引言

到目前为止，动态代理整个体系中应该只有代理类如何生成这部分对我们来说是完全空白的，这篇文章会帮我们迈出填补这个空白的第一步。我们会重点介绍Proxy中的ProxyClassFactory这个内部类，这个类做了字节码生成步骤之前的重要工作。

Proxy.newProxyInstance方法

从之前的分析我们知道，生成代理类$Proxy0是在Proxy.newProxyInstance方法中实现的。这个方法都做了哪些操作，我们来看一下：

  1. public static Object newProxyInstance(ClassLoader loader,
  2.                                           Class<?>[] interfaces,
  3.                                           InvocationHandler h)
  4.         throws IllegalArgumentException
  5.     {
  6.         Objects.requireNonNull(h);
  7.         final Class<?>[] intfs = interfaces.clone();
  8.         /*
  9.          * Look up or generate the designated proxy class.
  10.          */
  11.         Class<?> cl = getProxyClass0(loader, intfs);
  12.         /*
  13.          * Invoke its constructor with the designated invocation handler.
  14.          */
  15.         try {
  16.             final Constructor<?> cons = cl.getConstructor(constructorParams);
  17.             final InvocationHandler ih = h;
  18.             if (!Modifier.isPublic(cl.getModifiers())) {
  19.                 AccessController.doPrivileged(new PrivilegedAction<Void>() {
  20.                     public Void run() {
  21.                         cons.setAccessible(true);
  22.                         return null;
  23.                     }
  24.                 });
  25.             }
  26.             return cons.newInstance(new Object[]{h});
  27.         }
  28.     }

为了缩短版面，我去掉了权限检查和catch块这些无关紧要的代码。
方法的参数，我们已经很清楚了，就是ClassLoader（如果你对ClassLoader不是很了解，可以参考这个系列）、interfaces(代理类需要实现的接口，也就是IHello)和InvocationHandler，因为生成的动态代理类需要实现被增强类的接口，所以，一个interface的class数组应该就能唯一确定一个动态代理类了。
我们需要重点关注的是getProxyClass0这个方法，通过这个方法，得到了代表$Proxy0类的Class实例。

  1. private static Class<?> getProxyClass0(ClassLoader loader,
  2.                                            Class<?>... interfaces) {
  3.         if (interfaces.length > 65535) {
  4.             throw new IllegalArgumentException("interface limit exceeded");
  5.         }
  7.         // If the proxy class defined by the given loader implementing
  8.         // the given interfaces exists, this will simply return the cached copy;
  9.         // otherwise, it will create the proxy class via the ProxyClassFactory
  10.         return proxyClassCache.get(loader, interfaces);
  11.     }

方法首先检查interface的长度是否超过65535，如果超过，直接抛出异常。为什么会有这个限制？如果你对class文件的结构清楚的话，就能很轻松的回答这个问题，在class文件中，位于常量池之后的是访问标志，用来识别一些类或者接口层次的访问信息，而访问标志之后就是类索引、父类索引和接口索引集合，因为java中可以实现多个接口，所以接口索引集合中接口索引的数量可能会不止一个，这个数量是由一个u2类型（两个字节）的接口计数器来表明的。而u2类型的最大值就是65535。
回到正题，在进行了接口数量校验之后，调用的是proxyClassCache的get方法，proxyClassCache是一个WeakCache类实例，看来重点就是这个类了。我们从注释中能大概明白proxyClassCache.get方法的作用：如果实现了这些接口的、由这个类加载器加载的代理class已经存在的话，直接返回缓存的复制，否则使用ProxyClassFactory来创建代理class。
这篇文章的重点不是讲解WeakCache这个类的实现，但是略过WeakCache而直接讲解跟它相关的ProxyClassFactory肯定会有些突兀，因为我们不知道ProxyClassFactory这个类存在的目的是什么，所以，为了平滑的过渡，我们先将视线转移到WeakCache，看一下跟ProxyClassFactory相关的字段和构造方法。

WeakCache简介和与ProxyClassFactory的关系

这个类是在java.lang.reflect包里面的。
还是先翻译一下源码中的注释：
WeakCache是一个基于((key,sub-key)->value)的缓存映射。Keys和values是虚引用，sub-keys是强引用。keys直接被传到get方法，这个方法还需要一个parameter参数。Sub-keys是使用传入构造方法的SubKeyFactory参数根据keys和parameter计算出来的。Values是使用传入构造方法的ValueFactory根据keys和parameter计算出来的。Keys可以是null，subKeyFactory和valueFactory返回的sub-keys和values不能是null。sub-keys通过他们的equals方法来进行比较。当每次执行get、containsValue和size方法时，如果到keys的虚引用被清楚掉，那么缓存中的条目会被擦除。被清除的到individual values的虚引用不会导致擦除，但是这样的条目逻辑上会被当成不存在的并且在去请求这些values的key和subKey时会触发valueFactory的re-evaluation。
通过这个描述，我们大概知道这个类的作用了。

涉及到的字段

  1.     private final BiFunction<K, P, ?> subKeyFactory;
  2.     private final BiFunction<K, P, V> valueFactory;

我这里去掉了暂时不需要关注的字段。这两个成员变量是我们在Proxy中需要用到的，都是BiFunction类型，根据注释中的解释，一个用来计算subKey，一个用来是计算values，而这两个也是构造方法中需要给定的变量。

  1. public WeakCache(BiFunction<K, P, ?> subKeyFactory,
  2.                      BiFunction<K, P, V> valueFactory) {
  3.         this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
  4.         this.valueFactory = Objects.requireNonNull(valueFactory);
  5.     }

我们看一下在Proxy类中怎么构造的这两个参数：

Proxy中的BiFunction

  1.  private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
  2.         proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

传入的两个参数是KeyFactory和ProxyClassFactory，这两个类肯定都是BiFunction的子类，它们都是Proxy的内部类，而ProxyClassFactory就是我们要分析的重要部分。

KeyFactory

  1. /**
  2.      * A function that maps an array of interfaces to an optimal key where
  3.      * Class objects representing interfaces are weakly referenced.
  4.      */
  5. private static final class KeyFactory
  6.         implements BiFunction<ClassLoader, Class<?>[], Object>
  7.     {
  8.         @Override
  9.         public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
  10.             switch (interfaces.length) {
  11.                 case 1: return new Key1(interfaces[0]); // the most frequent
  12.                 case 2: return new Key2(interfaces[0], interfaces[1]);
  13.                 case 0: return key0;
  14.                 default: return new KeyX(interfaces);
  15.             }
  16.         }
  17.     }

通过注释和代码我们可以知道，这个Function映射一个interface的class的数组到一个最优的key，这个key里面的代表接口的class对象（们）是虚引用。
Key1、Key2和KeyX同样是Proxy的内部类，这里我还是把代码都贴出来吧：

Key1、Key2和KeyX

  1. /*
  2.      * Key1 and Key2 are optimized for the common use of dynamic proxies
  3.      * that implement 1 or 2 interfaces.
  4.      */
  6.     /*
  7.      * a key used for proxy class with 1 implemented interface
  8.      */
  9.     private static final class Key1 extends WeakReference<Class<?>> {
  10.         private final int hash;
  12.         Key1(Class<?> intf) {
  13.             super(intf);
  14.             this.hash = intf.hashCode();
  15.         }
  17.         @Override
  18.         public int hashCode() {
  19.             return hash;
  20.         }
  22.         @Override
  23.         public boolean equals(Object obj) {
  24.             Class<?> intf;
  25.             return this == obj ||
  26.                    obj != null &&
  27.                    obj.getClass() == Key1.class &&
  28.                    (intf = get()) != null &&
  29.                    intf == ((Key1) obj).get();
  30.         }
  31.     }
  33.     /*
  34.      * a key used for proxy class with 2 implemented interfaces
  35.      */
  36.     private static final class Key2 extends WeakReference<Class<?>> {
  37.         private final int hash;
  38.         private final WeakReference<Class<?>> ref2;
  40.         Key2(Class<?> intf1, Class<?> intf2) {
  41.             super(intf1);
  42.             hash = 31 * intf1.hashCode() + intf2.hashCode();
  43.             ref2 = new WeakReference<Class<?>>(intf2);
  44.         }
  46.         @Override
  47.         public int hashCode() {
  48.             return hash;
  49.         }
  51.         @Override
  52.         public boolean equals(Object obj) {
  53.             Class<?> intf1, intf2;
  54.             return this == obj ||
  55.                    obj != null &&
  56.                    obj.getClass() == Key2.class &&
  57.                    (intf1 = get()) != null &&
  58.                    intf1 == ((Key2) obj).get() &&
  59.                    (intf2 = ref2.get()) != null &&
  60.                    intf2 == ((Key2) obj).ref2.get();
  61.         }
  62.     }
  64.     /*
  65.      * a key used for proxy class with any number of implemented interfaces
  66.      * (used here for 3 or more only)
  67.      */
  68.     private static final class KeyX {
  69.         private final int hash;
  70.         private final WeakReference<Class<?>>[] refs;
  72.         @SuppressWarnings("unchecked")
  73.         KeyX(Class<?>[] interfaces) {
  74.             hash = Arrays.hashCode(interfaces);
  75.             refs = (WeakReference<Class<?>>[])new WeakReference<?>[interfaces.length];
  76.             for (int i = 0; i < interfaces.length; i++) {
  77.                 refs[i] = new WeakReference<>(interfaces[i]);
  78.             }
  79.         }
  81.         @Override
  82.         public int hashCode() {
  83.             return hash;
  84.         }
  86.         @Override
  87.         public boolean equals(Object obj) {
  88.             return this == obj ||
  89.                    obj != null &&
  90.                    obj.getClass() == KeyX.class &&
  91.                    equals(refs, ((KeyX) obj).refs);
  92.         }
  94.         private static boolean equals(WeakReference<Class<?>>[] refs1,
  95.                                       WeakReference<Class<?>>[] refs2) {
  96.             if (refs1.length != refs2.length) {
  97.                 return false;
  98.             }
  99.             for (int i = 0; i < refs1.length; i++) {
  100.                 Class<?> intf = refs1[i].get();
  101.                 if (intf == null || intf != refs2[i].get()) {
  102.                     return false;
  103.                 }
  104.             }
  105.             return true;
  106.         }
  107.     }

可以看到，当动态代理类需要实现1个、两个和两个以上接口的时候，分别会使用Key1、Key2和KeyX。Key1和Key2直接继承了WeakReference，而KeyX虽然没有继承WeakReference，却维护了一个WeakReference的数组，而这些虚引用都是到代表接口的Class对象。
所以针对KeyProxy，我们就可以理解为，当给定一个class数组（这个class数组里的每个class都代表一个接口，一个代理类需要实现的接口）时，返回到这些class的虚引用。

ProxyClassFactory

Proxy的代码比较长，我们分段解析：

  1. /**
  2.      * A factory function that generates, defines and returns the proxy class given
  3.      * the ClassLoader and array of interfaces.
  4.      */
  5.     private static final class ProxyClassFactory
  6.         implements BiFunction<ClassLoader, Class<?>[], Class<?>>
  7.     {
  8.         // prefix for all proxy class names
  9.         private static final String proxyClassNamePrefix = "$Proxy";
  11.         // next number to use for generation of unique proxy class names
  12.         private static final AtomicLong nextUniqueNumber = new AtomicLong();

最开始的注释表明了这个类的作用：一个根据classLoader和interface数组来生成、定义和返回代理类的工厂方法。也就是说，代表代理类$Proxy0的class对象，是在这里生成的。
两个成员变量，proxyClassNamePrefix和nextUniqueNumber，前者是所有代理类的名字的前缀，联想我们的$Proxy0，应该是的，后者是用来产生不同的代理类名称的数字。我们的$Proxy0这个数组就是0。
看apply方法的实现：

  1. @Override
  2.         public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
  4.             Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
  5.             for (Class<?> intf : interfaces) {
  6.                 /*
  7.                  * Verify that the class loader resolves the name of this
  8.                  * interface to the same Class object.
  9.                  */
  10.                 Class<?> interfaceClass = null;
  11.                 try {
  12.                     interfaceClass = Class.forName(intf.getName(), false, loader);
  13.                 } catch (ClassNotFoundException e) {
  14.                 }
  15.                 if (interfaceClass != intf) {
  16.                     throw new IllegalArgumentException(
  17.                         intf + " is not visible from class loader");
  18.                 }
  19.                 /*
  20.                  * Verify that the Class object actually represents an
  21.                  * interface.
  22.                  */
  23.                 if (!interfaceClass.isInterface()) {
  24.                     throw new IllegalArgumentException(
  25.                         interfaceClass.getName() + " is not an interface");
  26.                 }
  27.                 /*
  28.                  * Verify that this interface is not a duplicate.
  29.                  */
  30.                 if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
  31.                     throw new IllegalArgumentException(
  32.                         "repeated interface: " + interfaceClass.getName());
  33.                 }
  34.             }

apply方法就是要完成根据classLoader和代表接口的class的数组返回代理类的class实例的任务。这部分代码对所有的interface进行了校验，包括被类加载器加载后生成的class对象是否与这个class是同一个、是否是接口的校验、是否重复的校验等等， 比较简单。

  1.             //生成代理类的包名
  2.             String proxyPkg = null;     // package to define proxy class in
  3.             //生成的代理类的访问标志，默认是public final的。
  4.             int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
  6.             /*
  7.              * Record the package of a non-public proxy interface so that the
  8.              * proxy class will be defined in the same package.  Verify that
  9.              * all non-public proxy interfaces are in the same package.
  10.              */
  11.             for (Class<?> intf : interfaces) {
  12.                 String proxyPkg = null;     // package to define proxy class in
  13.             int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
  15.             /*
  16.              * Record the package of a non-public proxy interface so that the
  17.              * proxy class will be defined in the same package.  Verify that
  18.              * all non-public proxy interfaces are in the same package.
  19.              */
  20.             for (Class<?> intf : interfaces) {
  21.                 //获取接口的访问标志
  22.                 int flags = intf.getModifiers();
  23.                 //如果接口的访问标志不是public的，那么生成的代理类的包名和接口报名相同
  24.                 if (!Modifier.isPublic(flags)) {
  25.                     //生成的代理类的访问标志设置为final
  26.                     accessFlags = Modifier.FINAL;
  27.                     //获取接口名称并得到包名称
  28.                     String name = intf.getName();
  29.                     int n = name.lastIndexOf('.');
  30.                     String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
  31.                     if (proxyPkg == null) { 
  32.                         //之前没有接口非public的，直接设置代理类的包名为当前接口的包名
  33.                         proxyPkg = pkg;
  34.                     } else if (!pkg.equals(proxyPkg)) {
  35.                         //如果代理类实现不同包的接口并且接口都不是public的，报错
  36.                         throw new IllegalArgumentException(
  37.                             "non-public interfaces from different packages");
  38.                     }
  39.                 }
  40.             }
  41.           }

这部分代码上面我添加了注释，大致意思就是通过遍历每个接口的访问权限来得到生成的代理类存放在哪个包下。如果接口中有非public访问权限的，就存放在这个包下，但是不允许出现两个非public接口并且在不同的包下面的情况。

  1.            if (proxyPkg == null) {
  2.                //如果所有的包的访问权限都是public，就将生成的代理类放到com.sun.proxy下。
  3.                 // if no non-public proxy interfaces, use com.sun.proxy package
  4.                 proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
  5.             }
  7.             /*
  8.              * Choose a name for the proxy class to generate.
  9.              */
  10.             //生成一个序号
  11.             long num = nextUniqueNumber.getAndIncrement();
  12.             //得到代理类的名称 包名+前缀+序号
  13.             String proxyName = proxyPkg + proxyClassNamePrefix + num;
  15.             /*
  16.              * Generate the specified proxy class.
  17.              */
  18.             //调用sun.misc.ProxyGenerator来生成字节码
  19.             byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
  20.                 proxyName, interfaces, accessFlags);
  21.             try {
  22.                 //根据二进制class文件获取相应的class实例。
  23.                 return defineClass0(loader, proxyName,
  24.                                     proxyClassFile, 0, proxyClassFile.length);
  25.             } catch (ClassFormatError e) {
  26.                 /*
  27.                  * A ClassFormatError here means that (barring bugs in the
  28.                  * proxy class generation code) there was some other
  29.                  * invalid aspect of the arguments supplied to the proxy
  30.                  * class creation (such as virtual machine limitations
  31.                  * exceeded).
  32.                  */
  33.                 throw new IllegalArgumentException(e.toString());
  34.             }

ProxyClassFactory类应该是动态代理中一个很重要的类了，虽然字节码生成不是在这个方法中实现的，但是它让我们知道了生成代理类的前置校验以及代理类的访问标志、存放位置的构造逻辑。

小结

经过艰难的源码分析，我们走出了探究动态代理底层机制的关键一步，先抛开WeakCache的简单介绍，我们知道了在Proxy类中，ProxyClassFactory这个BiFunction充当了生成代理类class实例的关键角色，它做了接口校验、包名生成和代理类访问标志这些工作。下一篇，我们就讲解字节码文件的真正生成流程。