玩转Spring Cache --- @Cacheable/@CachePut/@CacheEvict缓存注解相关基础类打点【享学Spring】（中）-阿里云开发者社区

CompositeCacheOperationSource

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

public class CompositeCacheOperationSource implements CacheOperationSource, Serializable {
  // 这里用的数组，表面只能赋值一次  并且只能通过构造函数赋值
  private final CacheOperationSource[] cacheOperationSources;
  public CompositeCacheOperationSource(CacheOperationSource... cacheOperationSources) {
    this.cacheOperationSources = cacheOperationSources;
  }
  public final CacheOperationSource[] getCacheOperationSources() {
    return this.cacheOperationSources;
  }
  @Override
  @Nullable
  public Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass) {
    Collection<CacheOperation> ops = null;
    for (CacheOperationSource source : this.cacheOperationSources) {
      Collection<CacheOperation> cacheOperations = source.getCacheOperations(method, targetClass);
      if (cacheOperations != null) {
        if (ops == null) {
          ops = new ArrayList<>();
        }
        ops.addAll(cacheOperations);
      }
    }
    return ops;
  }
}

对它的解释就是，所以组合进取的属性源，最终都会叠加生效。

注意：它还是个抽象类哦~~~它的唯一实现如下（匿名内部类）：

public class BeanFactoryCacheOperationSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor {
  @Nullable
  private CacheOperationSource cacheOperationSource;
  private final CacheOperationSourcePointcut pointcut = new CacheOperationSourcePointcut() {
    @Override
    @Nullable
    protected CacheOperationSource getCacheOperationSource() {
      return cacheOperationSource;
    }
  };
  ...
}

`CacheAnnotationParser`：缓存注解解析器

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

// @since 3.1
public interface CacheAnnotationParser {
  @Nullable
  Collection<CacheOperation> parseCacheAnnotations(Class<?> type);
  @Nullable
  Collection<CacheOperation> parseCacheAnnotations(Method method);
}

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

// @since 3.1
public class SpringCacheAnnotationParser implements CacheAnnotationParser, Serializable {
  private static final Set<Class<? extends Annotation>> CACHE_OPERATION_ANNOTATIONS = new LinkedHashSet<>(8);
  // 它能处理的注解类型，一目了然
  static {
    CACHE_OPERATION_ANNOTATIONS.add(Cacheable.class);
    CACHE_OPERATION_ANNOTATIONS.add(CacheEvict.class);
    CACHE_OPERATION_ANNOTATIONS.add(CachePut.class);
    CACHE_OPERATION_ANNOTATIONS.add(Caching.class);
  }
  // 处理class和Method
  // 使用DefaultCacheConfig，把它传给parseCacheAnnotations()  来给注解属性搞定默认值
  // 至于为何自己要新new一个呢？？？其实是因为@CacheConfig它只能放在类上呀~~~（传Method也能获取到类）
  // 返回值都可以为null（没有标注此注解方法、类  那肯定返回null啊）
  @Override
  @Nullable
  public Collection<CacheOperation> parseCacheAnnotations(Class<?> type) {
    DefaultCacheConfig defaultConfig = new DefaultCacheConfig(type);
    return parseCacheAnnotations(defaultConfig, type);
  }
  @Override
  @Nullable
  public Collection<CacheOperation> parseCacheAnnotations(Method method) {
    DefaultCacheConfig defaultConfig = new DefaultCacheConfig(method.getDeclaringClass());
    return parseCacheAnnotations(defaultConfig, method);
  }
  // 找到方法/类上的注解们~~~
  private Collection<CacheOperation> parseCacheAnnotations(DefaultCacheConfig cachingConfig, AnnotatedElement ae) {
    // 第三个参数传的false：表示接口的注解它也会看一下~~~
    Collection<CacheOperation> ops = parseCacheAnnotations(cachingConfig, ae, false);
    // 若出现接口方法里也标了，实例方法里也标了，那就继续处理。让以实例方法里标注的为准~~~
    if (ops != null && ops.size() > 1) {
      // More than one operation found -> local declarations override interface-declared ones...
      Collection<CacheOperation> localOps = parseCacheAnnotations(cachingConfig, ae, true);
      if (localOps != null) {
        return localOps;
      }
    }
    return ops;
  }
  private Collection<CacheOperation> parseCacheAnnotations(DefaultCacheConfig cachingConfig, AnnotatedElement ae, boolean localOnly) {
    // localOnly=true，只看自己的不看接口的。false表示接口的也得看~
    Collection<? extends Annotation> anns = (localOnly ? AnnotatedElementUtils.getAllMergedAnnotations(ae, CACHE_OPERATION_ANNOTATIONS) : AnnotatedElementUtils.findAllMergedAnnotations(ae, CACHE_OPERATION_ANNOTATIONS));
    if (anns.isEmpty()) {
      return null;
    }
    // 这里为和写个1？？？因为绝大多数情况下，我们都只会标注一个注解~~
    final Collection<CacheOperation> ops = new ArrayList<>(1);
    // 这里的方法parseCacheableAnnotation/parsePutAnnotation等 说白了  就是把注解属性，转换封装成为`CacheOperation`对象~~
    // 注意parseCachingAnnotation方法，相当于~把注解属性转换成了CacheOperation对象  下面以它为例介绍
    anns.stream().filter(ann -> ann instanceof Cacheable).forEach(
        ann -> ops.add(parseCacheableAnnotation(ae, cachingConfig, (Cacheable) ann)));
    anns.stream().filter(ann -> ann instanceof CacheEvict).forEach(
        ann -> ops.add(parseEvictAnnotation(ae, cachingConfig, (CacheEvict) ann)));
    anns.stream().filter(ann -> ann instanceof CachePut).forEach(
        ann -> ops.add(parsePutAnnotation(ae, cachingConfig, (CachePut) ann)));
    anns.stream().filter(ann -> ann instanceof Caching).forEach(
        ann -> parseCachingAnnotation(ae, cachingConfig, (Caching) ann, ops));
    return ops;
  }
  // CacheableOperation是抽象类CacheOperation的子类~
  private CacheableOperation parseCacheableAnnotation(
      AnnotatedElement ae, DefaultCacheConfig defaultConfig, Cacheable cacheable) {
    // 这个builder是CacheOperation.Builder的子类，父类规定了所有注解通用的一些属性~~~
    CacheableOperation.Builder builder = new CacheableOperation.Builder();
    builder.setName(ae.toString());
    builder.setCacheNames(cacheable.cacheNames());
    builder.setCondition(cacheable.condition());
    builder.setUnless(cacheable.unless());
    builder.setKey(cacheable.key());
    builder.setKeyGenerator(cacheable.keyGenerator());
    builder.setCacheManager(cacheable.cacheManager());
    builder.setCacheResolver(cacheable.cacheResolver());
    builder.setSync(cacheable.sync());
    // DefaultCacheConfig是本类的一个内部类，来处理buider，给他赋值默认值~~~  比如默认的keyGenerator等等
    defaultConfig.applyDefault(builder);
    CacheableOperation op = builder.build();
    validateCacheOperation(ae, op); // 校验。key和KeyGenerator至少得有一个   CacheManager和CacheResolver至少得配置一个
    return op;
  }
  ... // 解析其余注解略，一样的。
  // 它其实就是把三三者聚合了，一个一个的遍历。所以它最后一个参数传的ops，在内部进行add
  private void parseCachingAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, Caching caching, Collection<CacheOperation> ops) {
    Cacheable[] cacheables = caching.cacheable();
    for (Cacheable cacheable : cacheables) {
      ops.add(parseCacheableAnnotation(ae, defaultConfig, cacheable));
    }
    CacheEvict[] cacheEvicts = caching.evict();
    for (CacheEvict cacheEvict : cacheEvicts) {
      ops.add(parseEvictAnnotation(ae, defaultConfig, cacheEvict));
    }
    CachePut[] cachePuts = caching.put();
    for (CachePut cachePut : cachePuts) {
      ops.add(parsePutAnnotation(ae, defaultConfig, cachePut));
    }
  }
  // 设置默认值的私有静态内部类
  private static class DefaultCacheConfig {
    private final Class<?> target;
    @Nullable
    private String[] cacheNames;
    @Nullable
    private String keyGenerator;
    @Nullable
    private String cacheManager;
    @Nullable
    private String cacheResolver;
    private boolean initialized = false;
    // 唯一构造函数~
    public DefaultCacheConfig(Class<?> target) {
      this.target = target;
    }
    public void applyDefault(CacheOperation.Builder builder) {
      // 如果还没初始化过，就进行初始化（毕竟一个类上有多个方法，这种默认通用设置只需要来一次即可）
      if (!this.initialized) {
        // 找到类上、接口上的@CacheConfig注解  它可以指定本类使用的cacheNames和keyGenerator和cacheManager和cacheResolver
        CacheConfig annotation = AnnotatedElementUtils.findMergedAnnotation(this.target, CacheConfig.class);
        if (annotation != null) {
          this.cacheNames = annotation.cacheNames();
          this.keyGenerator = annotation.keyGenerator();
          this.cacheManager = annotation.cacheManager();
          this.cacheResolver = annotation.cacheResolver();
        }
        this.initialized = true;
      }
      // 下面方法一句话总结：方法上没有指定的话，就用类上面的CacheConfig配置
      if (builder.getCacheNames().isEmpty() && this.cacheNames != null) {
        builder.setCacheNames(this.cacheNames);
      }
      if (!StringUtils.hasText(builder.getKey()) && !StringUtils.hasText(builder.getKeyGenerator()) && StringUtils.hasText(this.keyGenerator)) {
        builder.setKeyGenerator(this.keyGenerator);
      }
      if (StringUtils.hasText(builder.getCacheManager()) || StringUtils.hasText(builder.getCacheResolver())) {
        // One of these is set so we should not inherit anything
      } else if (StringUtils.hasText(this.cacheResolver)) {
        builder.setCacheResolver(this.cacheResolver);
      } else if (StringUtils.hasText(this.cacheManager)) {
        builder.setCacheManager(this.cacheManager);
      }
    }
  }
}

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

CacheOperationInvocationContext：执行上下文

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

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

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

protected class CacheOperationContext implements CacheOperationInvocationContext<CacheOperation> {
  // 它里面包含了CacheOperation、Method、Class、Method targetMethod;(注意有两个Method)、AnnotatedElementKey、KeyGenerator、CacheResolver等属性
  // this.method = BridgeMethodResolver.findBridgedMethod(method);
  // this.targetMethod = (!Proxy.isProxyClass(targetClass) ? AopUtils.getMostSpecificMethod(method, targetClass)  : this.method);
  // this.methodKey = new AnnotatedElementKey(this.targetMethod, targetClass);
    private final CacheOperationMetadata metadata;
    private final Object[] args;
    private final Object target;
    private final Collection<? extends Cache> caches;
    private final Collection<String> cacheNames;
    @Nullable
    private Boolean conditionPassing; // 标志CacheOperation.conditon是否是true：表示通过  false表示未通过
    public CacheOperationContext(CacheOperationMetadata metadata, Object[] args, Object target) {
        this.metadata = metadata;
        this.args = extractArgs(metadata.method, args);
        this.target = target;
        // 这里方法里调用了cacheResolver.resolveCaches(context)方法来得到缓存们~~~~  CacheResolver
        this.caches = CacheAspectSupport.this.getCaches(this, metadata.cacheResolver);
        // 从caches拿到他们的names们
        this.cacheNames = createCacheNames(this.caches);
    }
  ... // 省略get/set
    protected boolean isConditionPassing(@Nullable Object result) {
        if (this.conditionPassing == null) {
      // 如果配置了并且还没被解析过，此处就解析condition条件~~~
            if (StringUtils.hasText(this.metadata.operation.getCondition())) {
        // 执行上下文：此处就不得不提一个非常重要的它了：CacheOperationExpressionEvaluator
        // 它代表着缓存操作中SpEL的执行上下文~~~  具体可以先参与下面的对它的介绍
        // 解析conditon~
                EvaluationContext evaluationContext = createEvaluationContext(result);
                this.conditionPassing = evaluator.condition(this.metadata.operation.getCondition(),
                        this.metadata.methodKey, evaluationContext);
            } else {
                this.conditionPassing = true;
            }
        }
        return this.conditionPassing;
    }
  // 解析CacheableOperation和CachePutOperation好的unless
    protected boolean canPutToCache(@Nullable Object value) {
        String unless = "";
        if (this.metadata.operation instanceof CacheableOperation) {
            unless = ((CacheableOperation) this.metadata.operation).getUnless();
        } else if (this.metadata.operation instanceof CachePutOperation) {
            unless = ((CachePutOperation) this.metadata.operation).getUnless();
        }
        if (StringUtils.hasText(unless)) {
            EvaluationContext evaluationContext = createEvaluationContext(value);
            return !evaluator.unless(unless, this.metadata.methodKey, evaluationContext);
        }
        return true;
    }
  // 这里注意：生成key  需要注意步骤。
  // 若配置了key（非空串）：那就作为SpEL解析出来
  // 否则走keyGenerator去生成~~~（所以你会发现，即使咱们没有配置key和keyGenerator，程序依旧能正常work,只是生成的key很长而已~~~）
  // （keyGenerator你可以能没配置？？？？）
  // 若你自己没有手动指定过KeyGenerator，那会使用默认的SimpleKeyGenerator 它的实现比较简单
  // 其实若我们自定义KeyGenerator，我觉得可以继承自`SimpleKeyGenerator `，而不是直接实现接口~~~
    @Nullable
    protected Object generateKey(@Nullable Object result) {
        if (StringUtils.hasText(this.metadata.operation.getKey())) {
            EvaluationContext evaluationContext = createEvaluationContext(result);
            return evaluator.key(this.metadata.operation.getKey(), this.metadata.methodKey, evaluationContext);
        }
        // key的优先级第一位，没有指定采用生成器去生成~
        return this.metadata.keyGenerator.generate(this.target, this.metadata.method, this.args);
    }
    private EvaluationContext createEvaluationContext(@Nullable Object result) {
        return evaluator.createEvaluationContext(this.caches, this.metadata.method, this.args,
                this.target, this.metadata.targetClass, this.metadata.targetMethod, result, beanFactory);
    }
  ...
}

CacheOperationExpressionEvaluator：缓存操作执行器

在这之前，在讲解发布订阅、事件机制的文章中：

【小家Spring】从Spring中的(ApplicationEvent)事件驱动机制出发，聊聊【观察者模式】【监听者模式】【发布订阅模式】【消息队列MQ】【EventSourcing】…

讲到过EventExpressionEvaluator，它在解析@EventListener注解的condition属性的时候被使用到，它也继承自抽象父类CachedExpressionEvaluator：

可见本类也是抽象父类的一个实现，是不是顿时有种熟悉感了？

// @since 3.1   注意抽象父类CachedExpressionEvaluator在Spring4.2才有
// CachedExpressionEvaluator里默认使用的解析器是：SpelExpressionParser  以及
// 还准备了一个ParameterNameDiscoverer  可以交给执行上文CacheEvaluationContext使用
class CacheOperationExpressionEvaluator extends CachedExpressionEvaluator {
  // 注意这两个属性是public的  在CacheAspectSupport里都有使用~~~
  public static final Object NO_RESULT = new Object();
  public static final Object RESULT_UNAVAILABLE = new Object();
  public static final String RESULT_VARIABLE = "result";
  private final Map<ExpressionKey, Expression> keyCache = new ConcurrentHashMap<>(64);
  private final Map<ExpressionKey, Expression> conditionCache = new ConcurrentHashMap<>(64);
  private final Map<ExpressionKey, Expression> unlessCache = new ConcurrentHashMap<>(64);
  // 这个方法是创建执行上下文。能给解释：为何可以使用#result这个key的原因
  // 此方法的入参确实不少：8个
  public EvaluationContext createEvaluationContext(Collection<? extends Cache> caches,
      Method method, Object[] args, Object target, Class<?> targetClass, Method targetMethod,
      @Nullable Object result, @Nullable BeanFactory beanFactory) {
    // root对象，此对象的属性决定了你的#root能够取值的范围，具体下面有贴出此类~
    CacheExpressionRootObject rootObject = new CacheExpressionRootObject(caches, method, args, target, targetClass);
    // 它继承自MethodBasedEvaluationContext，已经讲解过了，本文就不继续深究了~
    CacheEvaluationContext evaluationContext = new CacheEvaluationContext(rootObject, targetMethod, args, getParameterNameDiscoverer());
    if (result == RESULT_UNAVAILABLE) {
      evaluationContext.addUnavailableVariable(RESULT_VARIABLE);
    } else if (result != NO_RESULT) {
      // 这一句话就是为何我们可以使用#result的核心原因~
      evaluationContext.setVariable(RESULT_VARIABLE, result);
    }
    // 从这里可知，缓存注解里也是可以使用容器内的Bean的~
    if (beanFactory != null) {
      evaluationContext.setBeanResolver(new BeanFactoryResolver(beanFactory));
    }
    return evaluationContext;
  }
  // 都有缓存效果哦，因为都继承自抽象父类CachedExpressionEvaluator嘛
  // 抽象父类@since 4.2才出来，就是给解析过程提供了缓存的效果~~~~（注意此缓存非彼缓存）
  // 解析key的SpEL表达式
  @Nullable
  public Object key(String keyExpression, AnnotatedElementKey methodKey, EvaluationContext evalContext) {
    return getExpression(this.keyCache, methodKey, keyExpression).getValue(evalContext);
  }
  // condition和unless的解析结果若不是bool类型，统一按照false处理~~~~
  public boolean condition(String conditionExpression, AnnotatedElementKey methodKey, EvaluationContext evalContext) {
    return (Boolean.TRUE.equals(getExpression(this.conditionCache, methodKey, conditionExpression).getValue(evalContext, Boolean.class)));
  }
  public boolean unless(String unlessExpression, AnnotatedElementKey methodKey, EvaluationContext evalContext) {
    return (Boolean.TRUE.equals(getExpression(this.unlessCache, methodKey, unlessExpression).getValue(evalContext, Boolean.class)));
  }
  /**
   * Clear all caches.
   */
  void clear() {
    this.keyCache.clear();
    this.conditionCache.clear();
    this.unlessCache.clear();
  }
}
// #root可取的值，参考CacheExpressionRootObject这个对象的属性
// @since 3.1
class CacheExpressionRootObject {
  // 可见#root.caches竟然都是阔仪的~~~
  private final Collection<? extends Cache> caches;
  private final Method method;
  private final Object[] args;
  private final Object target;
  private final Class<?> targetClass;
  // 省略所有的get/set（其实只有get方法）
}

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

CacheResolver

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

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

它有一些内置实现如下：

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

CompositeCacheOperationSource

`CacheAnnotationParser`：缓存注解解析器

CacheOperationInvocationContext：执行上下文

CacheOperationExpressionEvaluator：缓存操作执行器

CacheResolver

热门文章

最新文章

相关课程

相关电子书

相关实验场景

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

CompositeCacheOperationSource

CacheAnnotationParser：缓存注解解析器

CacheOperationInvocationContext：执行上下文

CacheOperationExpressionEvaluator：缓存操作执行器

CacheResolver

热门文章

最新文章

相关课程

相关电子书

相关实验场景

`CacheAnnotationParser`：缓存注解解析器