【Java设计模式】六、代理模式：静态代理、JDK + CGLIB动态代理-编程知识

文章目录

1、代理对象
2、代理模式结构
3、静态代理
4、JDK动态代理
5、JDK动态代理的原理
6、CGLIB动态代理
7、三种代理的对比
8、代理模式的总结

结构型设计是将类或者对象按某种布局（继承机制、组合聚合）来组成更大结构。包括七种：

* 代理模式
* 适配器模式
* 装饰者模式
* 桥接模式
* 外观模式
* 组合模式
* 享元模式

1、代理对象

以买电脑为例，联想公司就是目标对象，地方代理商就是代理对象。

在这里插入图片描述

Java按照代理对象生成时机，分为：

静态代理：代理类在编译器就生成
动态代理：代理类在程序运行时动态生成。又分为JDK代理和CGLib代理

2、代理模式结构

有三种角色：

抽象主题类：定义一套规范
真实主题类：下面例子中的火车站类
代理类：下面例子中的代售点类

3、静态代理

直接去火车站买票，需要经历：坐车到火车站、排队等操作，麻烦（即目标对象不适合或不能直接访问到）。我们一般会到镇上就近的火车票代售点。此时，火车站为目标对象，代售点是代理对象。类图如下：注意，代理对象ProxyPoint聚合了目标对象（火车站TrainStation）

在这里插入图片描述

定义卖火车票的规范：

//卖票接口
public interface SellTickets {void sell();
}

定义火车站，实现规范接口：

//火车站  火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {public void sell() {System.out.println("火车站卖票");}
}

定义代售点类，和目标对象实现同一个接口（即抽象主题），聚合目标对象，代售点卖票，调用的也是目标对象（火车站对象）的卖票功能：

//代售点
public class ProxyPoint implements SellTickets {private TrainStation station = new TrainStation();    //目标对象public void sell() {System.out.println("代理点收取一些服务费用");station.sell();}
}

客户端测试：

public class Client {public static void main(String[] args) {ProxyPoint proxy = new ProxyPoint();   //创建代理对象proxy.sell();}
}

注意上面代理类自己sell方法里的这句：

System.out.println("代理点收取一些服务费用");

客户端直接访问的是代理对象，代理对象是一个目标对象和访问者的中介，同时也是对原来对象的一个增强！！！（如上面代理对象的sell就新增了收取服务费用的功能）

4、JDK动态代理

先是抽象主题和目标对象：

//卖票接口
public interface SellTickets {void sell();
}//火车站  火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {public void sell() {System.out.println("火车站卖票");}
}

JDK中有一个类Proxy，它不是上面提到的代理对象类，而是提供创建代理对象的静态方法newProxyInstance来获取代理对象

//代理工厂，用来创建代理对象
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 ： 代理对象，即上面的proxyObjectmethod ： 对应于在代理对象上调用的接口方法的 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;}
}

客户端：

//测试类
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();}
}

运行：

代理点收取一些服务费用(JDK动态代理方式)
火车站卖票

5、JDK动态代理的原理

注意上面定义的ProxyFactory不是代理类，代理类是程序运行过程中动态在内存中生成的类。使用阿尔萨斯下的jad指令，查看生成的代理类$Proxy0：

//简略版，删掉了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提供的动态代理相关类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：高性能的代码生成包

<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>2.2.2</version>
</dependency>

还是买票的案例，这次只有火车站这个具体主题类，没有SellTickets接口：

//火车站
public class TrainStation {public void sell() {System.out.println("火车站卖票");}
}

写代理工厂类，实现MethodInterceptor 接口，重写intercept方法。Enhancer的Callback设置回调，需要一个MethodInterceptor的子实现对象，此时传入代理工厂类对象后，就会回调intercept方法，intercept方法中又调用了真实对象的sell方法。关键点：

Enhancer对象
设置父类字节码对象为真实目标对象
设置回调，回调中调真实目标对象的对应方法

//代理工厂
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：上面的真实目标对象，即目标对象

//测试类
public class Client {public static void main(String[] args) {//创建代理工厂对象ProxyFactory factory = new ProxyFactory();//获取代理对象TrainStation proxyObject = factory.getProxyObject();proxyObject.sell();}
}