WeakCache解析

        在搞懂了弱引用，以及弱引用hashmap以后，终于可以来看看WeakCache这个类是怎么缓存动态代理类的了。

        先来个硬翻译，把这个类上面的注释，自己翻译了一遍。。。

        它是一个具有二级缓存的弱引用类，一级缓存的key和value都是弱引用，二级缓存是强引用。其中key是根据入参直接传入的，二级缓存的key和value都是是根据一级缓存的key和value通过各自的工厂方法(subKeyFactory和valueFactory)计算得到的。一级key可以为空，并且当二级缓存的key和value不为空时，他可以来做比较。二级缓存key可以用它们各自的equals方法做比较。当弱引用被clear后，entries会被以惰性（lazily）方式被删除，被clear过后的弱引用的value值不会被删除，但是他们会在逻辑上被置为不存在的，并且要重新计算二级缓存的key和value。

        自己翻译了一遍还是没懂啥意思，也许是翻译的不准确吧。还是往下看代码吧。

public V get(K key, P parameter) {
        Objects.requireNonNull(parameter);

        expungeStaleEntries();//删除失效缓存（依靠弱引用机制）

        Object cacheKey = CacheKey.valueOf(key, refQueue);//根据入参的key生成一级key，这里的入参其实就是接口类的classLoader
        // 已懒加载方式生成二级缓存的valueMap
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        //若根据一级key(classloader)没有找到对应的代理类，则需要生成
        if (valuesMap == null) {
        //map的putIfAbsent方法类似CAS锁，保证一个key所对应的value不会被覆盖。即：map中存在key，则返回对应的value，没有key，则将对应的键值对存入并返回value。
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

        //根据subKeyFactory所定义的规则，生成对应的二级缓存key
        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> 的实例
                V value = supplier.get();
                if (value != null) {
                    return value;//找到了，直接返回
                }
            }
            // 如果缓存中没找到
            // 或者缓存中返回的是null (有可能是被弱引用移除，或者是当初生成这个代理类时就没有成功)

            // 根据Factory创建一个新的代理类
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }
            //二级缓存没找到，就需要根据factory作为值进行重新生成二级缓存
            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // 成功创建二级缓存
                    supplier = factory;
                }
                // 如果二级缓存存在，需要取得最新的二级缓存数据
            } else {
                //由于这个循环中最开始已经判断过supplier是否为null了，这里如果出现了supplier不为null，说明在运行期间，该supplier有可能被其他的线程赋过值，那么就要取得最新的数据
                if (valuesMap.replace(subKey, supplier, factory)) {
                    supplier = factory;
                } else {
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }

        整个流程看下来，就大概能懂最开始的硬翻译了。

        至于为什么会有二级缓存。参考了一些资料，主要是因为有可能多个类具有共同的classloader，为保证唯一性，就要有二级缓存，采用接口数组来唯一标识一个代理类。当classloader移除后，会将它所对应的所有缓存都清掉，所以就要采用弱引用类型，而接口数组对应的类肯定一直存在，所以才用了强引用。

        这下子算是把jdk的代理流程捋顺了，但是jdk代码的一些细节，还是不太懂。等以后有了更深的理解后，再来补充吧。