文章目录
结构型设计是将类或者对象按某种布局（继承机制、组合聚合）来组成更大结构。包括七种：
java
* 代理模式
* 适配器模式
* 装饰者模式
* 桥接模式
* 外观模式
* 组合模式
* 享元模式1、代理对象
以买电脑为例，联想公司就是目标对象，地方代理商就是代理对象。
Java按照代理对象生成时机，分为：
- 静态代理：代理类在编译器就生成
- 动态代理：代理类在程序运行时动态生成。又分为JDK代理和CGLib代理
2、代理模式结构
有三种角色：
- 抽象主题类：定义一套规范
- 真实主题类：下面例子中的火车站类
- 代理类：下面例子中的代售点类
3、静态代理
直接去火车站买票，需要经历：坐车到火车站、排队等操作，麻烦（即目标对象不适合或不能直接访问到）。我们一般会到镇上就近的火车票代售点。此时，火车站为目标对象，代售点是代理对象。类图如下：注意，代理对象ProxyPoint聚合了目标对象（火车站TrainStation）
定义卖火车票的规范：
java
//卖票接口
public interface SellTickets {
void sell();
}定义火车站，实现规范接口：
java
//火车站 火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {
public void sell() {
System.out.println("火车站卖票");
}
}定义代售点类，和目标对象实现同一个接口（即抽象主题），聚合目标对象，代售点卖票，调用的也是目标对象（火车站对象）的卖票功能：
java
//代售点
public class ProxyPoint implements SellTickets {
private TrainStation station = new TrainStation(); //目标对象
public void sell() {
System.out.println("代理点收取一些服务费用");
station.sell();
}
}客户端测试：
java
public class Client {
public static void main(String[] args) {
ProxyPoint proxy = new ProxyPoint(); //创建代理对象
proxy.sell();
}
}注意上面代理类自己sell方法里的这句：
java
System.out.println("代理点收取一些服务费用");客户端直接访问的是代理对象，代理对象是一个目标对象和访问者的中介，同时也是对原来对象的一个增强！！！（如上面代理对象的sell就新增了收取服务费用的功能）
4、JDK动态代理
先是抽象主题和目标对象：
java
//卖票接口
public interface SellTickets {
void sell();
}
//火车站 火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {
public void sell() {
System.out.println("火车站卖票");
}
}JDK中有一个类Proxy，它不是上面提到的代理对象类 ，而是提供创建代理对象的静态方法newProxyInstance来获取代理对象
java
//代理工厂，用来创建代理对象
public class ProxyFactory {
//声明目标对象
private TrainStation station = new TrainStation();
//返回代理对象
public SellTickets getProxyObject() {
//使用Proxy获取代理对象
/*
newProxyInstance()方法参数说明：
ClassLoader loader ： 类加载器，用于加载代理类，使用真实对象的类加载器即可
Class<?>[] interfaces ： 真实对象所实现的接口，但代理模式下，真实对象和代理对象实现相同的接口，这里依旧用目标对象（真实对象）+ getInterfaces拿到接口类对象
InvocationHandler h ： 代理对象的调用处理程序
*/
SellTickets proxyObject = (SellTickets) Proxy.newProxyInstance(station.getClass().getClassLoader(),
station.getClass().getInterfaces(),
new InvocationHandler() {
/*
InvocationHandler中invoke方法参数说明：
proxy ： 代理对象，即上面的proxyObject
method ： 对应于在代理对象上调用的接口方法的 Method 实例
args ： 通过代理对象调用接口方法时传递的实际参数
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理点收取一些服务费用(JDK动态代理方式)");
//执行真实对象，调用method的invoke，传入调用方法的对象和方法的实参
Object result = method.invoke(station, args);
return result;
}
});
return proxyObject;
}
}客户端：
java
//测试类
public class Client {
public static void main(String[] args) {
//创建代理对象工厂
ProxyFactory factory = new ProxyFactory();
//获取代理对象（proxyObject.getClass发现其全类名是com.sun.proxy.$Proxy0）
SellTickets proxyObject = factory.getProxyObject();
//通过代理对象调用买票的方法
proxyObject.sell();
}
}运行：
java
代理点收取一些服务费用(JDK动态代理方式)
火车站卖票5、JDK动态代理的原理
注意上面定义的ProxyFactory不是代理类，代理类是程序运行过程中动态在内存中生成的类。使用阿尔萨斯下的jad指令，查看生成的代理类$Proxy0：
java
//简略版，删掉了hashcode、equals等方法
com.sun.proxy.$Proxy0
//程序运行过程中动态生成的代理类
public final class $Proxy0 extends Proxy implements SellTickets {
private static Method m3;
public $Proxy0(InvocationHandler invocationHandler) {
super(invocationHandler);
}
static {
m3 = Class.forName("com.myplat.proxy.dynamic.jdk.SellTickets").getMethod("sell", new Class[0]);
}
public final void sell() {
this.h.invoke(this, m3, null);
}
}而其父类Proxy：
java
//Java提供的动态代理相关类
public class Proxy implements java.io.Serializable {
protected InvocationHandler h;
protected Proxy(InvocationHandler h) {
this.h = h;
}
}
.....略发现：
- 代理类$Proxy0实现了抽象主题SellTickets接口（符合：真实的目标对象和代理对象实现了同样的接口）
- 代理类$Proxy0又将我在newProxyInstance传入的InvocationHandler传给了父类的h属性
因此，以上的完整过程是：
- 测试类中通过代理对象调用sell方法
- 到了$Proxy0的sell方法中
h.invoke即newProxyInstance方法中传入的第三个匿名内部类对象h中重写的invoke方法
- 传入invoke的三个实参为：proxy代理对象自己（即this），m3（静态代码块中初始化的抽象主题SellTickets的sell方法），sell方法的实参（null）
- invoke方法中则通过反射，执行真实对象所属类TrainStation中的sell方法并返回，相关代码：
Object result = method.invoke(station, args);
6、CGLIB动态代理
前面JDK动态代理Proxy.newProxyInstance方法的第二个形参是真实对象所实现的接口，当上面的案例没有抽象主题接口SellTickets时，则JDK代理无法使用了（看阿尔萨斯拿到的代理类$Proxy0，静态代码块要Class.forName加载newProxyInstance传入的抽象主题接口，现在没这个接口了，自然不能用了）
此时可用CGLIB：高性能的代码生成包
xml
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>还是买票的案例，这次只有火车站这个具体主题类，没有SellTickets接口：
java
//火车站
public class TrainStation {
public void sell() {
System.out.println("火车站卖票");
}
}写代理工厂类，实现MethodInterceptor 接口，重写intercept方法。Enhancer的Callback设置回调，需要一个MethodInterceptor的子实现对象，此时传入代理工厂类对象后，就会回调intercept方法，intercept方法中又调用了真实对象的sell方法。关键点：
- Enhancer对象
- 设置父类字节码对象为真实目标对象
- 设置回调，回调中调真实目标对象的对应方法
java
//代理工厂
public class ProxyFactory implements MethodInterceptor {
//声明真实目标对象
private TrainStation station = new TrainStation();
//通过CGLIB获取代理对象
public TrainStation getProxyObject() {
//创建Enhancer对象，类似于JDK动态代理的Proxy类，下一步就是设置几个参数
Enhancer enhancer =new Enhancer();
//设置父类的字节码对象
enhancer.setSuperclass(TrainStation.class);
//设置回调函数
enhancer.setCallback(this);
//创建代理对象
TrainStation proxyObj = (TrainStation) enhancer.create();
return proxyObj;
}
/*
intercept方法参数说明：
o ： 代理对象
method ： 真实对象中的方法的Method实例
args ： 实际参数
methodProxy ：代理对象中的方法的method实例
*/
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//对原真实目标对象的方法按实际需求做点增强
System.out.println("代理点收取一些服务费用(CGLIB动态代理方式)");
//调用真实目标对象的方法
Object result = method.invoke(station, args);
//也可用invokeSuper调用目标对象的方法（因为前面设置了代理对象的父类字节码对象为真实目标对象，他们之间是父子关系）
//TrainStation result = (TrainStation) methodProxy.invokeSuper(o, args);
return result;
}
}PS：上面的真实目标对象，即目标对象
java
//测试类
public class Client {
public static void main(String[] args) {
//创建代理工厂对象
ProxyFactory factory = new ProxyFactory();
//获取代理对象
TrainStation proxyObject = factory.getProxyObject();
proxyObject.sell();
}
}7、三种代理的对比
关于JDK代理和CGLIB代理：
- CGLIB底层用ASM字节码生成框架来生成代理类
- CGLIB不能对final关键字的类进行代理，因为
enhancer.setSuperclass，动态生成的代理类是目标类的子类，而final类无法被继承 - JDK和CGLIB动态代理的效率，和JDK版本有关（JDK1.8后，JDK > CGLIB）
- 总之，有接口用JDK动态代理，没接口，走CGLIB
关于动态和静态代理：
当抽象主题接口新增了一个方法，则静态代理下的写的代理类也需要去实现此方法，维护复杂。动态代理无此问题。
8、代理模式的总结
优点：
- 代理模式在客户端与目标对象之间起到了一个中介作用 + 保护目标对象
- 代理对象中可以扩展目标对象的功能（上面代售点加服务费、AOP增强）
- 代理模式将客户端和目标对象解耦
缺点：
- 增加了复杂度
使用场景：
