第十五章 dubbo結果緩存機制

dubbo提供了三種結果緩存機制：

• lru：基於最近最少使用原則刪除多余緩存，保持最熱的數據被緩存
• threadlocal：當前線程緩存
• jcache：可以橋接各種緩存實現

一、使用方式

    <dubbo:reference id="demoService" check="false" interface="com.alibaba.dubbo.demo.DemoService">
        <dubbo:method name="sayHello" timeout="60000" cache="lru"/>
    </dubbo:reference>

添加cache配置。

注意：dubbo結果緩存有一個bug，https://github.com/alibaba/dubbo/issues/1362，當cache="xxx"配置在服務級別時，沒有問題，當配置成方法級別的時候，不管怎么配置，都睡使用LruCache。

 

二、LRU緩存源碼解析

/**
 * CacheFilter
 * 配置了cache配置才會加載CacheFilter
 */
@Activate(group = {Constants.CONSUMER, Constants.PROVIDER}, value = Constants.CACHE_KEY)
public class CacheFilter implements Filter {
    private CacheFactory cacheFactory;

    public void setCacheFactory(CacheFactory cacheFactory) {
        this.cacheFactory = cacheFactory;
    }

    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        if (cacheFactory != null && ConfigUtils.isNotEmpty(invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.CACHE_KEY))) {
            // 使用CacheFactory$Adaptive獲取具體的CacheFactory，然后再使用具體的CacheFactory獲取具體的Cache對象
            Cache cache = cacheFactory.getCache(invoker.getUrl().addParameter(Constants.METHOD_KEY, invocation.getMethodName()));
            if (cache != null) {
                // 緩存對象的key為arg1,arg2,arg3,...,arg4
                String key = StringUtils.toArgumentString(invocation.getArguments());
                // 獲取緩存value
                Object value = cache.get(key);
                if (value != null) {
                    return new RpcResult(value);
                }
                Result result = invoker.invoke(invocation);
                // 響應結果沒有exception信息，則將相應結果的值塞入緩存
                if (!result.hasException()) {
                    cache.put(key, result.getValue());
                }
                return result;
            }
        }
        return invoker.invoke(invocation);
    }
}

從@Activate(group = {Constants.CONSUMER, Constants.PROVIDER}, value = Constants.CACHE_KEY)中我們可以看出，consumer端或provider端配置了cache="xxx"，則會走該CacheFilter。

首先獲取具體Cache實例：CacheFilter中的cacheFactory屬性是CacheFactory$Adaptive實例。

public class CacheFactory$Adaptive implements com.alibaba.dubbo.cache.CacheFactory {
    public com.alibaba.dubbo.cache.Cache getCache(com.alibaba.dubbo.common.URL arg0) {
        if (arg0 == null) throw new IllegalArgumentException("url == null");
        com.alibaba.dubbo.common.URL url = arg0;
        String extName = url.getParameter("cache", "lru");
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.cache.CacheFactory) name from url(" + url.toString() + ") use keys([cache])");
        // 獲取具體的CacheFactory
        com.alibaba.dubbo.cache.CacheFactory extension = (com.alibaba.dubbo.cache.CacheFactory) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.cache.CacheFactory.class).getExtension(extName);
        // 使用具體的CacheFactory獲取具體的Cache
        return extension.getCache(arg0);
    }
}

這里extName使我們配置的lru，如果不配置，默認也是lru。這里獲取到的具體的CacheFactory是LruCacheFactory。

@SPI("lru")
public interface CacheFactory {
    @Adaptive("cache")
    Cache getCache(URL url);
}

public abstract class AbstractCacheFactory implements CacheFactory {
    private final ConcurrentMap<String, Cache> caches = new ConcurrentHashMap<String, Cache>();

    public Cache getCache(URL url) {
        String key = url.toFullString();
        Cache cache = caches.get(key);
        if (cache == null) {
            caches.put(key, createCache(url));
            cache = caches.get(key);
        }
        return cache;
    }

    protected abstract Cache createCache(URL url);
}

public class LruCacheFactory extends AbstractCacheFactory {
    protected Cache createCache(URL url) {
        return new LruCache(url);
    }
}

調用LruCacheFactory.getCache(URL url)方法，實際上調用的是其父類AbstractCacheFactory的方法。邏輯是：創建一個LruCache實例，之后存儲在ConcurrentMap<String, Cache> caches中，key為url.toFullString()。

再來看LruCache的創建：

public interface Cache {
    void put(Object key, Object value);
    Object get(Object key);
}

public class LruCache implements Cache {
    private final Map<Object, Object> store;

    public LruCache(URL url) {
        final int max = url.getParameter("cache.size", 1000);
        this.store = new LRUCache<Object, Object>(max);
    }

    public void put(Object key, Object value) {
        store.put(key, value);
    }

    public Object get(Object key) {
        return store.get(key);
    }
}

默認緩存存儲的最大個數為1000個。之后創建了一個LRUCache對象。

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private static final long serialVersionUID = -5167631809472116969L;

    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    private static final int DEFAULT_MAX_CAPACITY = 1000;
    private final Lock lock = new ReentrantLock();
    private volatile int maxCapacity;

    public LRUCache(int maxCapacity) {
        /**
         * 注意：
         * LinkedHashMap 維護着一個運行於所有Entry的雙向鏈表：此鏈表定義了迭代順序，該迭代順序可以是插入順序或者是訪問順序
         * 而真正存儲的數據結構還是其父類HashMap的那個Entry[]數組，上述的雙向鏈表僅用於維護迭代順序（幫助實現lru算法等） 15          *
         * LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
         * 第三個參數accessOrder：false（插入順序），true（訪問順序）
         */
        super(16, DEFAULT_LOAD_FACTOR, true);
        this.maxCapacity = maxCapacity;
    }

    /**
     * 是否需要刪除最老的數據（即最近沒有被訪問的數據）
     * @param eldest
     * @return
     */
    @Override
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
        return size() > maxCapacity;
    }

    @Override
    public V get(Object key) {
        try {
            lock.lock();
            return super.get(key);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public V put(K key, V value) {
        try {
            lock.lock();
            return super.put(key, value);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public V remove(Object key) {
        try {
            lock.lock();
            return super.remove(key);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public int size() {
        try {
            lock.lock();
            return super.size();
        } finally {
            lock.unlock();
        }
    }
    ...
}

注意：

• LinkedHashMap維護着一個運行於所有Entry的雙向鏈表：此鏈表定義了迭代順序，該迭代順序可以是插入順序或者是訪問順序（真正存儲的數據結構還是其父類HashMap的那個Entry[]數組，上述的雙向鏈表僅用於維護迭代順序）
• 當指定了LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)第三個參數accessOrder=true時，每次執行get(Object key)時，獲取出來的Entry都會被放到尾節點，也就是說雙向鏈表的header節點是最久以前訪問的，當執行put(Object key, Object value)的時候，就執行removeEldestEntry(java.util.Map.Entry<K, V> eldest)來判斷是否需要刪除這個header節點。（這些是LinkedHashMap實現的，具體源碼分析見 https://yikun.github.io/2015/04/02/Java-LinkedHashMap%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86%E5%8F%8A%E5%AE%9E%E7%8E%B0/  http://wiki.jikexueyuan.com/project/java-collection/linkedhashmap.html）

 

三、ThreadLocal緩存源碼解析

根據文章開頭提到的bug，cache=""只能配置在服務級別。

<dubbo:reference id="demoService" check="false" interface="com.alibaba.dubbo.demo.DemoService" cache="threadlocal"/>

public class ThreadLocalCacheFactory extends AbstractCacheFactory {
    protected Cache createCache(URL url) {
        return new ThreadLocalCache(url);
    }
}

public class ThreadLocalCache implements Cache {
    private final ThreadLocal<Map<Object, Object>> store;

    public ThreadLocalCache(URL url) {
        this.store = new ThreadLocal<Map<Object, Object>>() {
            @Override
            protected Map<Object, Object> initialValue() {
                return new HashMap<Object, Object>();
            }
        };
    }

    public void put(Object key, Object value) {
        store.get().put(key, value);
    }

    public Object get(Object key) {
        return store.get().get(key);
    }
}

ThreadLocalCache的實現是HashMap。

 

四、JCache緩存源碼解析

//TODO