Java 动态代理

什么是动态代理

首先，动态代理是代理模式的一种实现方式，代理模式除了动态代理还有 静态代理，只不过静态代理能够在编译时期确定类的执行对象，而动态代理只有在运行时才能够确定执行对象是谁。代理可以看作是对最终调用目标的一个封装，能够通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合。
动态代理的应用场景有很多，最常见的就是 AOP 的实现、RPC 远程调用、Java 注解对象获取、日志框架、全局性异常处理、事务处理等。
动态代理的实现有很多，但是 JDK 动态代理是很重要的一种，下面就 JDK 动态代理来深入理解一波。

JDK 动态代理

首先先来看一下动态代理的执行过程
动态代理实现原理分析 - 图1
在 JDK 动态代理中，实现了 InvocationHandler 的类可以看作是 代理类(因为类也是一种对象，所以上面为了描述关系，把代理类形容成了代理对象)。JDK 动态代理就是围绕实现了 InvocationHandler 的代理类进行的，比如下面就是一个 InvocationHandler 的实现类，同时它也是一个代理类。

  1. public class UserHandler implements InvocationHandler {
  3.     private UserDao userDao;
  5.     public UserHandler(UserDao userDao){
  6.         this.userDao = userDao;
  7.     }
  9.     @Override
  10.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  11.         saveUserStart();
  12.         Object obj = method.invoke(userDao, args);
  13.         saveUserDone();
  14.         return obj;
  15.     }
  17.     public void saveUserStart(){
  18.         System.out.println("---- 开始插入 ----");
  19.     }
  21.     public void saveUserDone(){
  22.         System.out.println("---- 插入完成 ----");
  23.     }
  24. }

代理类一个最最最重要的方法就是 invoke 方法，它有三个参数

  • Object proxy: 动态代理对象，关于这个方法后面会说。
  • Method method: 表示最终要执行的方法，method.invoke 用于执行被代理的方法，也就是真正的目标方法
  • Object[] args: 这个参数就是向目标方法传递的参数。

这里构造好了代理类，现在就要使用它来实现对目标对象的调用，那么如何操作呢？请看下面代码

  1. public static void dynamicProxy(){
  3.     UserDao userDao = new UserDaoImpl();
  4.     InvocationHandler handler = new UserHandler(userDao);
  6.     ClassLoader loader = userDao.getClass().getClassLoader();
  7.     Class<?>[] interfaces = userDao.getClass().getInterfaces();
  9.     UserDao proxy = (UserDao)Proxy.newProxyInstance(loader, interfaces, handler);
  10.     proxy.saveUser();
  11. }

如果要用 JDK 动态代理的话，就需要知道目标对象的类加载器、目标对象的接口，当然还要知道目标对象是谁。构造完成后，就可以调用 Proxy.newProxyInstance方法，然后把类加载器、目标对象的接口、目标对象绑定上去就完事儿了。
这里需要注意一下 Proxy 类，它就是动态代理实现所用到的代理类。
Proxy 位于java.lang.reflect 包下，这同时也旁敲侧击的表明动态代理的本质就是反射。
下面就围绕 JDK 动态代理，来深入理解一下它的原理，以及搞懂为什么动态代理的本质就是反射。

动态代理的实现原理

在了解动态代理的实现原理之前，先来了解一下 InvocationHandler 接口

InvocationHandler 接口

JavaDoc 告诉我们，InvocationHandler 是一个接口，实现这个接口的类就表示该类是一个代理实现类，也就是代理类。
动态代理实现原理分析 - 图2
InvocationHandler 接口中只有一个 invoke 方法。
动态代理的优势在于能够很方便的对代理类中方法进行集中处理，而不用修改每个被代理的方法。因为所有被代理的方法（真正执行的方法）都是通过在 InvocationHandler 中的 invoke 方法调用的。所以只需要对 invoke 方法进行集中处理。
invoke 方法只有三个参数

  1. public Object invoke(Object proxy, Method method, Object[] args)
  2.         throws Throwable;
  • proxy：代理对象
  • method: 代理对象调用的方法
  • args：调用方法中的参数。

动态代理的整个代理过程不像静态代理那样一目了然，清晰易懂，因为在动态代理的过程中，没有看到代理类的真正代理过程，也不明白其具体操作，所以要分析动态代理的实现原理，必须借助源码。
那么问题来了，首先第一步应该从哪分析？如果不知道如何分析的话，干脆就使用倒推法，从后往前找，直接先从 _Proxy.newProxyInstance_入手，看看是否能略知一二。

Proxy.newInstance 方法分析

Proxy 提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。
Proxy.newProxyInstance 源码（java.lang.reflect.Proxy）

  1. public static Object newProxyInstance(ClassLoader loader,
  2.                                       Class<?>[] interfaces,
  3.                                       InvocationHandler h)
  4.     throws IllegalArgumentException
  5.     {
  6.     Objects.requireNonNull(h);
  8.     final Class<?>[] intfs = interfaces.clone();
  9.     final SecurityManager sm = System.getSecurityManager();
  10.     if (sm != null) {
  11.     checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  12.     }
  14.     Class<?> cl = getProxyClass0(loader, intfs);
  16.     try {
  17.     if (sm != null) {
  18.     checkNewProxyPermission(Reflection.getCallerClass(), cl);
  19.     }
  21.     final Constructor<?> cons = cl.getConstructor(constructorParams);
  22.     final InvocationHandler ih = h;
  23.     if (!Modifier.isPublic(cl.getModifiers())) {
  24.     AccessController.doPrivileged(new PrivilegedAction<Void>() {
  25.     public Void run() {
  26.     cons.setAccessible(true);
  27.     return null;
  28.     }
  29.     });
  30.     }
  31.     return cons.newInstance(new Object[]{h});
  32.     } catch (Exception e) {
  33.     ...
  34. }

乍一看起来有点麻烦，其实源码都是这样，看起来非常复杂，但是慢慢分析、厘清条理过后就好，最重要的是分析源码不能着急。
上面这个 Proxy.newProxyInstsance 其实就做了下面几件事，这里画了一个流程图作为参考。
动态代理实现原理分析 - 图3
从上图中也可以看出，newProxyInstsance 方法最重要的几个环节就是获得代理类、获得构造器，然后构造新实例。
对反射有一些了解的同学，应该会知道获得构造器和构造新实例是怎么回事。
所以重点就放在了获得代理类，这是最关键的一步，对应源码中的 _Class<?> cl = getProxyClass0(loader, intfs);_ 进入这个方法一探究竟

  1. private static Class<?> getProxyClass0(ClassLoader loader,
  2.                                        Class<?>... interfaces) {
  3.     if (interfaces.length > 65535) {
  4.         throw new IllegalArgumentException("interface limit exceeded");
  5.     }
  6.     return proxyClassCache.get(loader, interfaces);
  7. }

这个方法比较简单，首先会直接判断接口长度是否大于 65535（刚开始看到这里是有点不明白的，这个判断是要判断什么？interfaces 这不是一个 class 类型吗，从 length 点进去也看不到这个属性，细看一下才明白，这居然是可变参数，Class … 中的 … 就是可变参数，所以这个判断应该是判断接口数量是否大于 65535。）
然后会直接从 proxyClassCache 中根据 loader 和 interfaces 获取代理对象实例。如果能够根据 loader 和 interfaces 找到代理对象，将会返回缓存中的对象副本；否则，它将通过 ProxyClassFactory 创建代理类。
proxyClassCache.get 就是一系列从缓存中的查询操作，注意这里的 proxyClassCache 其实是一个 WeakCache，WeakCahe 也是位于 java.lang.reflect 包下的一个缓存映射 map，它的主要特点是一个弱引用的 map，但是它内部有一个 SubKey ，这个子键却是强引用的。
这里不用去追究这个 proxyClassCache 是如何进行缓存的，只需要知道它的缓存时机就可以了：即在类加载的时候进行缓存。
如果无法找到代理对象，就会通过 ProxyClassFactory 创建代理，ProxyClassFactory 继承于 BiFunction

  1. private static final class ProxyClassFactory
  2.         implements BiFunction<ClassLoader, Class<?>[], Class<?>>
  3.     {...}

ProxyClassFactory 里面有两个属性一个方法。
动态代理实现原理分析 - 图4

  • proxyClassNamePrefix：这个属性表明使用 ProxyClassFactory 创建出来的代理实例的命名是以 “$Proxy” 为前缀的。
  • nextUniqueNumber：这个属性表明 ProxyClassFactory 的后缀是使用 AtomicLong 生成的数字

所以代理实例的命名一般是 Proxy1这种。
这个 apply 方法是一个根据接口和类加载器进行代理实例创建的工厂方法，下面是这段代码的核心。

  1. @Override
  2. public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
  4.     ...
  6.     long num = nextUniqueNumber.getAndIncrement();
  7.     String proxyName = proxyPkg + proxyClassNamePrefix + num;
  9.     byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
  10.         proxyName, interfaces, accessFlags);
  11.     try {
  12.         return defineClass0(loader, proxyName,
  13.                             proxyClassFile, 0, proxyClassFile.length);
  14.     } catch (ClassFormatError e) {
  15.         throw new IllegalArgumentException(e.toString());
  16.     }
  17. }

可以看到，代理实例的命名就是上面所描述的那种命名方式，只不过它这里加上了 proxyPkg 包名的路径。然后下面就是生成代理实例的关键代码。
ProxyGenerator.generateProxyClass 跟进去是只能看到 .class 文件的，class 文件是虚拟机编译之后的结果，所以要看一下 .java 文件源码。.java 源码位于 OpenJDK中的 sun.misc 包中的 ProxyGenerator 下。
此类的 generateProxyClass() 静态方法的核心内容就是去调用 generateClassFile() 实例方法来生成 Class 文件。方法太长了就不贴了，这里就大致解释以下其作用：

  • 第一步：收集所有要生成的代理方法，将其包装成 ProxyMethod 对象并注册到 Map 集合中。
  • 第二步：收集所有要为 Class 文件生成的字段信息和方法信息。
  • 第三步：完成了上面的工作后，开始组装 Class 文件。

而 defineClass0 这个方法点进去是 native ，底层是 C/C++ 实现的，于是去看了一下 C/C++ 源码，路径在
动态代理实现原理分析 - 图5
点开之后的 C/C++ 源码还是挺让人绝望的。
动态代理实现原理分析 - 图6
不过再回头看一下这个 defineClass0 方法，它实际上就是根据上面生成的 proxyClassFile 字节数组来生成对应的实例罢了，所以不必再深究 C/C++ 对于代理对象的合成过程了。
所以总结一下可以看出，JDK 生成了一个叫 $Proxy0 的代理类，这个类文件放在内存中的，在创建代理对象时，就是通过反射获得这个类的构造方法，然后创建的代理实例。
所以最开始的 dynamicProxy 方法反编译后的代码就是这样的

  1. public final class $Proxy0 extends java.lang.reflect.Proxy implements com.cxuan.dynamic.UserDao {
  2.   public $Proxy0(java.lang.reflect.InvocationHandler) throws ;
  3.     Code:
  4.        0: aload_0
  5.        1: aload_1
  6.        2: invokespecial #8                  // Method java/lang/reflect/Proxy."<init>":(Ljava/lang/reflect/InvocationHandler;)V
  7.        5: return

可以看到代理类继承了 Proxy 类，所以也就决定了 Java 动态代理只能对接口进行代理。
动态代理实现原理分析 - 图7
于是，上面这个图应该就可以看懂了。

invoke 方法中第一个参数 proxy 的作用

细心的小伙伴们可能都发现了，invoke 方法中第一个 proxy 的作用是啥？代码里面好像 proxy 也没用到，这个参数的意义是啥呢？它运行时的类型是啥啊？为什么不使用 this 代替呢？
动态代理实现原理分析 - 图8
Stackoverflow 给出了一个回答 https://stackoverflow.com/questions/22930195/understanding-proxy-arguments-of-the-invoke-method-of-java-lang-reflect-invoca
什么意思呢？
就是说这个 proxy ，它是真正的代理对象，invoke 方法可以返回调用代理对象方法的返回结果，也可以返回对象的真实代理对象，也就是 $Proxy0，这也是它运行时的类型。
至于为什么不用 this 来代替 proxy，因为实现了 InvocationHandler 的对象中的 this ，指代的还是 InvocationHandler 接口实现类本身，而不是真实的代理对象。