Java 代理模式

首先我们需要明白Java的代理模式能做什么？给我们带来的好处是什么？

代理模式：一个最大的优点就是隐藏目标类、对目标类的访问都是通过代理类来实现。

带来的好处：通过代理访问目标对象，那么在代理中就可以对目标对象进行扩展。 在不修改目标对象源码的基础上，通过代理可以实现对目标对象进行扩展。比如Spring AOP就是基于代理模式的思想实现的。在切面前，切面后去实现一些逻辑处理比如日志打印，或者是对目标对象一些功能的扩展等。我们无需修改目标对象。

接下来我们看下：Java代理模式实现的3种方式

1.静态代理

2.JDK动态代理（也称接口代理）

3.cglib动态代理（也称子类代理）

首先我们看下代理模式的结构图

上图可以看到一个比较重要的是：目标对象与代理对象都实现一个业务接口。并且代理对象持有目标对象的引用。

接下来我们来看下静态代理与动态代理的区分：

静态代理：由程序员创建或特定工具自动生成源代码，也就是在编译时就已经将接口、被代理类、代理类等确定下来。在程序运行之前，代理类的.class文件就已经生成。

动态代理：代理类在程序运行时创建的代理方式被成为动态代理。

接下来我们看下静态代理具体的实现场景

  根据上面的结构图：我们假设一个场景，学生教班费给老师。老师派一个任务给到班长。让班长去收班费：那么班长就是学生的一个代理。代理收班费：

首先：我们需要定义一个接口：
public interface Student{
   //上交班费
  void handleFee();
}

定义目标类：
public class TargetStudent implements Student{

    private String name;
    public TargetStudent (String name) {
        this.name = name;
    }
    
    @Override
    public void handleFee() {
       System.out.println(name + "上交班费50元");
    }

}

 定义代理类：
 public class StudentsProxy implements Person{
    //被代理的学生
    TargetStudent stu;
    
    public StudentsProxy(Person stu) {
        // 只代理目标学生对象
        if(stu.getClass() == TargetStudent .class) {
            this.stu = (Student)stu;
        }
    }
    
    //代理上交班费，调用被代理学生的上交班费行为
    public void handleFee() {
        stu.handleFee();
    }
}

客户端调用
public class StaticProxyTest {
    public static void main(String[] args) {
        //被代理的学生张三，他的班费上交有代理对象monitor（班长）完成
        Person zhangsan = new Student("张三");
        
        //生成代理对象，并将张三传给代理对象
        Person proxy= new StudentsProxy(zhangsan);
        
        //班长代理上交班费
        proxy.handleFee();
    }

}
 

静态代理的代码大家应该很好理解：真正上交班费的是班长代理对象：

看完静态代理的实现，我们看下动态代理:

相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。 比如说，想要在每个代理的方法前都加上一个处理方法：

    //代理上交班费，调用被代理学生的上交班费行为
    public void handleFee() {
         call();
        stu.handleFee();
    }

如果针对上交班费的时候，老师让我们叫张三同学去她办公室，调用一个call方法、叫李四同学去打扫卫生、那么这还需要针对不同的学生，在交班费的时候有不同的处理逻辑，这个时候，我们就会频繁的去更改上交班费的实现逻辑，显得很麻烦。这个时候我们就需要用到动态代理了。

首先我们还是定义接口类
public interface Student{
   //上交班费
   void handleFee();
}

定义目标类：
public class TargetStudent implements Student{

    private String name;
    public TargetStudent(String name) {
        this.name = name;
    }
    
    @Override
    public void handleFee() {
       System.out.println(name + "上交班费50元");
    }

}

接口与目标类的实现与静态代理的方式差不太多。

主要的差异点，在与代理类的生成

public class StuInvocationHandler<T> implements InvocationHandler {

    /**
     * invocationHandler持有的被代理对象
     */
    T target;

    public StuInvocationHandler(T target){
        this.target = target;
    }

    /**
     * proxy:代表动态代理对象
     * method：代表正在执行的方法
     * args：代表调用目标方法时传入的实参
     */

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(target, args);
        return result;
    }
}

客户端调用
public class ProxyClient {

    public static void main(String[] args) {

        //创建一个实例对象，这个对象是被代理的对象
        Student zhangSan = new TargetStudent("张三");

        //创建一个与代理对象相关联的InvocationHandler
        InvocationHandler stuHandler = new StuInvocationHandler<Student>(zhangSan);

        //创建一个代理对象stuProxy来代理zhangsan，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
        Student stuProxy = (Student) Proxy.newProxyInstance(Student.class.getClassLoader(), new Class<?>[]{Student.class}, stuHandler);

        //代理执行上交班费的方法
        stuProxy.handleFee();
    }
}

创建了一个需要被代理的学生张三，将zhangsan对象传给了stuHandler中，我们在创建代理对象stuProxy时，将stuHandler作为参数了的，上面也有说到所有执行代理对象的方法都会被替换成执行invoke方法，也就是说，最后执行的是StuInvocationHandler中的invoke方法。

动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。是因为所有被代理执行的方法，都是通过在InvocationHandler中的invoke方法调用的，所以我们只要在invoke方法中统一处理，就可以对所有被代理的方法进行相同的操作了。例如，这里的方法计时，所有的被代理对象执行的方法都会被计时，然而我只做了很少的代码量。

接下来我们针对动态代理的原理进行分析：

看proxyClient客户端的代码：我们可以看到：

第一步：我们创建了目标对象的实例。

第二步：我们创建了一个和目标对象相关联的InvocationHandler 对象。

第三步：生成代理对象。

第四步：通过代理对象访问目标对象的方法。

我们从生成代理对象开始分析：

其生成的原理：通过java的反射生成一个proxy的类文件存放在内存中，并有缓存处理。

返回利用java的反射技术。获取到一个代理对象proxy 的实例。

 private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

         //通过类加载器获取到代理的class文件。并用反射生成proxy实例
//如果缓存中有，就从缓存中返回，如果没有，就在内存中新生成一个proxy的class文件返回
        return proxyClassCache.get(loader, interfaces);
    }

明白代理对象生成后，我们来看下，Proxy类与接口InvocationHandler之间的关系：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import proxy.Person;
 
public final class $Proxy0 extends Proxy implements Person {
  private static Method m1;
  private static Method m2;
  private static Method m3;
  private static Method m0;
  
  /**
  *注意这里是生成代理类的构造方法，方法参数为InvocationHandler类型，看到这，是不是就有点明白
  *为何代理对象调用方法都是执行InvocationHandler中的invoke方法，而InvocationHandler又持有一个
  *被代理对象的实例，不禁会想难道是....？ 没错，就是你想的那样。
  *
  *super(paramInvocationHandler)，是调用父类Proxy的构造方法。
  *父类持有：protected InvocationHandler h;
  *Proxy构造方法：
  *    protected Proxy(InvocationHandler h) {
  *         Objects.requireNonNull(h);
  *         this.h = h;
  *     }
  *
  */
  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }
  
  //这个静态块本来是在最后的，我把它拿到前面来，方便描述
   static
  {
    try
    {
      //看看这儿静态块儿里面有什么，是不是找到了handleFee方法。请记住handleFee通过反射得到的名字m3，其他的先不管
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m3 = Class.forName("proxy.Person").getMethod("handleFee", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
 
  /**
  * 
  *这里调用代理对象的handleFee方法，直接就调用了InvocationHandler中的invoke方法，并把m3传了进去。
  *this.h.invoke(this, m3, null);这里简单，明了。
  *来，再想想，代理对象持有一个InvocationHandler对象，InvocationHandler对象持有一个被代理的对象，
  *再联系到InvacationHandler中的invoke方法。嗯，就是这样。
  */
  public final void handleFee()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
 
 

从上面proxy Class文件生成的逻辑中，我们可以明白在代理对象的构造器中传入了一个InvocationHandler 对象，这就是为什么newProxyInstance方法的时候需要传入一个InvocationHandler对象. 

另外：

JDK和CGLIB动态代理总结
JDK动态代理只能对实现了接口的类生成代理，而不能针对类 ，使用的是 Java反射技术实现，生成类的过程比较高效。
CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法 ，使用asm字节码框架实现，相关执行的过程比较高效，生成类的过程可以利用缓存弥补，因为是继承，所以该类或方法最好不要声明成final 
JDK代理是不需要第三方库支持，只需要JDK环境就可以进行代理，使用条件:实现InvocationHandler + 使用Proxy.newProxyInstance产生代理对象 + 被代理的对象必须要实现接口
CGLib必须依赖于CGLib的类库，但是它需要类来实现任何接口代理的是指定的类生成一个子类，覆盖其中的方法，是一种继承但是针对接口编程的环境下推荐使用JDK的代理；

参考文献：
https://blog.csdn.net/xiaofeng10330111/article/details/105633821