【Java设计模式】六、代理模式：静态代理、JDK + CGLIB动态代理

分手后的思念是犯贱 2024-04-23 15:52 7阅读 0赞

#### 文章目录 ####

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

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

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

## 1、代理对象 ##

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

![在这里插入图片描述][30d304a594c7423685ce137469d7882f.png]

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

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

## 2、代理模式结构 ##

有三种角色：

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

## 3、静态代理 ##

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

![在这里插入图片描述][78b0ea32fb344e72956b4c03700f5209.png]

定义卖火车票的规范：

//卖票接口
    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 ： 代理对象，即上面的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;
        }
    }

客户端：

//测试类
    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方法`  
    ![在这里插入图片描述][38df3d2408684c4089cc15348a82bf8f.png]
 *  传入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();
        }
    }

## 7、三种代理的对比 ##

关于JDK代理和CGLIB代理：

*  CGLIB底层用ASM字节码生成框架来生成代理类
 *  CGLIB不能对final关键字的类进行代理，因为`enhancer.setSuperclass`，动态生成的代理类是目标类的子类，而final类无法被继承
 *  JDK和CGLIB动态代理的效率，和JDK版本有关（JDK1.8后，JDK > CGLIB）
 *  总之，有接口用JDK动态代理，没接口，走CGLIB

关于动态和静态代理：

当抽象主题接口新增了一个方法，则静态代理下的写的代理类也需要去实现此方法，维护复杂。动态代理无此问题。

## 8、代理模式的总结 ##

优点：

*  代理模式在客户端与目标对象之间起到了一个中介作用 + 保护目标对象
 *  代理对象中可以扩展目标对象的功能（上面代售点加服务费、AOP增强）
 *  代理模式将客户端和目标对象解耦

缺点：

*  增加了复杂度

> 使用场景：
> 
> ![在这里插入图片描述][60d41707cb2b4acaaf9bd4b545438df7.png]

[30d304a594c7423685ce137469d7882f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/b03bbe4bd540415fbe15491fe881ba40.png
[78b0ea32fb344e72956b4c03700f5209.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/856eb15463314e718cddb60c3fc49d93.png
[38df3d2408684c4089cc15348a82bf8f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/5d5e73c3b72d450f8740acb27a0fbccd.png
[60d41707cb2b4acaaf9bd4b545438df7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/7947158ca87647d890cf0564353923a8.png