java设计模式结构型模式

 结构型模式：

– 核心作用：是从程序的结构上实现松耦合，从而可以扩大整体的类结 构，用来解决更大的问题

分类： • 适配器模式、代理模式、桥接模式、 装饰模式、组合模式、外观模式、享元模式

结构型模式汇总

代理模式 为真实对象提供一个代理，从而控制对真实对象的访问 适配模式 使原本由于接口不兼容不能一起工作的类可以一起工作

桥接模式 处理多层继承结构，处理多维度变化的场景，将各个维度设计成独立的继 承结构，使各个维度可以独立的扩展在抽象层建立关联。

组合模式 将对象组合成树状结构以表示”部分和整体”层次结构，使得客户可以统一 的调用叶子对象和容器对象

装饰模式 动态地给一个对象添加额外的功能，比继承灵活 外观模式 为子系统提供统一的调用接口，使得子系统更加容易使用

享元模式 运用共享技术有效的实现管理大量细粒度对象，节省内存，提高效率

适配器adapter模式：

什么是适配器模式? – 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原 本由于接口不兼容而不能一起工作的那些类可以在一起工作。 

 模式中的角色：

 目标接口（Target）：客户所期待的接口。目标可以是具体的或抽象 的类，也可以是接口。

– 需要适配的类（Adaptee）：需要适配的类或适配者类。 – 适配器（Adapter）：通过包装一个需要适配的对象，把原接口转换成 目标接口。

public class Adpatee {
	public void request() {
		System.out.println("可以完成客户请求需要的功能！");
	}
}

　　

//适配器(对象适配器方式，使用了组合的方式)
public class Adapter2 implements Target {
	private Adpatee adaptee;

	@Override
	public void handleReq() {
		adaptee.request();
	}

	public Adapter2(Adpatee adaptee) {
		super();
		this.adaptee = adaptee;
	}
}

　　

//适配器
public class Adpater extends Adpatee implements Target{
	@Override
	public void handleReq(){
		super.request();
	}
}

　　

//客户端类
public class Client {
	public void test1(Target t) {
		t.handleReq();
	}
	public static void main(String[] args) {
		Client c=new Client();
		Adpatee a=new Adpatee();
		
		//Target t=new Adpater();
		Target t=new Adapter2(a);
		c.test1(t);
	}
}

　　

public interface Target {
	void handleReq();
}

　　代理模式(Proxy  pattern)： 

– 核心作用：

• 通过代理，控制对对象的访问！ 可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后 做后置处理。（即：AOP的微观实现！）

AOP(Aspect Oriented Programming面向切面编程)的核心实现机制！

代理模式(Proxy pattern)： – 核心角色：

• 抽象角色 – 定义代理角色和真实角色的公共对外方法

• 真实角色 – 实现抽象角色，定义真实角色所要实现的业务逻辑， 供代理角色调用。 – 关注真正的业务逻辑！

• 代理角色 – 实现抽象角色，是真实角色的代理，通过真实角色 的业务逻辑方法来实现抽象方法，并可以附加 自己的操作。
– 将统一的流程控制放到代理角色中处理！

代理模式：

应用场景：

– 安全代理：屏蔽对真实角色的直接访问。

– 远程代理：通过代理类处理远程方法调用(RMI)

– 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。

• 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以 使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。

• 分类：

– 静态代理(静态定义代理类) – 动态代理(动态生成代理类)

• JDK自带的动态代理

• javaassist字节码操作库实现

• CGLIB

• ASM(底层使用指令，可维护性较差)

静态代理：

• 静态代理(静态定义代理类)

动态代理：

 动态代理(动态生成代理类)

• JDK自带的动态代理

• javaassist字节码操作库实现

• CGLIB

• ASM(底层使用指令，可维护性较差)

动态代理的优点：

动态代理相比于静态代理的优点

– 抽象角色中(接口)声明的所以方法都被转移到调用处理器一个集中的方 法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

动态代理（JDK自带的实现）

JDK自带的动态代理 – java.lang.reflect.Proxy • 作用：动态生成代理类和对象 – java.lang.reflect.InvocationHandler(处理器接口) • 可以通过invoke方法实现对真实角色的代理访问。 • 每次通过Proxy生成代理类对象对象时都要指定对应的处理器对象

Star   realStar = new RealStar(); 
StarHandler handler = new StarHandler(realStar);
 Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Star.class},handler);
 proxy.sing();

　实现例子：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class StarHandler implements InvocationHandler{

	Star realStar;
	public StarHandler(Star realStar){
		super();
		this.realStar=realStar;
	}
	@Override
	public Object invoke(Object arg0, Method mathod, Object[] arg) throws Throwable {
		mathod.invoke(realStar, arg);
		Object obj=null;
		if(mathod.getName().equals("sing")){
			obj=mathod.invoke(realStar, arg);
		}
		return null;
	}
}

　　

import java.lang.reflect.Proxy;

public class Client {
	public static void main(String[] args) {
		Star realStar = new RealStar();
		StarHandler handler = new StarHandler(realStar);
		Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[] { Star.class },
				handler);

		proxy.bookTicket();
		proxy.sing();
	}
}

　　动态代理：

public class StarHandler implements InvocationHandler{

	Star realStar;
	public StarHandler(Star realStar){
		super();
		this.realStar=realStar;
	}
	@Override
	public Object invoke(Object arg0, Method mathod, Object[] arg) throws Throwable {
		mathod.invoke(realStar, arg);
		Object obj=null;
		if(mathod.getName().equals("sing")){
			obj=mathod.invoke(realStar, arg);
		}
		return null;
	}
}

　　

	StarHandler handler;
	public PxoxyStar(StarHandler handler){
		super();
		this.handler=handler;
	}
	@Override
	public void confer() {
		// TODO Auto-generated method stub
		
	}

　　

public class Client {
	public static void main(String[] args) {
		Star realStar = new RealStar();
		StarHandler handler = new StarHandler(realStar);
		Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[] { Star.class },
				handler);

		proxy.bookTicket();
		proxy.sing();
	}
}