代理模式

如何理解代理模式？

思考抽象问题最好的办法就是具体化！

比如我们需要为一个业务方法在执行前后记录日志，为了达到解耦的目的，我们可以再新建一个类并定义一个新的业务方法，该方法既可以调用原业务方法，又可以在调用前后进行日志处理，例如：

CarProxy.class

public void move() {
   System.out.println("日志开始记录....");
   new Car().move();
   System.out.println("日志记录完成....");
}

代理模式的应用很多，比如Spring容器的延迟加载，AOP增强处理等。

一、静态代理

静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。

所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

一句话，自己手写代理类就是静态代理。

基于继承的静态代理

目标对象：定义一个普通方法

public class Car {
   public void move() {
       System.out.println("汽车开始启动");
       System.out.println("汽车跑到了终点");
   }
}

 代理对象：主要作用是继承目标对象，进行增强处理，并使用关键字super调用父类方法。

public class CarProxy extends Car {

   @Override
   public void move() {
       System.out.println("日志开始记录....");
       super.move();
       System.out.println("日志记录完成....");
   }

}

测试方法：实际上是调用代理对象的move()方法。

public static void main(String[] args) {
   Car car = new CarProxy();
   car.move();
}

基于接口的静态代理

共同接口：定义一个普通的接口方法

public interface Moveable {
   void move();
}

 目标对象：实现该接口方法。

public class Car implements Moveable {

   @Override
   public void move() {
       System.out.println("汽车行驶中....");
   }

}

 代理对象：调用目标对象的方法，并在调用前后进行增强处理。

public class CarProxy implements Moveable{
   private Moveable move;

   @Override
   public void move() {
       if(move==null){
           move = new Car();
       }
       System.out.println("开始记录日志：");
       move.move();
       System.out.println("记录日志结束！");

   }
}

测试方法：实际上是调用代理对象的move()方法。

public static void main(String[] args) throws Exception {
    Moveable m =new CarProxy();
    m.move();
}

静态代理的优缺点

优点：

业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理模式的共有优点。

缺点：

1）代理对象的一个接口只服务于一种类型的对象，如果要代理的类型很多，势必要为每一种类型的方法都进行代理，静态代理在程序规模稍大时就无法胜任了。

2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。显而易见，增加了代码维护的复杂度。

二、动态代理

动态代理是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成 。

简单来说，动态代理就是交给程序去自动生成代理类。

1、JDK的动态代理

JDK动态代理实现步骤：

1. 创建被代理的类以及实现的接口；

2. 创建一个实现接口InvocationHandler的类，它必须实现invoke方法；

3. 调用Proxy的newProxyInstance静态方法，创建一个代理类。

4. 通过代理对象调用目标方法。

代码示例

共同接口

public interface Moveable {
   String move();
}

目标对象：正常实现接口方法

public class Car implements Moveable {

   @Override
   public String move() {
       return "汽车行驶中";
   }

}

对目标对象的增强处理： 

public class LogHandler implements InvocationHandler{
   private Object target;

   public LogHandler(Object object){
       super();
       this.target =  object;
   }

   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       //增强处理
       Object o = method.invoke(target,args);
       //增强处理
       return o;
   }

}

实现InvocationHandler接口步骤：

1. 定义含参构造方法，该参数为要代理的实例对象，目的是用于执行method.invoke()方法（也就是执行目标方法）

2. 实现接口的invoke()方法，该方法用于对目标方法的增强处理，比如记录日志等。该方法的返回值就是代理对象执行目标方法的返回值。

具体参数：

1. proxy 动态生成的代理对象

2. method 目标方法的实例

3. args 目标方法的参数

测试方法：

public static void main(String[] args) {
   Moveable move =  (Moveable) Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(), new LogHandler(new Car()));

   System.out.println("代理对象:"+move.getClass().getName());
   System.out.println("执行方法:"+move.move());
}

通过调用Proxy.newProxyInstance方法生成代理对象，具体参数有：

1. loader 目标类的类加载器

2. interfaces 目标类实现的接口

3. InvocationHandler 调用处理程序的实现对象

 打印结果

代理对象:com.sun.proxy.$Proxy0
执行方法:汽车行驶中

值得一提的是，JDK动态代理针对每个代理对象都会有一个关联的调用处理程序，即实现InvocationHandler接口。当在代理对象上调用目标方法时，将对方法调用进行编码并将其分配给其实现 InvocationHandler 接口的 invoke 方法。

特点

JDK的动态代理只能代理实现了接口的类， 没有实现接口的类不能实现动态代理。

2、cglib的动态代理

引用cglib的依赖包

   cglib
   cglib-nodep
   2.2

为了方便思考它的原理，我把执行步骤按顺序写下 

public static void main(String[] args) {
       Enhancer enhancer = new Enhancer();
       //设置父类，被代理类（这里是Car.class）
       enhancer.setSuperclass(Car.class);
       //设置回调函数
       enhancer.setCallback(new MethodInterceptor() {
           @Override
           public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
               //增强处理...
               Object o= proxy.invokeSuper(obj, args);//代理类调用父类的方法
               //增强处理...
               return o;
           }
       });
       //创建代理类并使用回调（用父类Car去引用）
       Car car = (Car) enhancer.create();
       //执行目标方法
       System.out.println(car.move());
   }

方法拦截器

实现MethodInterceptor接口的intercept方法后，所有生成的代理方法都调用这个方法。

intercept方法的具体参数有：

1. obj 目标类的实例

2. method 目标方法实例（通过反射获取的目标方法实例）

3. args 目标方法的参数

4. proxy 代理类的实例

该方法的返回值就是目标方法的返回值。

特点

1. cglib的动态代理是针对类来实现代理。

2. 对指定目标类产生一个子类，通过方法拦截技术拦截所有父类方法的调用。

3. 因为是通过继承实现，final类无法使用。

 

具体详解请参考： https://mp.weixin.qq.com/s/a0d3POVcN4CfCrzVk-0-Jw