4、动态代理的缓存机制

1.背景

上一节大致介绍了Proxy动态代理的原理，从几个疑问上面分析，这一节介绍一下动态代理的缓存机制。网上的资源比较少。
可以怀着下面几个问题阅读源码

为什么要缓存
缓存的内容是什么
哪里调用的缓存
缓存的实现机制
缓存的过期机制

2.属性说明

Proxy涉及的缓存主要在java.lang.reflect.WeakCache这个类中
该类存在于jdk反射的包中
当生成代理对象的时候会用到

java.lang.reflect.Proxy#newProxyInstance
java.lang.reflect.Proxy#getProxyClass0
java.lang.reflect.WeakCache#get

看这个类的结构

//用了Reference记录引用队列,java gc时配合清除缓存用
private final ReferenceQueue<K> refQueue  = new ReferenceQueue<>();
//缓存的底层实现
private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map = new ConcurrentHashMap<>();
//记录所有缓存中的CacheKey,配合缓存的过期机制
private final ConcurrentMap<Supplier<V>, Boolean> reverseMap = new ConcurrentHashMap<>();
//两个二元操作函数
private final BiFunction<K, P, ?> subKeyFactory;
private final BiFunction<K, P, V> valueFactory;

这里最重要的的是map，将key-value介绍如下

字段	意义	备注
key	通过classLoader来进行一级缓存	实际类型为CacheKey
value	二级缓存	后续会介绍

源码中把这个value的变量称为valuesMap，这里顺便借用，介绍这个“二级缓存”是干嘛的

字段	意义	备注
key	二级缓存的key，由classLoader和interfaces[]标识代理类	实际类型在java.lang.reflect.Proxy.KeyFactory#apply,为Key1或者Key2或者KeyX或者object，取决于代理类实现的接口数量
value	用于返回代理类(即Class<?>)	第一次存储实际类型为java.lang.reflect.WeakCache.Factory#Factory，之后取出时，都是java.lang.reflect.WeakCache.CacheValue

那么为什么要用缓存,缓存的内容是什么
缓存就是在动态代理生成代理类时，只用生成一次后面尽量直接复用

3.实现机制

java.lang.reflect.WeakCache#get

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

        expungeStaleEntries();

        Object cacheKey = CacheKey.valueOf(key, refQueue);

        // lazily install the 2nd level valuesMap for the particular cacheKey
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

        // create subKey and retrieve the possible Supplier<V> stored by that
        // subKey from valuesMap
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                // supplier might be a Factory or a CacheValue<V> instance
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            // else no supplier in cache
            // or a supplier that returned null (could be a cleared CacheValue
            // or a Factory that wasn't successful in installing the CacheValue)

            // lazily construct a Factory
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }

            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // successfully installed Factory
                    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);
                }
            }
        }
    }

注意下面几点

3.1 ConcurrentMap的get以及putIfAbsent的使用

可以看到有几处代码，形如

ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

这个是为了保证在多线程下，去获取同一个key，拿到的是同一个引用对象
可以理解像单例模式里面要判断两次，来保证不会多次生成对象

if(instance==null) {
  synchronize(XXX.class) {
    if(instance==null){
      instance = new XXX();
    }
  }
}

可以参考http://wxl24life.iteye.com/blog/1746794

3.2 为什么说第一次valuesMap里面value的实际类型和之后不一样

根据Supplier<V> supplier = valuesMap.get(subKey);中supplier值以及在while循环第几次，按照时间先后考虑

3.2.1 supplier==null,第一次while循环

这种出现在第一次请求中，二级缓存没有该key

逻辑为

supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
    // successfully installed Factory
    supplier = factory;
}

此时valuesMap里面的key是subKey
subKey是

Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));

根据java.lang.reflect.Proxy.KeyFactory#apply
subKey实际类型是Key1,Key2,Object或者KeyX，根据实现的接口数量决定

private static final class KeyFactory
        implements BiFunction<ClassLoader, Class<?>[], Object>
    {
        @Override
        public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
            switch (interfaces.length) {
                case 1: return new Key1(interfaces[0]); // the most frequent
                case 2: return new Key2(interfaces[0], interfaces[1]);
                case 0: return key0;
                default: return new KeyX(interfaces);
            }
        }
    }

3.2.2 supplier==null,第二次while循环(或者因其他原因，第n次while循环)

这种出现在第一次请求中，二级缓存没有该key,supplier被赋值之后
逻辑为

if (supplier != null) {
  // supplier might be a Factory or a CacheValue<V> instance
  V value = supplier.get();
  if (value != null) {
     return value;
  }
 }

supplier在第一次循环时，已经为factory了，这里调用get方法，就是进入
java.lang.reflect.WeakCache.Factory#get的逻辑

        @Override
        public synchronized V get() { // serialize access
            // re-check
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                //supplier和当前supplier不等，验证不正确
                return null;
            }
            V value = null;
            try {
                //生成代理类对应的Class<?>信息
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) { // remove us on failure
                    valuesMap.remove(subKey, this);
                }
            }
            assert value != null;
            CacheValue<V> cacheValue = new CacheValue<>(value);

            //把之前二级缓存的value替换为当前的CacheValue
            if (valuesMap.replace(subKey, this, cacheValue)) {
                // put also in reverseMap
                reverseMap.put(cacheValue, Boolean.TRUE);
            } else {
                throw new AssertionError("Should not reach here");
            }
            return value;
        }

其中， value = Objects.requireNonNull(valueFactory.apply(key, parameter));就是代理类

java.lang.reflect.Proxy.ProxyClassFactory#apply //返回Class<?>
//具体生成细节参考上一节

在生成value之后

//把当前的值即this(类型为Factory)替换为了cacheValue(类型CacheValue)
valuesMap.replace(subKey, this, cacheValue)

并且这一次get()最终返回的是value;也就是Class<?>

3.2.3 supplier!=null

出现在之后的某一次请求中，二级缓存已经有该key-value

if (supplier != null) {
  // supplier might be a Factory or a CacheValue<V> instance
  V value = supplier.get();
  if (value != null) {
     return value;
  }
 }

此时，supplier的类型为CacheValue
在Factory#get中生成时，就是
CacheValue<V> cacheValue = new CacheValue<>(value);
CacheValue#get方法，最终转入java.lang.ref.Reference#get，返回的就是这个value，即构造函数的参数value

3.3缓存的过期机制

这里用了java.lang.reflect.WeakCache.CacheKey是继承WeakReference的
即弱引用，在java gc中，满足适当的条件时，当一个referent是ROOT可达且为弱引用时，会将其放入对应的referenceQueue。
核心函数在

private void expungeStaleEntries() {
        CacheKey<K> cacheKey;
        while ((cacheKey = (CacheKey<K>)refQueue.poll()) != null) {
            cacheKey.expungeFrom(map, reverseMap);
        }
    }

可能会奇怪这里并没有refQueue的enqueue操作，这个操作是java gc的时候做的，这里不深究。
只要知道gc时，某些场景会进行refQueue的enqueue即可。
那么，之后再调用expungeStaleEntries()就能清除过期的缓存。

4. 思考

4.1 为什么要二级缓存

一级缓存用来区分classLoader,二级缓存用来区分实现的接口
生成类的缓存是按照ClassLoader来划分的，这是因为类的区分不仅根据类名还根据装载类的ClassLoader，也就是说同一个类被不同的ClassLoader加载，那么它们也是不同的.
参考
http://www.cnblogs.com/cruze/p/3843996.html
http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-5.html#jvms-5.3

4.2 ConcurrentHashMap想要获取SingleValue的方法(严格来说是同一个引用)

如果putIfAbsent返回值不为null,那么返回该值，不要重新put
http://wxl24life.iteye.com/blog/1746794

4.3 二级缓存valueMaps的value的类型不一样

第一次是Factory，调用get()时，生成代理类信息之后，将CacheValue作为值替换了当前key对应的value
之后调用，都是CacheValue.get()返回java.lang.ref.Reference#get，最终就是CacheValue的构造函数参数，即代理类信息Class<?>

4.4 一级缓存的key-value与二级缓存的key-value

4.5 在'背景'中提出的问题，在上文中都有解释

4.6 缓存的过期机制

利用java.lang.reflect.WeakCache.CacheKey继承WeakReference，配合ReferenceQueue使用。
在java gc时某些条件下触发。

5.暂时不明白的问题

5.1 reverseMap的value有什么用?

感觉纯粹是利用ConcurrentHashMap的"Concurrent"的特性，value并没有什么用，代码里面并没有处理里面的value，都是Boolean.TRUE;

5.2 实现二级缓存的逻辑为什么要这么写,不能一步到位吗?

为什么先放入Factory，调用Factory.get时进行replace操作再放入CacheValue，不能一步到位写入CacheValue后面直接用吗

6. refer

concurrentHashMap 的putIfAbsent完成single value
http://wxl24life.iteye.com/blog/1746794

cglib的缓存说明
http://www.cnblogs.com/cruze/p/3843996.html
http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-5.html#jvms-5.3

gc 与 reference
http://www.cnblogs.com/maxmys/p/3998842.html
http://hongjiang.info/java-referencequeue/
http://zhang-xzhi-xjtu.iteye.com/blog/413159

转摘于：https://www.jianshu.com/p/9f5566b5e7fb