动态代理源码分析（3）

分析入口：

Proxy类的newProxyInstance方法：

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h) throws IllegalArgumentException {
　　     //判断参数InvocationHandler（里面的invoke方法执行具体的代理逻辑）是否为空，空抛异常
        Objects.requireNonNull(h);
        //复制一份代理类需要实现的接口（和被代理类实现的接口一样）
        final Class<?>[] intfs = interfaces.clone();
        //检查是否有权限进行反射代理
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        /**
         * 查看或者生成一个代理类（代理类缓存在内存中，如果之前已经有过同样类加载器和同样接口参数生成的代理类，
         * 则会缓存在内存中，此时直接返回代理类；如果缓存中没有相应代理类或者代理类已经过期失效，则根据条件生成
         * 新的代理类，放入缓存，并返回代理对象）
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        try {
            //检查返回的代理类的权限
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            /**
             * 用反射获取代理类的构造函数（根据生成代理类的源码，可知构造函数是一个有参构造，
             * 且参数为InvocationHandler,Proxy类中定义constructorParams就是InvocationHandler）
             */
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            //判断代理类的访问权限，如果不是public的权限，则做相应的设置
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //返回代理类的反射实例对象
            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);
        }
    }

newProxyInstance方法中调用的获取代理类Class对象的getProxyClass0方法：

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        //如果进行动态代理时传入的代理类需要实现接口数量大于65535，则抛异常
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        /**
         * 如果在缓存中有参数loader和interfaces定义过的代理类，则简单的返回一份代
         * 理类copy否则通过ProxyClassFactory生产一个代理类
         * 
         * proxyClassCache在Proxy类内部定义：
         *      private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
         *         proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
         */
        return proxyClassCache.get(loader, interfaces);
    }

getProxyClass0方法中调用的proxyClassCache（WeakCache<ClassLoader, Class<?>[], Class<?>>）对象分析：

/**
 * K:动态代理参数类加载器
 * P:动态代理参数代理类需要实现的接口数组
 * V:代理类Class（当Class存在时）或者生成代理类的工厂Factory（代理类不存在时）
 */
final class WeakCache<K, P, V> {}

WeakCache中的属性和构造函数分析：

    private final ReferenceQueue<K> refQueue = new ReferenceQueue<>();
    /**
     * 代理类在内存中的缓存结构 :
     *      一级key是类加载器包装对象（每个类加载器可加载不同的类->代理类）
     *      二级key是接口数组
     *      value就是对应的代理类Class
     */
    private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map
            = new ConcurrentHashMap<>();
    private final ConcurrentMap<Supplier<V>, Boolean> reverseMap
            = new ConcurrentHashMap<>();
    //根据K和P生产一个二级key
    private final BiFunction<K, P, ?> subKeyFactory;
    //根据K和P生产代理类V
    private final BiFunction<K, P, V> valueFactory;

    /**
     * Construct an instance of {@code WeakCache}
     *
     * @param subKeyFactory a function mapping a pair of
     *                      {@code (key, parameter) -> sub-key}
     * @param valueFactory  a function mapping a pair of
     *                      {@code (key, parameter) -> value}
     * @throws NullPointerException if {@code subKeyFactory} or
     *                              {@code valueFactory} is null.
     */
    public WeakCache(BiFunction<K, P, ?> subKeyFactory,
                     BiFunction<K, P, V> valueFactory) {
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }

获取代理类Class对象的方法（getProxyClass0方法中调用的proxyClassCache.get()）分析（WeakCache类中的get方法）：

public V get(K key, P parameter) {
        //先判断接口数组是否为空
        Objects.requireNonNull(parameter);
        //删除失效的条目（缓存结构中失效的代理类）
        expungeStaleEntries();
        //将参数类加载器包装
        Object cacheKey = CacheKey.valueOf(key, refQueue);

        //懒惰式加载特定cacheKey（包装好的ClassLoader）对应的ConcurrentMap值
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        //先判断cacheKey有没有对应的值，如果有，就继续执行，如果没有则进行赋值操作
        if (valuesMap == null) {
            /**
             * map.putIfAbsent(K,V)
             * 效果等同于：
             * if(map.containsKey(K)){
             *     return map.get(K);
             * }else{
             *     return map.put(K,V);
             * }
             */
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                    = map.putIfAbsent(cacheKey,
                    valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

        /**
         * 上述代码完成了一级key的匹配，并得到了一级key对应的值valuesMap；
         * 此处再根据类加载器和接口数组构造一个二级key，去获取相应的代理类Class
         */
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                // supplier可能是一个Factory也可能是一个CacheValue<V>实例（被包装的代理类Class对象）
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            /**
             * 如果supplier不是代理类Class对象，或者supplier为空；
             * 则先将valuesMap对应中对应的代理类Class的值替换成一个
             * 生产代理类Class的工具Factory
             */

            //懒惰式加载一个生产代理类Class的工具Factory
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }

            /**
             * 一下代码都是在给valuesMap安装生产代理类Class的工具Factory
             * 即把代理类缓存结构（key,subkey->value）中的value暂时变为Factory，
             * 等代理类Class生产出来后，再行替换，变为真正的代理类Class缓存条目
             */
            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    supplier = factory;
                }
            } else {
                if (valuesMap.replace(subKey, supplier, factory)) {
                    supplier = factory;
                } else {
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }

在get方法中调用的Factory（生产代理类Class的工具Factory：WeakCache内部类）:

private final class Factory implements Supplier<V> {

        private final K key;
        private final P parameter;
        private final Object subKey;
        private final ConcurrentMap<Object, Supplier<V>> valuesMap;

        Factory(K key, P parameter, Object subKey,
                ConcurrentMap<Object, Supplier<V>> valuesMap) {
            this.key = key;
            this.parameter = parameter;
            this.subKey = subKey;
            this.valuesMap = valuesMap;
        }

        @Override
        public synchronized V get() { // serialize access
            //重复检查supplier的属性，是Factory还是真正的代理类Class
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                //如果supplier是CacheValue<V>,被包装的代理类Class对象，就返回null
                return null;
            }
            //如果supplier是一个生产CacheValue<V>的Factory，就执行生成代码
            V value = null;
            try {
　　　　　　　　　 //valueFactory.apply(key, parameter)真正生成代理类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;

            // wrap value with CacheValue (WeakReference)
            CacheValue<V> cacheValue = new CacheValue<>(value);

            // try replacing us with CacheValue (this should always succeed)
            if (valuesMap.replace(subKey, this, cacheValue)) {
                // put also in reverseMap
                reverseMap.put(cacheValue, Boolean.TRUE);
            } else {
                throw new AssertionError("Should not reach here");
            }

            // successfully replaced us with new CacheValue -> return the value
            // wrapped by it
            return value;
        }
    }

最终获取到代理类Class后原路返回到层层调用方，实现动态代理！！！