深刻理解Spring Cache框架

本文是緩存系列第三篇，前兩篇分別介紹了 Guava 和 JetCache。

前兩篇咱們講了 Guava 和 JetCache，它們都是緩存的具體實現，今天給你們分析一下 Spring 框架自己對這些緩存具體實現的支持和融合。使用 Spring Cache 將大大的減小咱們的Spring項目中緩存使用的複雜度，提升代碼可讀性。本文將從如下幾個方面來認識Spring Cache框架。

背景

SpringCache 產生的背景其實與Spring產生的背景有點相似。因爲 Java EE 系統框架臃腫、低效，代碼可觀性低，對象建立和依賴關係複雜， Spring 框架出來了，目前基本上全部的Java後臺項目都離不開 Spring 或 SpringBoot (對 Spring 的進一步簡化)。如今項目面臨高併發的問題愈來愈多，各種緩存的應用也增多，那麼在通用的 Spring 框架上，就須要有一種更加便捷簡單的方式，來完成緩存的支持，就這樣 SpringCache就出現了。

不過首先咱們須要明白的一點是，SpringCache 並不是某一種 Cache 實現的技術，SpringCache 是一種緩存實現的通用技術，基於 Spring 提供的 Cache 框架，讓開發者更容易將本身的緩存實現高效便捷的嵌入到本身的項目中。固然，SpringCache 也提供了自己的簡單實現 NoOpCacheManager、ConcurrentMapCacheManager 等。經過 SpringCache，能夠快速嵌入本身的Cache實現。

用法

源碼已分享至Github： github.com/zhuzhenke/c…

注意點：

一、開啓 EnableCaching 註解，默認沒有開啓 Cache。

二、配置 CacheManager。

@Bean@Qualifier("concurrentMapCacheManager")@PrimaryConcurrentMapCacheManager concurrentMapCacheManager() {  return new ConcurrentMapCacheManager();}複製代碼

這裏使用了 @Primary 和 @Qualifier 註解，@Qualifier 註解是給這個 Bean 加一個名字，用於同一個接口 Bean 的多個實現時，指定當前 Bean 的名字，也就意味着 CacheManager 能夠配置多個，而且在不一樣的方法場景下使用。@Primary 註解是當接口 Bean 有多個時，優先注入當前 Bean 。

如今拿 CategoryService 實現來分析

public class CategoryService {   @Caching(evict = {@CacheEvict(value = CategoryCacheConstants.CATEGORY_DOMAIN,      key = "#category.getCategoryCacheKey()",      beforeInvocation = true)})  public int add(Category category) {    System.out.println("模擬進行數據庫交互操做......");    System.out.println("Cache became invalid,value:" + CategoryCacheConstants.CATEGORY_DOMAIN        + ",key:" + category.getCategoryCacheKey());    return 1;  }   @Caching(evict = {@CacheEvict(value = CategoryCacheConstants.CATEGORY_DOMAIN,      key = "#category.getCategoryCacheKey()",      beforeInvocation = true)})  public int delete(Category category) {    System.out.println("模擬進行數據庫交互操做......");    System.out.println("Cache became invalid,value:" + CategoryCacheConstants.CATEGORY_DOMAIN        + ",key:" + category.getCategoryCacheKey());    return 0;  }   @Caching(evict = {@CacheEvict(value = CategoryCacheConstants.CATEGORY_DOMAIN,      key = "#category.getCategoryCacheKey()")})  public int update(Category category) {    System.out.println("模擬進行數據庫交互操做......");    System.out.println("Cache updated,value:" + CategoryCacheConstants.CATEGORY_DOMAIN        + ",key:" + category.getCategoryCacheKey()        + ",category:" + category);    return 1;  }   @Cacheable(value = CategoryCacheConstants.CATEGORY_DOMAIN,      key = "#category.getCategoryCacheKey()")  public Category get(Category category) {    System.out.println("模擬進行數據庫交互操做......");    Category result = new Category();    result.setCateId(category.getCateId());    result.setCateName(category.getCateId() + "CateName");    result.setParentId(category.getCateId() - 10);    return result;  }}複製代碼

CategoryService 經過對 category 對象的數據庫增刪改查，模擬緩存失效和緩存增長的結果。使用很是簡便，把註解加在方法上，則能夠達到緩存的生效和失效方案。

深刻源碼

源碼分析咱們分爲幾個方面一步一步解釋其中的實現原理和實現細節。源碼基於 Spring 4.3.7.RELEASE 分析。

發現

SpringCache 在方法上使用註解發揮緩存的做用，緩存的發現是基於 AOP 的 PointCut 和 MethodMatcher 經過在注入的 class 中找到每一個方法上的註解，並解析出來。

首先看到 org.springframework.cache.annotation.SpringCacheAnnotationParser 類：

protected Collection<CacheOperation> parseCacheAnnotations(DefaultCacheConfig cachingConfig, AnnotatedElement ae) { Collection<CacheOperation> ops = null;  Collection<Cacheable> cacheables = AnnotatedElementUtils.getAllMergedAnnotations(ae, Cacheable.class); if (!cacheables.isEmpty()) { ops = lazyInit(ops); for (Cacheable cacheable : cacheables) {  ops.add(parseCacheableAnnotation(ae, cachingConfig, cacheable)); } } Collection<CacheEvict> evicts = AnnotatedElementUtils.getAllMergedAnnotations(ae, CacheEvict.class); if (!evicts.isEmpty()) { ops = lazyInit(ops); for (CacheEvict evict : evicts) {  ops.add(parseEvictAnnotation(ae, cachingConfig, evict)); } } Collection<CachePut> puts = AnnotatedElementUtils.getAllMergedAnnotations(ae, CachePut.class); if (!puts.isEmpty()) { ops = lazyInit(ops); for (CachePut put : puts) {  ops.add(parsePutAnnotation(ae, cachingConfig, put)); } } Collection<Caching> cachings = AnnotatedElementUtils.getAllMergedAnnotations(ae, Caching.class); if (!cachings.isEmpty()) { ops = lazyInit(ops); for (Caching caching : cachings) {  Collection<CacheOperation> cachingOps = parseCachingAnnotation(ae, cachingConfig, caching);  if (cachingOps != null) {  ops.addAll(cachingOps);  } } }  return ops;}複製代碼

這個方法會解析 Cacheable、CacheEvict、CachePut 和 Caching 4個註解，找到方法上的這4個註解後，會將註解中的參數解析出來，做爲後續註解生效的一個依據。這裏舉例說一下 CacheEvict 註解。

CacheEvictOperation parseEvictAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, CacheEvict cacheEvict) { CacheEvictOperation.Builder builder = new CacheEvictOperation.Builder();  builder.setName(ae.toString()); builder.setCacheNames(cacheEvict.cacheNames()); builder.setCondition(cacheEvict.condition()); builder.setKey(cacheEvict.key()); builder.setKeyGenerator(cacheEvict.keyGenerator()); builder.setCacheManager(cacheEvict.cacheManager()); builder.setCacheResolver(cacheEvict.cacheResolver()); builder.setCacheWide(cacheEvict.allEntries()); builder.setBeforeInvocation(cacheEvict.beforeInvocation());  defaultConfig.applyDefault(builder); CacheEvictOperation op = builder.build(); validateCacheOperation(ae, op);  return op;}複製代碼

CacheEvict 註解是用於緩存失效。這裏代碼會根據 CacheEvict 的配置生產一個 CacheEvictOperation 的類，註解上的 name、key、cacheManager 和 beforeInvocation 等都會傳遞進來。

另外須要將一下 Caching 註解，這個註解經過 parseCachingAnnotation 方法解析參數，會拆分紅 Cacheable、CacheEvict、CachePut 註解，也就對應咱們緩存中的增長、失效和更新操做。

Collection<CacheOperation> parseCachingAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, Caching caching) { Collection<CacheOperation> ops = null;  Cacheable[] cacheables = caching.cacheable(); if (!ObjectUtils.isEmpty(cacheables)) { ops = lazyInit(ops); for (Cacheable cacheable : cacheables) {  ops.add(parseCacheableAnnotation(ae, defaultConfig, cacheable)); } } CacheEvict[] cacheEvicts = caching.evict(); if (!ObjectUtils.isEmpty(cacheEvicts)) { ops = lazyInit(ops); for (CacheEvict cacheEvict : cacheEvicts) {  ops.add(parseEvictAnnotation(ae, defaultConfig, cacheEvict)); } } CachePut[] cachePuts = caching.put(); if (!ObjectUtils.isEmpty(cachePuts)) { ops = lazyInit(ops); for (CachePut cachePut : cachePuts) {  ops.add(parsePutAnnotation(ae, defaultConfig, cachePut)); } }  return ops;}複製代碼

而後回到 AbstractFallbackCacheOperationSource 類：

public Collection<CacheOperation> getCacheOperations(Method method, Class<?> targetClass) { if (method.getDeclaringClass() == Object.class) { return null; }  Object cacheKey = getCacheKey(method, targetClass); Collection<CacheOperation> cached = this.attributeCache.get(cacheKey);  if (cached != null) { return (cached != NULL_CACHING_ATTRIBUTE ? cached : null); } else { Collection<CacheOperation> cacheOps = computeCacheOperations(method, targetClass); if (cacheOps != null) {  if (logger.isDebugEnabled()) {  logger.debug("Adding cacheable method '" + method.getName() + "' with attribute: " + cacheOps);  }  this.attributeCache.put(cacheKey, cacheOps); } else {  this.attributeCache.put(cacheKey, NULL_CACHING_ATTRIBUTE); } return cacheOps; }}

複製代碼

這裏會將解析出來的 CacheOperation 放在當前 Map<Object, Collection<CacheOperation>> attributeCache = new ConcurrentHashMap<Object, Collection<CacheOperation>>(1024); 屬性上，爲後續攔截方法時處理緩存作好數據的準備。

註解產生做用

當訪問 categoryService.get(category) 方法時，會走到 CglibAopProxy.intercept() 方法，這也說明緩存註解是基於動態代理實現，經過方法的攔截來動態設置或失效緩存。方法中會經過 List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); 來拿到當前調用方法的 Interceptor 鏈。往下走會調用 CacheInterceptor 的 invoke 方法，最終調用 execute 方法，咱們重點分析這個方法的實現。

private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts) { // Special handling of synchronized invocation if (contexts.isSynchronized()) { CacheOperationContext context = contexts.get(CacheableOperation.class).iterator().next(); if (isConditionPassing(context, CacheOperationExpressionEvaluator.NO_RESULT)) {  Object key = generateKey(context, CacheOperationExpressionEvaluator.NO_RESULT);  Cache cache = context.getCaches().iterator().next();  try {  return wrapCacheValue(method, cache.get(key, new Callable<Object>() {   @Override   public Object call() throws Exception {   return unwrapReturnValue(invokeOperation(invoker));   }  }));  }  catch (Cache.ValueRetrievalException ex) {  // The invoker wraps any Throwable in a ThrowableWrapper instance so we  // can just make sure that one bubbles up the stack.  throw (CacheOperationInvoker.ThrowableWrapper) ex.getCause();  } } else {  // No caching required, only call the underlying method  return invokeOperation(invoker); } }  // Process any early evictions processCacheEvicts(contexts.get(CacheEvictOperation.class), true,  CacheOperationExpressionEvaluator.NO_RESULT);  // Check if we have a cached item matching the conditions Cache.ValueWrapper cacheHit = findCachedItem(contexts.get(CacheableOperation.class));  // Collect puts from any @Cacheable miss, if no cached item is found List<CachePutRequest> cachePutRequests = new LinkedList<CachePutRequest>(); if (cacheHit == null) { collectPutRequests(contexts.get(CacheableOperation.class),  CacheOperationExpressionEvaluator.NO_RESULT, cachePutRequests); }  Object cacheValue; Object returnValue;  if (cacheHit != null && cachePutRequests.isEmpty() && !hasCachePut(contexts)) { // If there are no put requests, just use the cache hit cacheValue = cacheHit.get(); returnValue = wrapCacheValue(method, cacheValue); } else { // Invoke the method if we don't have a cache hit returnValue = invokeOperation(invoker); cacheValue = unwrapReturnValue(returnValue); } // Collect any explicit @CachePuts collectPutRequests(contexts.get(CachePutOperation.class), cacheValue, cachePutRequests); // Process any collected put requests, either from @CachePut or a @Cacheable miss for (CachePutRequest cachePutRequest : cachePutRequests) { cachePutRequest.apply(cacheValue); } // Process any late evictions processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue); return returnValue;}複製代碼

咱們的方法沒有使用同步，走到 processCacheEvicts 方法。

private void processCacheEvicts(Collection<CacheOperationContext> contexts, boolean beforeInvocation, Object result) { for (CacheOperationContext context : contexts) { CacheEvictOperation operation = (CacheEvictOperation) context.metadata.operation; if (beforeInvocation == operation.isBeforeInvocation() && isConditionPassing(context, result)) {  performCacheEvict(context, operation, result); } }}複製代碼

注意這個方法傳入的 beforeInvocation 參數是 true，說明是方法執行前進行的操做，這裏是取出 CacheEvictOperation，operation.isBeforeInvocation()，調用下面方法：

private void performCacheEvict(CacheOperationContext context, CacheEvictOperation operation, Object result) { Object key = null; for (Cache cache : context.getCaches()) { if (operation.isCacheWide()) {  logInvalidating(context, operation, null);  doClear(cache); } else {  if (key == null) {  key = context.generateKey(result);  }  logInvalidating(context, operation, key);  doEvict(cache, key); } }}複製代碼

這裏須要注意了，operation 中有個參數 cacheWide，若是使用這個參數並設置爲true，則在緩存失效時，會調用 clear 方法進行所有緩存的清理，不然只對當前 key 進行 evict 操做。本文中，doEvict() 最終會調用到 ConcurrentMapCache的evict(Object key) 方法，將 key 緩存失效。

回到 execute 方法，走到 Cache.ValueWrapper cacheHit = findCachedItem(contexts.get(CacheableOperation.class)); 這一步，這裏會根據當前方法是否有 CacheableOperation 註解，進行緩存的查詢，若是沒有命中緩存，則會調用方法攔截器 CacheInterceptor 的 proceed 方法，進行原方法的調用，獲得緩存 key 對應的 value，而後經過 cachePutRequest.apply(cacheValue) 設置緩存。

public void apply(Object result) { if (this.context.canPutToCache(result)) { for (Cache cache : this.context.getCaches()) {  doPut(cache, this.key, result); } }}複製代碼

doPut() 方法最終對調用到 ConcurrentMapCache 的 put 方法，完成緩存的設置工做。

最後 execute 方法還有最後一步 processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue); 處理針對執行方法後緩存失效的註解策略。

優缺點

優勢

方便快捷高效，可直接嵌入多個現有的 cache 實現，簡寫了不少代碼，可觀性很是強。

缺點

• 內部調用，非 public 方法上使用註解，會致使緩存無效。因爲 SpringCache 是基於 Spring AOP 的動態代理實現，因爲代理自己的問題，當同一個類中調用另外一個方法，會致使另外一個方法的緩存不能使用，這個在編碼上須要注意，避免在同一個類中這樣調用。若是非要這樣作，能夠經過再次代理調用，如 ((Category)AopContext.currentProxy()).get(category) 這樣避免緩存無效。
• 不能支持多級緩存設置，如默認到本地緩存取數據，本地緩存沒有則去遠端緩存取數據，而後遠程緩存取回來數據再存到本地緩存。
  

擴展知識點

• 動態代理：JDK、CGLIB代理。
• SpringAOP、方法攔截器。

以上就是本文的所有內容，但願對你們的學習有所幫助，

 你們以爲不錯能夠點個贊在關注下，之後還會分享更多文章！