玩转Spring Cache --- @Cacheable/@CachePut/@CacheEvict缓存注解相关基础类打点【享学Spring】

不念不忘少年蓝@ 2021-12-15 01:47 443阅读 0赞

每篇一句

写书和翻译最重要的是把事做好，而不是为了让书上有你的名字

前言

本文算是了解缓存注解原理的先行文章，因为它抽象出来的模块类比较多，所以做这篇文章进行关键类的打点。
若我们需要扩展缓存注解的能力，对这些抽象是非常有必要深入了解的~

Spring内置的三大注解缓存是：

  1. Cacheable：缓存
  2. CacheEvict：删除缓存
  3. CachePut：更新缓存

CacheOperation：缓存操作

它是缓存操作的基类。我们知道不同的缓存注解，都有不同的缓存操作并且注解内的属性也挺多，此类就是对缓存操作的抽象

  1. // @since 3.1 三大缓存注解属性的基类~~~
  2. public abstract class CacheOperation implements BasicOperation { 
  4.     private final String name;
  5.     private final Set<String> cacheNames;
  6.     private final String key;
  7.     private final String keyGenerator;
  8.     private final String cacheManager;
  9.     private final String cacheResolver;
  10.     private final String condition;
  12.     // 把toString()作为一个成员变量记着了 因为调用的次数太多
  13.     private final String toString;
  15.     // 构造方法是protected 的~~~ 入参一个Builder来对各个属性赋值
  16.     // builder方式是@since 4.3提供的，显然Spring4.3对这部分进行了改造~
  17.     protected CacheOperation(Builder b) { 
  18.         this.name = b.name;
  19.         this.cacheNames = b.cacheNames;
  20.         this.key = b.key;
  21.         this.keyGenerator = b.keyGenerator;
  22.         this.cacheManager = b.cacheManager;
  23.         this.cacheResolver = b.cacheResolver;
  24.         this.condition = b.condition;
  25.         this.toString = b.getOperationDescription().toString();
  26.     }
  27.     ... // 省略所有的get/set（其实builder里都只有set方法~~~）
  29.     // 它的public静态抽象内部类 Builder 简单的说，它是构建一个CacheOperation的构建器
  30.     public abstract static class Builder { 
  31.         private String name = "";
  32.         private Set<String> cacheNames = Collections.emptySet();
  33.         private String key = "";
  34.         private String keyGenerator = "";
  35.         private String cacheManager = "";
  36.         private String cacheResolver = "";
  37.         private String condition = "";
  38.         // 省略所有的get/set
  40.         // 抽象方法 自行实现~
  41.         public abstract CacheOperation build();
  42.     }
  44. }
  46. // @since 4.1 
  47. public interface BasicOperation { 
  48.     Set<String> getCacheNames();
  49. }

它的继承图谱如下：
在这里插入图片描述
对应着三个注解，Spring提供了三种不同的操作实现。基类CacheOperation里封装的是三哥们都共有的属性，所以实现类里处理各自的个性化属性~~~~

  1. // @since 3.1
  2. public class CacheableOperation extends CacheOperation { 
  3.     @Nullable
  4.     private final String unless;
  5.     private final boolean sync;
  7.     public CacheableOperation(CacheableOperation.Builder b) { 
  8.         super(b);
  9.         this.unless = b.unless;
  10.         this.sync = b.sync;
  11.     }
  12.     ... // 省略get方法（无set方法哦）
  14.     // @since 4.3
  15.     public static class Builder extends CacheOperation.Builder { 
  16.         @Nullable
  17.         private String unless;
  18.         private boolean sync;
  19.         ... // 生路set方法（没有get方法哦~）
  21.         // Spring4.3抽象的这个技巧还是不错的，此处传this进去即可
  22.         @Override
  23.         public CacheableOperation build() { 
  24.             return new CacheableOperation(this);
  25.         }
  27.         @Override
  28.         protected StringBuilder getOperationDescription() { 
  29.             StringBuilder sb = super.getOperationDescription();
  30.             sb.append(" | unless='");
  31.             sb.append(this.unless);
  32.             sb.append("'");
  33.             sb.append(" | sync='");
  34.             sb.append(this.sync);
  35.             sb.append("'");
  36.             return sb;
  37.         }
  39.     }
  40. }

因为三哥们的实现完全一样，所以此处只需要举CacheableOperation这一个例子即可

CacheOperationSource：缓存属性源

缓存属性源。该接口被CacheInterceptor它使用。它能够获取到Method上所有的缓存操作集合：

  1. // @since 3.1
  2. public interface CacheOperationSource { 
  4.     // 返回此Method方法上面所有的缓存操作~~~~CacheOperation 集合
  5.     // 显然一个Method上可以对应有多个缓存操作~~~~
  6.     @Nullable
  7.     Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass);
  9. }

它的继承树如下：
在这里插入图片描述
这里面有最为重要的AnnotationCacheOperationSource，以及还有NameMatchCacheOperationSource根据名称匹配的实现。

NameMatchCacheOperationSource

根据方法名称来匹配看看作用在此方法上的缓存操作有哪些~（不需要注解了）

  1. // @since 3.1
  2. public class NameMatchCacheOperationSource implements CacheOperationSource, Serializable { 
  4.     /** Keys are method names; values are TransactionAttributes. */
  5.     private Map<String, Collection<CacheOperation>> nameMap = new LinkedHashMap<>();
  7.     // 你配置的时候，可以调用此方法。这里使用的也是add方法
  8.     // 先拦截这个方法，然后看看这个方法有木有匹配的缓存操作，有点想AOP的配置
  9.     public void setNameMap(Map<String, Collection<CacheOperation>> nameMap) { 
  10.         nameMap.forEach(this::addCacheMethod);
  11.     }
  12.     public void addCacheMethod(String methodName, Collection<CacheOperation> ops) { 
  13.         // 输出debug日志
  14.         if (logger.isDebugEnabled()) { 
  15.             logger.debug("Adding method [" + methodName + "] with cache operations [" + ops + "]");
  16.         }
  17.         this.nameMap.put(methodName, ops);
  18.     }
  21.     // 这部分逻辑挺简单，就是根据方法去Map类里匹配到一个最为合适的Collection<CacheOperation>
  22.     @Override
  23.     @Nullable
  24.     public Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass) { 
  25.         // look for direct name match
  26.         String methodName = method.getName();
  27.         Collection<CacheOperation> ops = this.nameMap.get(methodName);
  29.         // 若不是null就直接return了~ 首次进来，都会进入到这个逻辑~~~~
  30.         if (ops == null) { 
  31.             // Look for most specific name match. // 找打一个最适合的 最匹配的
  32.             String bestNameMatch = null;
  33.             // 遍历所有外部已经制定进来了的方法名们~~~~
  34.             for (String mappedName : this.nameMap.keySet()) { 
  35.                 // isMatch就是Ant风格匹配~~(第一步) 光Ant匹配上了还不算
  36.                 // 第二步：bestNameMatch=null或者
  37.                 if (isMatch(methodName, mappedName)
  38.                         && (bestNameMatch == null || bestNameMatch.length() <= mappedName.length())) { 
  39.                     // mappedName为匹配上了的名称~~~~ 给bestNameMatch 赋值 
  40.                     // 继续循环，最终找到一个最佳的匹配~~~~
  41.                     ops = this.nameMap.get(mappedName);
  42.                     bestNameMatch = mappedName;
  43.                 }
  44.             }
  45.         }
  47.         return ops;
  48.     }
  50.     protected boolean isMatch(String methodName, String mappedName) { 
  51.         return PatternMatchUtils.simpleMatch(mappedName, methodName);
  52.     }
  53.     ...
  54. }

这个Collection<CacheOperation>的匹配规则很简单，就是使用methodName进行匹配的，支持Ant风格匹配模式。

AbstractFallbackCacheOperationSource

这个抽象方法主要目的是：让缓存注解（当然此抽象类并不要求一定是注解，别的方式也成）既能使用在类上，也能使用在方法上。方法上没找到，就Fallback到类上去找。

并且它还支持把注解写在接口上，哪怕你只是一个JDK动态代理的实现而已。比如我们的MyBatis Mapper接口上也是可以直接使用缓存注解的~

  1. // @since 3.1
  2. public abstract class AbstractFallbackCacheOperationSource implements CacheOperationSource { 
  4.     private static final Collection<CacheOperation> NULL_CACHING_ATTRIBUTE = Collections.emptyList();
  6.     // 这个Map初始值可不小，因为它要缓存所有的Method
  7.     private final Map<Object, Collection<CacheOperation>> attributeCache = new ConcurrentHashMap<>(1024);
  10.     @Override
  11.     @Nullable
  12.     public Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass) { 
  13.         // 如果这个方法是Object的方法，那就不考虑缓存操作~~~
  14.         if (method.getDeclaringClass() == Object.class) { 
  15.             return null;
  16.         }
  18.         // 以method和Class作为上面缓存Map的key
  19.         Object cacheKey = getCacheKey(method, targetClass);
  20.         Collection<CacheOperation> cached = this.attributeCache.get(cacheKey);
  21.         if (cached != null) { 
  22.             return (cached != NULL_CACHING_ATTRIBUTE ? cached : null);
  23.         }
  25.         // 核心处理逻辑：包括AnnotationCacheOperationSource的主要逻辑也是沿用的这个模版
  26.         else { 
  28.             // computeCacheOperations计算缓存属性，这个方法是本类的灵魂，见下面
  29.             Collection<CacheOperation> cacheOps = computeCacheOperations(method, targetClass);
  30.             if (cacheOps != null) { 
  31.                 if (logger.isTraceEnabled()) { 
  32.                     logger.trace("Adding cacheable method '" + method.getName() + "' with attribute: " + cacheOps);
  33.                 }
  34.                 this.attributeCache.put(cacheKey, cacheOps);
  35.             } else {  // 若没有标注属性的方法，用NULL_CACHING_ATTRIBUTE占位~ 不用null值哦~~~~ Spring内部大都不直接使用null
  36.                 this.attributeCache.put(cacheKey, NULL_CACHING_ATTRIBUTE);
  37.             }
  38.             return cacheOps;
  39.         }
  40.     }
  42.     @Nullable
  43.     private Collection<CacheOperation> computeCacheOperations(Method method, @Nullable Class<?> targetClass) { 
  44.         // Don't allow no-public methods as required.
  45.         // allowPublicMethodsOnly()默认是false（子类复写后的默认值已经写为true了）
  46.         // 也就是说：缓存注解只能标注在public方法上~~~~不接收别非public方法~~~
  47.         if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) { 
  48.             return null;
  49.         }
  51.         // The method may be on an interface, but we need attributes from the target class.
  52.         // If the target class is null, the method will be unchanged.
  53.         Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
  55.         // First try is the method in the target class.
  56.         // 第一步：先去该方法上找，看看有木有啥缓存属性 有就返回
  57.         Collection<CacheOperation> opDef = findCacheOperations(specificMethod);
  58.         if (opDef != null) { 
  59.             return opDef;
  60.         }
  62.         // Second try is the caching operation on the target class.
  63.         // 第二步：方法上没有，就再去方法所在的类上去找。
  64.         // isUserLevelMethod：我们自己书写的方法（非自动生成的） 才直接return，否则继续处理
  65.         opDef = findCacheOperations(specificMethod.getDeclaringClass());
  66.         if (opDef != null && ClassUtils.isUserLevelMethod(method)) { 
  67.             return opDef;
  68.         }
  70.         // 他俩不相等，说明method这个方法它是标注在接口上的，这里也给与了支持
  71.         // 此处透露的性息：我们的缓存注解也可以标注在接口方法上，比如MyBatis的接口上都是ok的~~~~
  72.         if (specificMethod != method) { 
  73.             // Fallback is to look at the original method.
  74.             opDef = findCacheOperations(method);
  75.             if (opDef != null) { 
  76.                 return opDef;
  77.             }
  78.             // Last fallback is the class of the original method.
  79.             opDef = findCacheOperations(method.getDeclaringClass());
  80.             if (opDef != null && ClassUtils.isUserLevelMethod(method)) { 
  81.                 return opDef;
  82.             }
  83.         }
  85.         return null;
  86.     }
  88.     @Nullable
  89.     protected abstract Collection<CacheOperation> findCacheOperations(Class<?> clazz);
  90.     @Nullable
  91.     protected abstract Collection<CacheOperation> findCacheOperations(Method method);
  92.     protected boolean allowPublicMethodsOnly() { 
  93.         return false;
  94.     }
  95. }

该抽象类提供的能力是：你的缓存属性可以放在方法上，方法上没有的话会去类上找，它有大名鼎鼎的实现类：AnnotationCacheOperationSource

AnnotationCacheOperationSource

从名字就可以看出，它是和缓存注解有关的缓存属性源。它能够处理上述的三大缓存注解。

  1. // @since 3.1
  2. public class AnnotationCacheOperationSource extends AbstractFallbackCacheOperationSource implements Serializable { 
  4.     // 是否只允许此注解标注在public方法上？？？下面有设置值为true
  5.     // 该属性只能通过构造函数赋值
  6.     private final boolean publicMethodsOnly;
  7.     private final Set<CacheAnnotationParser> annotationParsers;
  9.     // 默认就设置了publicMethodsOnly=true
  10.     public AnnotationCacheOperationSource() { 
  11.         this(true);
  12.     }
  13.     public AnnotationCacheOperationSource(boolean publicMethodsOnly) { 
  14.         this.publicMethodsOnly = publicMethodsOnly;
  15.         this.annotationParsers = Collections.singleton(new SpringCacheAnnotationParser());
  16.     }
  17.     ...
  18.     // 也可以自己来实现注解的解析器。（比如我们要做自定义注解的话，可以这么搞~~~）
  19.     public AnnotationCacheOperationSource(CacheAnnotationParser... annotationParsers) { 
  20.         this.publicMethodsOnly = true;
  21.         this.annotationParsers = new LinkedHashSet<>(Arrays.asList(annotationParsers));
  22.     }
  24.     // 这两个方法：核心事件都交给了CacheAnnotationParser.parseCacheAnnotations方法
  25.     @Override
  26.     @Nullable
  27.     protected Collection<CacheOperation> findCacheOperations(Class<?> clazz) { 
  28.         return determineCacheOperations(parser -> parser.parseCacheAnnotations(clazz));
  29.     }
  30.     @Override
  31.     @Nullable
  32.     protected Collection<CacheOperation> findCacheOperations(Method method) { 
  33.         return determineCacheOperations(parser -> parser.parseCacheAnnotations(method));
  34.     }
  36.     // CacheOperationProvider就是一个函数式接口而已~~~类似Function~
  37.     // 这块determineCacheOperations() + CacheOperationProvider接口的设计还是很巧妙的 可以学习一下
  38.     @Nullable
  39.     protected Collection<CacheOperation> determineCacheOperations(CacheOperationProvider provider) { 
  40.         Collection<CacheOperation> ops = null;
  42.         // 调用我们设置进来的所有的CacheAnnotationParser一个一个的处理~~~
  43.         for (CacheAnnotationParser annotationParser : this.annotationParsers) { 
  44.             Collection<CacheOperation> annOps = provider.getCacheOperations(annotationParser);
  46.             // 理解这一块：说明我们方法上、类上是可以标注N个注解的，都会同时生效~~~最后都会combined 
  47.             if (annOps != null) { 
  48.                 if (ops == null) { 
  49.                     ops = annOps;
  50.                 } else { 
  51.                     Collection<CacheOperation> combined = new ArrayList<>(ops.size() + annOps.size());
  52.                     combined.addAll(ops);
  53.                     combined.addAll(annOps);
  54.                     ops = combined;
  55.                 }
  56.             }
  57.         }
  58.         return ops;
  59.     }
  60. }

它专用于处理三大缓存注解，就是获取标注在方法上的缓存注解们。
另外需要说明的是：若你想扩展你自己的缓存注解（比如加上超时时间TTL），你的处理器可以可以继承自AnnotationCacheOperationSource，然后进行自己的扩展吧~

可以看到解析缓存注解这块，依托的一个处理器是：CacheAnnotationParser，下面继续介绍。

CompositeCacheOperationSource

又是Composite组合模式，此设计模式在Spring中大量存在。

  1. public class CompositeCacheOperationSource implements CacheOperationSource, Serializable { 
  2.     // 这里用的数组，表面只能赋值一次 并且只能通过构造函数赋值
  3.     private final CacheOperationSource[] cacheOperationSources;
  4.     public CompositeCacheOperationSource(CacheOperationSource... cacheOperationSources) { 
  5.         this.cacheOperationSources = cacheOperationSources;
  6.     }
  8.     public final CacheOperationSource[] getCacheOperationSources() { 
  9.         return this.cacheOperationSources;
  10.     }
  12.     @Override
  13.     @Nullable
  14.     public Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass) { 
  15.         Collection<CacheOperation> ops = null;
  16.         for (CacheOperationSource source : this.cacheOperationSources) { 
  17.             Collection<CacheOperation> cacheOperations = source.getCacheOperations(method, targetClass);
  18.             if (cacheOperations != null) { 
  19.                 if (ops == null) { 
  20.                     ops = new ArrayList<>();
  21.                 }
  22.                 ops.addAll(cacheOperations);
  23.             }
  24.         }
  25.         return ops;
  26.     }
  28. }

对它的解释就是，所以组合进取的属性源，最终都会叠加生效。
注意：它还是个抽象类哦~~~它的唯一实现如下（匿名内部类）：

  1. public class BeanFactoryCacheOperationSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor { 
  3.     @Nullable
  4.     private CacheOperationSource cacheOperationSource;
  6.     private final CacheOperationSourcePointcut pointcut = new CacheOperationSourcePointcut() { 
  7.         @Override
  8.         @Nullable
  9.         protected CacheOperationSource getCacheOperationSource() { 
  10.             return cacheOperationSource;
  11.         }
  12.     };
  13.     ...
  14. }

CacheAnnotationParser：缓存注解解析器

解析Spring三大注解缓存的策略接口~~~

  1. // @since 3.1
  2. public interface CacheAnnotationParser { 
  3.     @Nullable
  4.     Collection<CacheOperation> parseCacheAnnotations(Class<?> type);
  5.     @Nullable
  6.     Collection<CacheOperation> parseCacheAnnotations(Method method);
  7. }

Spring内建了一个唯一实现类：SpringCacheAnnotationParser。它对把注解解析为缓存属性非常的重要。

  1. // @since 3.1
  2. public class SpringCacheAnnotationParser implements CacheAnnotationParser, Serializable { 
  3.     private static final Set<Class<? extends Annotation>> CACHE_OPERATION_ANNOTATIONS = new LinkedHashSet<>(8);
  4.     // 它能处理的注解类型，一目了然
  5.     static { 
  6.         CACHE_OPERATION_ANNOTATIONS.add(Cacheable.class);
  7.         CACHE_OPERATION_ANNOTATIONS.add(CacheEvict.class);
  8.         CACHE_OPERATION_ANNOTATIONS.add(CachePut.class);
  9.         CACHE_OPERATION_ANNOTATIONS.add(Caching.class);
  10.     }
  12.     // 处理class和Method
  13.     // 使用DefaultCacheConfig，把它传给parseCacheAnnotations() 来给注解属性搞定默认值
  14.     // 至于为何自己要新new一个呢？？？其实是因为@CacheConfig它只能放在类上呀~~~（传Method也能获取到类）
  15.     // 返回值都可以为null（没有标注此注解方法、类 那肯定返回null啊）
  16.     @Override
  17.     @Nullable
  18.     public Collection<CacheOperation> parseCacheAnnotations(Class<?> type) { 
  19.         DefaultCacheConfig defaultConfig = new DefaultCacheConfig(type);
  20.         return parseCacheAnnotations(defaultConfig, type);
  21.     }
  22.     @Override
  23.     @Nullable
  24.     public Collection<CacheOperation> parseCacheAnnotations(Method method) { 
  25.         DefaultCacheConfig defaultConfig = new DefaultCacheConfig(method.getDeclaringClass());
  26.         return parseCacheAnnotations(defaultConfig, method);
  27.     }
  29.     // 找到方法/类上的注解们~~~
  30.     private Collection<CacheOperation> parseCacheAnnotations(DefaultCacheConfig cachingConfig, AnnotatedElement ae) { 
  31.         // 第三个参数传的false：表示接口的注解它也会看一下~~~
  32.         Collection<CacheOperation> ops = parseCacheAnnotations(cachingConfig, ae, false);
  33.         // 若出现接口方法里也标了，实例方法里也标了，那就继续处理。让以实例方法里标注的为准~~~
  34.         if (ops != null && ops.size() > 1) { 
  35.             // More than one operation found -> local declarations override interface-declared ones...
  36.             Collection<CacheOperation> localOps = parseCacheAnnotations(cachingConfig, ae, true);
  37.             if (localOps != null) { 
  38.                 return localOps;
  39.             }
  40.         }
  41.         return ops;
  42.     }
  43.     private Collection<CacheOperation> parseCacheAnnotations(DefaultCacheConfig cachingConfig, AnnotatedElement ae, boolean localOnly) { 
  45.         // localOnly=true，只看自己的不看接口的。false表示接口的也得看~
  46.         Collection<? extends Annotation> anns = (localOnly ? AnnotatedElementUtils.getAllMergedAnnotations(ae, CACHE_OPERATION_ANNOTATIONS) : AnnotatedElementUtils.findAllMergedAnnotations(ae, CACHE_OPERATION_ANNOTATIONS));
  47.         if (anns.isEmpty()) { 
  48.             return null;
  49.         }
  51.         // 这里为和写个1？？？因为绝大多数情况下，我们都只会标注一个注解~~
  52.         final Collection<CacheOperation> ops = new ArrayList<>(1);
  54.         // 这里的方法parseCacheableAnnotation/parsePutAnnotation等 说白了 就是把注解属性，转换封装成为`CacheOperation`对象~~
  55.         // 注意parseCachingAnnotation方法，相当于~把注解属性转换成了CacheOperation对象 下面以它为例介绍
  56.         anns.stream().filter(ann -> ann instanceof Cacheable).forEach(
  57.                 ann -> ops.add(parseCacheableAnnotation(ae, cachingConfig, (Cacheable) ann)));
  58.         anns.stream().filter(ann -> ann instanceof CacheEvict).forEach(
  59.                 ann -> ops.add(parseEvictAnnotation(ae, cachingConfig, (CacheEvict) ann)));
  60.         anns.stream().filter(ann -> ann instanceof CachePut).forEach(
  61.                 ann -> ops.add(parsePutAnnotation(ae, cachingConfig, (CachePut) ann)));
  62.         anns.stream().filter(ann -> ann instanceof Caching).forEach(
  63.                 ann -> parseCachingAnnotation(ae, cachingConfig, (Caching) ann, ops));
  64.         return ops;
  65.     }
  67.     // CacheableOperation是抽象类CacheOperation的子类~
  68.     private CacheableOperation parseCacheableAnnotation(
  69.             AnnotatedElement ae, DefaultCacheConfig defaultConfig, Cacheable cacheable) { 
  71.         // 这个builder是CacheOperation.Builder的子类，父类规定了所有注解通用的一些属性~~~
  72.         CacheableOperation.Builder builder = new CacheableOperation.Builder();
  74.         builder.setName(ae.toString());
  75.         builder.setCacheNames(cacheable.cacheNames());
  76.         builder.setCondition(cacheable.condition());
  77.         builder.setUnless(cacheable.unless());
  78.         builder.setKey(cacheable.key());
  79.         builder.setKeyGenerator(cacheable.keyGenerator());
  80.         builder.setCacheManager(cacheable.cacheManager());
  81.         builder.setCacheResolver(cacheable.cacheResolver());
  82.         builder.setSync(cacheable.sync());
  84.         // DefaultCacheConfig是本类的一个内部类，来处理buider，给他赋值默认值~~~ 比如默认的keyGenerator等等
  85.         defaultConfig.applyDefault(builder);
  86.         CacheableOperation op = builder.build();
  87.         validateCacheOperation(ae, op); // 校验。key和KeyGenerator至少得有一个 CacheManager和CacheResolver至少得配置一个
  89.         return op;
  90.     }
  91.     ... // 解析其余注解略，一样的。
  93.     // 它其实就是把三三者聚合了，一个一个的遍历。所以它最后一个参数传的ops，在内部进行add
  94.     private void parseCachingAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, Caching caching, Collection<CacheOperation> ops) { 
  96.         Cacheable[] cacheables = caching.cacheable();
  97.         for (Cacheable cacheable : cacheables) { 
  98.             ops.add(parseCacheableAnnotation(ae, defaultConfig, cacheable));
  99.         }
  100.         CacheEvict[] cacheEvicts = caching.evict();
  101.         for (CacheEvict cacheEvict : cacheEvicts) { 
  102.             ops.add(parseEvictAnnotation(ae, defaultConfig, cacheEvict));
  103.         }
  104.         CachePut[] cachePuts = caching.put();
  105.         for (CachePut cachePut : cachePuts) { 
  106.             ops.add(parsePutAnnotation(ae, defaultConfig, cachePut));
  107.         }
  108.     }
  110.     // 设置默认值的私有静态内部类
  111.     private static class DefaultCacheConfig { 
  113.         private final Class<?> target;
  114.         @Nullable
  115.         private String[] cacheNames;
  116.         @Nullable
  117.         private String keyGenerator;
  118.         @Nullable
  119.         private String cacheManager;
  120.         @Nullable
  121.         private String cacheResolver;
  122.         private boolean initialized = false;
  124.         // 唯一构造函数~
  125.         public DefaultCacheConfig(Class<?> target) { 
  126.             this.target = target;
  127.         }
  129.         public void applyDefault(CacheOperation.Builder builder) { 
  130.             // 如果还没初始化过，就进行初始化（毕竟一个类上有多个方法，这种默认通用设置只需要来一次即可）
  131.             if (!this.initialized) { 
  132.                 // 找到类上、接口上的@CacheConfig注解 它可以指定本类使用的cacheNames和keyGenerator和cacheManager和cacheResolver
  133.                 CacheConfig annotation = AnnotatedElementUtils.findMergedAnnotation(this.target, CacheConfig.class);
  134.                 if (annotation != null) { 
  135.                     this.cacheNames = annotation.cacheNames();
  136.                     this.keyGenerator = annotation.keyGenerator();
  137.                     this.cacheManager = annotation.cacheManager();
  138.                     this.cacheResolver = annotation.cacheResolver();
  139.                 }
  140.                 this.initialized = true;
  141.             }
  143.             // 下面方法一句话总结：方法上没有指定的话，就用类上面的CacheConfig配置
  144.             if (builder.getCacheNames().isEmpty() && this.cacheNames != null) { 
  145.                 builder.setCacheNames(this.cacheNames);
  146.             }
  147.             if (!StringUtils.hasText(builder.getKey()) && !StringUtils.hasText(builder.getKeyGenerator()) && StringUtils.hasText(this.keyGenerator)) { 
  148.                 builder.setKeyGenerator(this.keyGenerator);
  149.             }
  151.             if (StringUtils.hasText(builder.getCacheManager()) || StringUtils.hasText(builder.getCacheResolver())) { 
  152.                 // One of these is set so we should not inherit anything
  153.             } else if (StringUtils.hasText(this.cacheResolver)) { 
  154.                 builder.setCacheResolver(this.cacheResolver);
  155.             } else if (StringUtils.hasText(this.cacheManager)) { 
  156.                 builder.setCacheManager(this.cacheManager);
  157.             }
  158.         }
  159.     }
  161. }

经过这一番解析后，三大缓存注解，最终都被收集到CacheOperation里来了，这也就和CacheOperationSource缓存属性源接口的功能照应了起来。

CacheOperationInvocationContext：执行上下文

它代表缓存执行时的上下文。

  1. //@since 4.1 注意泛型O extends BasicOperation
  2. public interface CacheOperationInvocationContext<O extends BasicOperation> { 
  4.     // 缓存操作属性CacheOperation
  5.     O getOperation();
  7.     // 目标类、目标方法
  8.     Object getTarget();
  9.     Method getMethod();
  11.     // 方法入参们
  12.     Object[] getArgs();
  13. }

它只有一个CacheAspectSupport内部类实现CacheOperationContext，此处也搬上来吧：

  1. protected class CacheOperationContext implements CacheOperationInvocationContext<CacheOperation> { 
  3.     // 它里面包含了CacheOperation、Method、Class、Method targetMethod;(注意有两个Method)、AnnotatedElementKey、KeyGenerator、CacheResolver等属性
  4.     // this.method = BridgeMethodResolver.findBridgedMethod(method);
  5.     // this.targetMethod = (!Proxy.isProxyClass(targetClass) ? AopUtils.getMostSpecificMethod(method, targetClass) : this.method);
  6.     // this.methodKey = new AnnotatedElementKey(this.targetMethod, targetClass);
  7.     private final CacheOperationMetadata metadata;
  8.     private final Object[] args;
  9.     private final Object target;
  10.     private final Collection<? extends Cache> caches;
  11.     private final Collection<String> cacheNames;
  13.     @Nullable
  14.     private Boolean conditionPassing; // 标志CacheOperation.conditon是否是true：表示通过 false表示未通过
  16.     public CacheOperationContext(CacheOperationMetadata metadata, Object[] args, Object target) { 
  17.         this.metadata = metadata;
  18.         this.args = extractArgs(metadata.method, args);
  19.         this.target = target;
  20.         // 这里方法里调用了cacheResolver.resolveCaches(context)方法来得到缓存们~~~~ CacheResolver
  21.         this.caches = CacheAspectSupport.this.getCaches(this, metadata.cacheResolver);
  22.         // 从caches拿到他们的names们
  23.         this.cacheNames = createCacheNames(this.caches);
  24.     }
  25.     ... // 省略get/set
  27.     protected boolean isConditionPassing(@Nullable Object result) { 
  28.         if (this.conditionPassing == null) { 
  29.             // 如果配置了并且还没被解析过，此处就解析condition条件~~~
  30.             if (StringUtils.hasText(this.metadata.operation.getCondition())) { 
  32.                 // 执行上下文：此处就不得不提一个非常重要的它了：CacheOperationExpressionEvaluator
  33.                 // 它代表着缓存操作中SpEL的执行上下文~~~ 具体可以先参与下面的对它的介绍
  34.                 // 解析conditon~
  35.                 EvaluationContext evaluationContext = createEvaluationContext(result);
  36.                 this.conditionPassing = evaluator.condition(this.metadata.operation.getCondition(),
  37.                         this.metadata.methodKey, evaluationContext);
  38.             } else { 
  39.                 this.conditionPassing = true;
  40.             }
  41.         }
  42.         return this.conditionPassing;
  43.     }
  45.     // 解析CacheableOperation和CachePutOperation好的unless
  46.     protected boolean canPutToCache(@Nullable Object value) { 
  47.         String unless = "";
  48.         if (this.metadata.operation instanceof CacheableOperation) { 
  49.             unless = ((CacheableOperation) this.metadata.operation).getUnless();
  50.         } else if (this.metadata.operation instanceof CachePutOperation) { 
  51.             unless = ((CachePutOperation) this.metadata.operation).getUnless();
  52.         }
  53.         if (StringUtils.hasText(unless)) { 
  54.             EvaluationContext evaluationContext = createEvaluationContext(value);
  55.             return !evaluator.unless(unless, this.metadata.methodKey, evaluationContext);
  56.         }
  57.         return true;
  58.     }
  61.     // 这里注意：生成key 需要注意步骤。
  62.     // 若配置了key（非空串）：那就作为SpEL解析出来
  63.     // 否则走keyGenerator去生成~~~（所以你会发现，即使咱们没有配置key和keyGenerator，程序依旧能正常work,只是生成的key很长而已~~~）
  64.     // （keyGenerator你可以能没配置？？？？）
  65.     // 若你自己没有手动指定过KeyGenerator，那会使用默认的SimpleKeyGenerator 它的实现比较简单
  66.     // 其实若我们自定义KeyGenerator，我觉得可以继承自`SimpleKeyGenerator `，而不是直接实现接口~~~
  67.     @Nullable
  68.     protected Object generateKey(@Nullable Object result) { 
  69.         if (StringUtils.hasText(this.metadata.operation.getKey())) { 
  70.             EvaluationContext evaluationContext = createEvaluationContext(result);
  71.             return evaluator.key(this.metadata.operation.getKey(), this.metadata.methodKey, evaluationContext);
  72.         }
  73.         // key的优先级第一位，没有指定采用生成器去生成~
  74.         return this.metadata.keyGenerator.generate(this.target, this.metadata.method, this.args);
  75.     }
  77.     private EvaluationContext createEvaluationContext(@Nullable Object result) { 
  78.         return evaluator.createEvaluationContext(this.caches, this.metadata.method, this.args,
  79.                 this.target, this.metadata.targetClass, this.metadata.targetMethod, result, beanFactory);
  80.     }
  81.     ...
  82. }

CacheOperationExpressionEvaluator：缓存操作执行器

在这之前，在讲解发布订阅、事件机制的文章中：
【小家Spring】从Spring中的(ApplicationEvent)事件驱动机制出发，聊聊【观察者模式】【监听者模式】【发布订阅模式】【消息队列MQ】【EventSourcing】…
讲到过EventExpressionEvaluator，它在解析@EventListener注解的condition属性的时候被使用到，它也继承自抽象父类CachedExpressionEvaluator：
在这里插入图片描述
可见本类也是抽象父类的一个实现，是不是顿时有种熟悉感了？

  1. // @since 3.1 注意抽象父类CachedExpressionEvaluator在Spring4.2才有
  2. // CachedExpressionEvaluator里默认使用的解析器是：SpelExpressionParser 以及
  3. // 还准备了一个ParameterNameDiscoverer 可以交给执行上文CacheEvaluationContext使用
  4. class CacheOperationExpressionEvaluator extends CachedExpressionEvaluator { 
  6.     // 注意这两个属性是public的 在CacheAspectSupport里都有使用~~~
  7.     public static final Object NO_RESULT = new Object();
  8.     public static final Object RESULT_UNAVAILABLE = new Object();
  11.     public static final String RESULT_VARIABLE = "result";
  13.     private final Map<ExpressionKey, Expression> keyCache = new ConcurrentHashMap<>(64);
  14.     private final Map<ExpressionKey, Expression> conditionCache = new ConcurrentHashMap<>(64);
  15.     private final Map<ExpressionKey, Expression> unlessCache = new ConcurrentHashMap<>(64);
  17.     // 这个方法是创建执行上下文。能给解释：为何可以使用#result这个key的原因
  18.     // 此方法的入参确实不少：8个
  19.     public EvaluationContext createEvaluationContext(Collection<? extends Cache> caches,
  20.             Method method, Object[] args, Object target, Class<?> targetClass, Method targetMethod,
  21.             @Nullable Object result, @Nullable BeanFactory beanFactory) { 
  23.         // root对象，此对象的属性决定了你的#root能够取值的范围，具体下面有贴出此类~
  24.         CacheExpressionRootObject rootObject = new CacheExpressionRootObject(caches, method, args, target, targetClass);
  26.         // 它继承自MethodBasedEvaluationContext，已经讲解过了，本文就不继续深究了~
  27.         CacheEvaluationContext evaluationContext = new CacheEvaluationContext(rootObject, targetMethod, args, getParameterNameDiscoverer());
  28.         if (result == RESULT_UNAVAILABLE) { 
  29.             evaluationContext.addUnavailableVariable(RESULT_VARIABLE);
  30.         } else if (result != NO_RESULT) { 
  31.             // 这一句话就是为何我们可以使用#result的核心原因~
  32.             evaluationContext.setVariable(RESULT_VARIABLE, result);
  33.         }
  35.         // 从这里可知，缓存注解里也是可以使用容器内的Bean的~
  36.         if (beanFactory != null) { 
  37.             evaluationContext.setBeanResolver(new BeanFactoryResolver(beanFactory));
  38.         }
  39.         return evaluationContext;
  40.     }
  42.     // 都有缓存效果哦，因为都继承自抽象父类CachedExpressionEvaluator嘛
  43.     // 抽象父类@since 4.2才出来，就是给解析过程提供了缓存的效果~~~~（注意此缓存非彼缓存）
  45.     // 解析key的SpEL表达式
  46.     @Nullable
  47.     public Object key(String keyExpression, AnnotatedElementKey methodKey, EvaluationContext evalContext) { 
  48.         return getExpression(this.keyCache, methodKey, keyExpression).getValue(evalContext);
  49.     }
  51.     // condition和unless的解析结果若不是bool类型，统一按照false处理~~~~
  52.     public boolean condition(String conditionExpression, AnnotatedElementKey methodKey, EvaluationContext evalContext) { 
  53.         return (Boolean.TRUE.equals(getExpression(this.conditionCache, methodKey, conditionExpression).getValue(evalContext, Boolean.class)));
  54.     }
  55.     public boolean unless(String unlessExpression, AnnotatedElementKey methodKey, EvaluationContext evalContext) { 
  56.         return (Boolean.TRUE.equals(getExpression(this.unlessCache, methodKey, unlessExpression).getValue(evalContext, Boolean.class)));
  57.     }
  59.     /** * Clear all caches. */
  60.     void clear() { 
  61.         this.keyCache.clear();
  62.         this.conditionCache.clear();
  63.         this.unlessCache.clear();
  64.     }
  65. }
  67. // #root可取的值，参考CacheExpressionRootObject这个对象的属性
  68. // @since 3.1
  69. class CacheExpressionRootObject { 
  71.     // 可见#root.caches竟然都是阔仪的~~~
  72.     private final Collection<? extends Cache> caches;
  73.     private final Method method;
  74.     private final Object[] args;
  75.     private final Object target;
  76.     private final Class<?> targetClass;
  77.     // 省略所有的get/set（其实只有get方法）
  78. }

缓存操作的执行器，能让你深刻的理解到#root、#result的使用，并且永远忘记不了了。

CacheResolver

其名字已经暗示了其是Cache解析器，用于根据实际情况来动态解析使用哪个Cache，它是Spring4.1提供的新特性。

  1. // @since 4.1
  2. @FunctionalInterface
  3. public interface CacheResolver { 
  5.     // 根据执行上下文，拿到最终的缓存Cache集合
  6.     // CacheOperationInvocationContext：执行上下文
  7.     Collection<? extends Cache> resolveCaches(CacheOperationInvocationContext<?> context);
  9. }

它有一些内置实现如下：
在这里插入图片描述

AbstractCacheResolver

具体实现根据调用上下文提供缓存名称集合。

  1. // @since 4.1 实现了InitializingBean
  2. public abstract class AbstractCacheResolver implements CacheResolver, InitializingBean { 
  4.     // 课件它还是依赖于CacheManager的
  5.     @Nullable
  6.     private CacheManager cacheManager;
  8.     // 构造函数统一protected
  9.     protected AbstractCacheResolver() { 
  10.     }
  11.     protected AbstractCacheResolver(CacheManager cacheManager) { 
  12.         this.cacheManager = cacheManager;
  13.     }
  15.     // 设置，指定一个CacheManager
  16.     public void setCacheManager(CacheManager cacheManager) { 
  17.         this.cacheManager = cacheManager;
  18.     }
  19.     public CacheManager getCacheManager() { 
  20.         Assert.state(this.cacheManager != null, "No CacheManager set");
  21.         return this.cacheManager;
  22.     }
  25.     // 做了一步校验而已~~~CacheManager 必须存在
  26.     // 这是一个使用技巧哦 自己的在设计框架的框架的时候可以使用~
  27.     @Override
  28.     public void afterPropertiesSet()  { 
  29.         Assert.notNull(this.cacheManager, "CacheManager is required");
  30.     }
  32.     @Override
  33.     public Collection<? extends Cache> resolveCaches(CacheOperationInvocationContext<?> context) { 
  34.         // getCacheNames抽象方法，子类去实现~~~~
  35.         Collection<String> cacheNames = getCacheNames(context);
  36.         if (cacheNames == null) { 
  37.             return Collections.emptyList();
  38.         }
  41.         // 根据cacheNames 去CacheManager里面拿到Cache对象， 作为最终的返回
  42.         Collection<Cache> result = new ArrayList<>(cacheNames.size());
  43.         for (String cacheName : cacheNames) { 
  44.             Cache cache = getCacheManager().getCache(cacheName);
  45.             if (cache == null) { 
  46.                 throw new IllegalArgumentException("Cannot find cache named '" +
  47.                         cacheName + "' for " + context.getOperation());
  48.             }
  49.             result.add(cache);
  50.         }
  51.         return result;
  52.     }
  54.     // 子类需要实现此抽象方法
  55.     @Nullable
  56.     protected abstract Collection<String> getCacheNames(CacheOperationInvocationContext<?> context);
  57. }

此抽象类一样的，只是模版实现了resolveCaches()方法。抽象方法的实现交给了实现类

SimpleCacheResolver
  1. public class SimpleCacheResolver extends AbstractCacheResolver { 
  2.     ...
  3.     @Override
  4.     protected Collection<String> getCacheNames(CacheOperationInvocationContext<?> context) { 
  5.         return context.getOperation().getCacheNames();
  6.     }
  7.     ... 
  8. }

这个实现太简单了，没啥好说的。

NamedCacheResolver
  1. public class NamedCacheResolver extends AbstractCacheResolver { 
  3.     @Nullable
  4.     private Collection<String> cacheNames;
  7.     public NamedCacheResolver() { 
  8.     }
  10.     public NamedCacheResolver(CacheManager cacheManager, String... cacheNames) { 
  11.         super(cacheManager);
  12.         this.cacheNames = new ArrayList<>(Arrays.asList(cacheNames));
  13.     }
  16.     /** * Set the cache name(s) that this resolver should use. */
  17.     public void setCacheNames(Collection<String> cacheNames) { 
  18.         this.cacheNames = cacheNames;
  19.     }
  21.     @Override
  22.     protected Collection<String> getCacheNames(CacheOperationInvocationContext<?> context) { 
  23.         return this.cacheNames;
  24.     }
  26. }

此解析器的特点是，可以自己setCacheNames()。

若内建的不符合条件，我们可以自己实现一个自己的CacheResolver。比如实现和业务相关的缓存处理器（若Class==某Class，做些特殊的操作之类的）

需要注意的是：即使你配置使用的是CacheResolver，你也必须在配置里提供cacheNames至少一个的，因为毕竟是根据你配置的CacheNames去CacheManager里找（当然，若是你的自定义实现除外）

CacheOperationSourcePointcut

Pointcut小伙伴应该不陌生，在AOP章节重点又重点的描述过，我们知道Pointcut直接关乎到是否要生成代理对象，所以此类还是蛮重要的。

  1. // @since 3.1 它是个StaticMethodMatcherPointcut 所以方法入参它不关心
  2. abstract class CacheOperationSourcePointcut extends StaticMethodMatcherPointcut implements Serializable { 
  5.     // 如果你这个类就是一个CacheManager，不切入
  6.     @Override
  7.     public boolean matches(Method method, Class<?> targetClass) { 
  8.         if (CacheManager.class.isAssignableFrom(targetClass)) { 
  9.             return false;
  10.         }
  12.         // 获取到当前的缓存属性源~~~getCacheOperationSource()是个抽象方法
  13.         CacheOperationSource cas = getCacheOperationSource();
  15.         // 下面一句话解释为：如果方法/类上标注有缓存相关的注解，就切入进取~~
  16.         // 具体逻辑请参见方法：cas.getCacheOperations();
  17.         return (cas != null && !CollectionUtils.isEmpty(cas.getCacheOperations(method, targetClass)));
  18.     }
  20.     @Override
  21.     public boolean equals(Object other) { 
  22.         if (this == other) { 
  23.             return true;
  24.         }
  25.         if (!(other instanceof CacheOperationSourcePointcut)) { 
  26.             return false;
  27.         }
  28.         CacheOperationSourcePointcut otherPc = (CacheOperationSourcePointcut) other;
  29.         return ObjectUtils.nullSafeEquals(getCacheOperationSource(), otherPc.getCacheOperationSource());
  30.     }
  32.     @Override
  33.     public int hashCode() { 
  34.         return CacheOperationSourcePointcut.class.hashCode();
  35.     }
  37.     @Override
  38.     public String toString() { 
  39.         return getClass().getName() + ": " + getCacheOperationSource();
  40.     }
  43.     /** * Obtain the underlying {@link CacheOperationSource} (may be {@code null}). * To be implemented by subclasses. */
  44.     @Nullable
  45.     protected abstract CacheOperationSource getCacheOperationSource();
  47. }

CacheErrorHandler

处理缓存发生错误时的策略接口。在大多数情况下，提供者抛出的任何异常都应该简单地被抛出到客户机上，但是在某些情况下，基础结构可能需要以不同的方式处理缓存提供者异常。这个时候可以使用此接口来处理

接口内容十分之简单：

  1. public interface CacheErrorHandler { 
  2.     void handleCacheGetError(RuntimeException exception, Cache cache, Object key);
  3.     void handleCachePutError(RuntimeException exception, Cache cache, Object key, @Nullable Object value);
  4.     void handleCacheEvictError(RuntimeException exception, Cache cache, Object key);
  5.     void handleCacheClearError(RuntimeException exception, Cache cache);    
  6. }

Spring对它唯一内建实现为SimpleCacheErrorHandler，代码我不贴了，全是空实现，所以它是一个Adapter适配器形式的存在。
若你想自己提供CacheErrorHandler，你可以继承自SimpleCacheErrorHandler来弄~~~

AbstractCacheInvoker

它的作用是在进行缓存操作时发生异常时，调用组件CacheErrorHandler来进行处理~

  1. // @since 4.1
  2. public abstract class AbstractCacheInvoker { 
  3.     //protected属性~
  4.     protected SingletonSupplier<CacheErrorHandler> errorHandler;
  6.     protected AbstractCacheInvoker() { 
  7.         this.errorHandler = SingletonSupplier.of(SimpleCacheErrorHandler::new);
  8.     }
  9.     protected AbstractCacheInvoker(CacheErrorHandler errorHandler) { 
  10.         this.errorHandler = SingletonSupplier.of(errorHandler);
  11.     }
  13.     // 此处用的obtain方法 它能保证不为null
  14.     public CacheErrorHandler getErrorHandler() { 
  15.         return this.errorHandler.obtain();
  16.     }
  18.     @Nullable
  19.     protected Cache.ValueWrapper doGet(Cache cache, Object key) { 
  20.         try { 
  21.             return cache.get(key);
  22.         } catch (RuntimeException ex) { 
  23.             getErrorHandler().handleCacheGetError(ex, cache, key);
  24.             // 只有它有返回值哦 返回null
  25.             return null;  // If the exception is handled, return a cache miss
  26.         }
  27.     }
  28.     ... // 省略doPut、doEvict、doClear 处理方式同上
  29. }

可见这个类在Spring4.1提出，专门用于处理异常的，毕竟CacheErrorHandler也是Spring4.1后才有。

总结

本篇文章为讲解缓存注解的深入原理分析进行铺垫，所以密切关注这篇文章：
【小家Spring】玩转Spring Cache — @Cacheable/@CachePut/@CacheEvict注解的使用以及原理深度剖析

关注A哥






































Author A哥(YourBatman)
个人站点 www.yourbatman.cn
E-mail yourbatman@qq.com
微 信 fsx641385712
活跃平台
公众号 BAT的乌托邦（ID：BAT-utopia）
知识星球 BAT的乌托邦
每日文章推荐 每日文章推荐

BAT的乌托邦

发表评论

表情：
评论列表 （有 0 条评论，443人围观）

还没有评论，来说两句吧...

相关阅读