深入理解SpringCache框架

本文是缓存系列第三篇，前两篇分别介绍了 Guava 和 JetCache。

成都创新互联长期为近千家客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为醴陵企业提供专业的做网站、网站设计，醴陵网站改版等技术服务。拥有10余年丰富建站经验和众多成功案例,为您定制开发。

前两篇我们讲了 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： https://github.com/zhuzhenke/common-caches

注意点：

1、开启 EnableCaching 注解，默认没有开启 Cache。

2、配置 CacheManager。

@Bean
@Qualifier("concurrentMapCacheManager")
@Primary
ConcurrentMapCacheManager 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 parseCacheAnnotations(DefaultCacheConfig cachingConfig, AnnotatedElement ae) {
 Collection ops = null;

 Collection cacheables = AnnotatedElementUtils.getAllMergedAnnotations(ae, Cacheable.class);
 if (!cacheables.isEmpty()) {
 ops = lazyInit(ops);
 for (Cacheable cacheable : cacheables) {
  ops.add(parseCacheableAnnotation(ae, cachingConfig, cacheable));
 }
 }
 Collection evicts = AnnotatedElementUtils.getAllMergedAnnotations(ae, CacheEvict.class);
 if (!evicts.isEmpty()) {
 ops = lazyInit(ops);
 for (CacheEvict evict : evicts) {
  ops.add(parseEvictAnnotation(ae, cachingConfig, evict));
 }
 }
 Collection puts = AnnotatedElementUtils.getAllMergedAnnotations(ae, CachePut.class);
 if (!puts.isEmpty()) {
 ops = lazyInit(ops);
 for (CachePut put : puts) {
  ops.add(parsePutAnnotation(ae, cachingConfig, put));
 }
 }
 Collection cachings = AnnotatedElementUtils.getAllMergedAnnotations(ae, Caching.class);
 if (!cachings.isEmpty()) {
 ops = lazyInit(ops);
 for (Caching caching : cachings) {
  Collection 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 parseCachingAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, Caching caching) {
 Collection 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 getCacheOperations(Method method, Class<?> targetClass) {
 if (method.getDeclaringClass() == Object.class) {
 return null;
 }

 Object cacheKey = getCacheKey(method, targetClass);
 Collection cached = this.attributeCache.get(cacheKey);

 if (cached != null) {
 return (cached != NULL_CACHING_ATTRIBUTE ? cached : null);
 }
 else {
 Collection 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> attributeCache = new ConcurrentHashMap>(1024); 属性上，为后续拦截方法时处理缓存做好数据的准备。

注解产生作用

当访问 categoryService.get(category) 方法时，会走到 CglibAopProxy.intercept() 方法，这也说明缓存注解是基于动态代理实现，通过方法的拦截来动态设置或失效缓存。方法中会通过 List