JDK动态代理学习

关键类和接口：

• Proxy 类
• InvocationHandler 接口
• ProxyGenerator 类
• WeakCache 类
• Proxy.KeyFactory 类
• Proxy.ProxyClassFactory 类
• WeakCache.Factory 类

探索原理之前需要明白 JDK动态代理如何使用，首先需要自定义一个调用处理器对象 h ，这个h将会是连接代理对象和目标对象的中间桥梁，它决定了调用目标对象之前需要做一些什么事情，调用什么方法等等...

使用的时候像这样子，虽然 InvocationHandler 接口没有强制要求定义构造函数接收目标对象，但一般为了桥接目标对象肯定得拿到它的引用，除非你用代理类来做其他事情，不需要目标对象。

 在invoke()中，可以实现事务的控制，开启事务，提交事务，回滚事务等，实际上Spring的事务管理机制就是借由Spring AOP实现，AOP由JDK/CGLIB动态代理实现。

接下来就可以由 Proxy.newProxyInstance() 函数生成代理对象，代理对象继承了Proxy，实现了目标对象的所有接口。

在我们拿到 iHello2 对象时，它已经是一个代理对象了，这里值得注意的是：如果目标对象的接口数组中，有多个接口有相同的方法（方法名、方法形参相同），代理对象总是会调用最近一个接口的那个方法。例如 A B 接口都有 sayHello() ，B proxy = Proxy.newProxyInstance()，proxy.sayHello() 可能是调用到A接口中的 sayHello()。不过这并没有影响？因为接口没有实现。大多数情况下，最后也是由目标对象的方法去调用 sayHello()，我们的 h 只是做一些中间工作。

源码探索开始

一切的开端 Proxy.newProxyInstance() 

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
    throws IllegalArgumentException
{	
    // 强制要求 h 不为空
    Objects.requireNonNull(h);

    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
    // 这里是去检查目标对象的一组接口对于当前所给定的 类加载器 可不可以访问到，否则会报错
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }
     // 这个方法很关键，是生成代理类 Class对象，
     // 所有类均来自于 Class，Class对象就代表这个模板， 而对象就是Class的具体化。
    Class<?> cl = getProxyClass0(loader, intfs);

    try {
        if (sm != null) {
            // 去检查是否有权限生成Proxy？
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        // 生成的Class对象中会包含一个 h 的构造函数，拿到这个构造函数
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        // 最后通过这个构造函数，传入h，实例化一个Proxy！
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

由此我们拿到了Proxy，Proxy中包含所有目标对象的接口的方法，我们在使用Proxy时，就如同使用目标对象一般。这也是为什么可以由接口引用Proxy的根本原因。

所以目前生产Proxy的关键是如何拿到Class对象的。中间过程就有点绕了，从1.8后改为从一个缓存中获取，proxyClassCache就是

private static final WeakCache[], Class> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

接下来出现的 ProxyClassFactory 也是很重要的对象，看名字就知道专门生产ProxyClass的对象。

现在来到 WeakCache 对象中的get()，这里要搞明白形参，k 就是当前给定的类加载器，p 就是目标对象的一组接口。

public V get(K key, P parameter) {
    Objects.requireNonNull(parameter);
    expungeStaleEntries();
// 这里将 k 包装成一级缓存的key
    Object cacheKey = CacheKey.valueOf(key, refQueue);

    // map 是ConcurrentHashMap 就是那个装载所有Proxy的Class对象的缓存。
   // 通过一级key，获取一个二级缓存，二级缓存中保存着 由 k 装载的所有Class对象
    ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
    if (valuesMap == null) {
// 二级缓存为空，先生成二级缓存放进去做占位符，也是个ConcurrentHashMap，看来并发有点严重
        ConcurrentMap<Object, Supplier<V>> oldValuesMap
            = map.putIfAbsent(cacheKey,
                              valuesMap = new ConcurrentHashMap<>());
        if (oldValuesMap != null) {
            valuesMap = oldValuesMap;
        }
    }
    // 看源码可知，subKeyFactory 是Proxy.KeyFactory实现了BiFunction接口
    // 调用 apply() 根据目标对象的接口数组的个数包装成 Key1、Key2、KeyX 对象返回，subKey就是二级缓存的key了
    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    // 根据二级key从二级缓存获取的supplier，其实这个supplier就是个 Proxy.Factory 对象 或者 CacheValue 这个对象是个弱引用对象，里面保存着Class对象。
   // CacheValue弱引用对象方便GC的回收内存。
    Supplier<V> supplier = valuesMap.get(subKey);
    Factory factory = null;
    // 死循环尝试生产Class对象，因为处于并发中
    while (true) {
        if (supplier != null) {
            // 如果是Factory，还得去走一套逻辑生产Class对象，如果是CacheValue就直接返回保存的Class对象
            V value = supplier.get();
            if (value != null) {
                return value;
            }
        }
        // 走到这里代表缓存未命中的拉，要去手动生产了，根据一堆参数生产个Factory先。
        // 这个Factory其实就是封装了生产和缓存Class对象的逻辑而已，缓存不是它，真正做生产的也不是他
        if (factory == null) {
            factory = new Factory(key, parameter, subKey, valuesMap);
        }
        if (supplier == null) {
            supplier = valuesMap.putIfAbsent(subKey, factory);
            if (supplier == null) {
                // 将Factory放进二级缓存中，赋值给supplier，下一轮循环将去走 Factory.get() 逻辑
                supplier = factory;
            }
            // else retry with winning supplier
        } else {
            if (valuesMap.replace(subKey, supplier, factory)) {
                // successfully replaced
                // cleared CacheEntry / unsuccessful Factory
                // with our Factory
                supplier = factory;
            } else {
                // retry with current supplier
                supplier = valuesMap.get(subKey);
            }
        }
    }
}

Factory.get()，看看怎么构造代理对象的Class对象

@Override
public synchronized V get() { // serialize access
    ...

    try {
    // 前面逻辑没什么好看的，这里 valueFactory 其实是ProxyClassFactory，根据classLoader和目标对象接口数组生产Class对象
        value = Objects.requireNonNull(valueFactory.apply(key, parameter));
    } finally {
        if (value == null) { // remove us on failure
            valuesMap.remove(subKey, this);
        }
    }
    // the only path to reach here is with non-null value
    assert value != null;

    // 生产成功后，包装成弱引用对象，方便回收内存
    CacheValue<V> cacheValue = new CacheValue<>(value);

    // put into reverseMap
    reverseMap.put(cacheValue, Boolean.TRUE);

    // 将CacheValue顶替Factory，下次就直接返回Class对象
    if (!valuesMap.replace(subKey, this, cacheValue)) {
        throw new AssertionError("Should not reach here");
    }
    // successfully replaced us with new CacheValue -> return the value
    // wrapped by it
    return value;
}

上面还未真正构造Class对象，在ProxyClassFactory.apply才是构造

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
    Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
    // 上来做一些检查，遍历每个接口，有一个条件不满足就报错
    // 1、检查接口的Class对象是否可被loader装载。2、每个接口Class是否是接口类型。3、是否有接口重复了
    for (Class<?> intf : interfaces) {
        Class<?> interfaceClass = null;
        try {
            interfaceClass = Class.forName(intf.getName(), false, loader);
        } catch (ClassNotFoundException e) {
        }
        if (interfaceClass != intf) {
            throw new IllegalArgumentException(
                intf + " is not visible from class loader");
        }
        if (!interfaceClass.isInterface()) {
            throw new IllegalArgumentException(
                interfaceClass.getName() + " is not an interface");
        }
        if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
            throw new IllegalArgumentException(
                "repeated interface: " + interfaceClass.getName());
        }
    }

    String proxyPkg = null;     // package to define proxy class in
    int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

    /*
     * Record the package of a non-public proxy interface so that the
     * proxy class will be defined in the same package.  Verify that
     * all non-public proxy interfaces are in the same package.
     */
    for (Class<?> intf : interfaces) {
        int flags = intf.getModifiers();
        if (!Modifier.isPublic(flags)) {
            accessFlags = Modifier.FINAL;
            String name = intf.getName();
            int n = name.lastIndexOf('.');
            String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
            if (proxyPkg == null) {
                proxyPkg = pkg;
            } else if (!pkg.equals(proxyPkg)) {
                throw new IllegalArgumentException(
                    "non-public interfaces from different packages");
            }
        }
    }

    if (proxyPkg == null) {
        // if no non-public proxy interfaces, use com.sun.proxy package
        proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
    }

    // 上面是去决定代理对象生产后的所在的包路径，这里根据包路径+自增数生成代理对象名字 通常是 com.xxxx.service.$Proxy0
    long num = nextUniqueNumber.getAndIncrement();
    String proxyName = proxyPkg + proxyClassNamePrefix + num;

    // 最后终于要去真正生产Class对象了，得到Class字节码数组后。再由本地方法 defindClass0() 去给Class对象配置一下东西？
    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
        proxyName, interfaces, accessFlags);
    try {
        return defineClass0(loader, proxyName,
                            proxyClassFile, 0, proxyClassFile.length);
    } catch (ClassFormatError e) {
        /*
         * A ClassFormatError here means that (barring bugs in the
         * proxy class generation code) there was some other
         * invalid aspect of the arguments supplied to the proxy
         * class creation (such as virtual machine limitations
         * exceeded).
         */
        throw new IllegalArgumentException(e.toString());
    }
}

分析完以上的一条调用链之后，ProxyGenerator.generatorProxyClass() 就不再去看了。

生产Class对象后，返回到Factory，包装成CacheValue弱引用对象，放进二级缓存，key是目标对象接口数组（根据接口来获取Class对象），最后返回到 Proxy.newProxyInstance()，拿到Class对象的构造函数，传入 h ，实例化Proxy对象返回，打完收工！

总结生产Proxy对象的调用链：

Proxy.newProxyInstance() -> WeakCache.get() -> Factory.get() -> ProxyClassFactory.apply() -> ProxyGenerator.generatorProxyClass()

根据 classLoader 从一级缓存弱引用缓存中获取二级缓存，这个二级缓存里全都是该loader装载的class对象。

根据 具体的接口数组 从二级缓存中获取 Supplier，这个Supplier可能是Factory或CacheValue对象。

如果是Factory，调用ProxyClassFactory进一步，在ProxyClassFactory中调用ProxyGenerator最终根据loader，接口数组生产Class对象。

JDK代理对象的每一个方法都会调用InvocationHandler.invoke(proxy, method, args)，根据每个被调用的方法不同，传入当前的代理对象，当前的调用方法，方法的实参数。在invoke()中实现自定义的增强逻辑。比如Spring AOP中是将增强器封装成拦截器链，将增强器做成串联调用。

最后上一张反编译的$Proxy0对象源码

public final class $Proxy0 extends Proxy
  implements IHello // 继承了Proxy类和实现IHello接口
{
  // 变量，都是private static Method  XXX
  private static Method m1;
  private static Method m3;
  private static Method m2;
  private static Method m0;
 
  // 代理类的构造函数，其参数正是是InvocationHandler实例，Proxy.newInstance方法就是通过通过这个构造函数来创建代理实例的
  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }
  
  // 接口代理方法
  public final void sayHello()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  // 静态代码块对变量进行一些初始化工作
  static
  {
    try
    {
	  // 这里每个方法对象 和类的实际方法绑定
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("com.jpeony.spring.proxy.jdk.IHello").getMethod("sayHello", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", 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());
    }
  }