浅谈Spring boot cache使用和原理

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

static class CacheConfigurationImportSelector implements ImportSelector {
​
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
      CacheType[] types = CacheType.values();
      String[] imports = new String[types.length];
      for (int i = 0; i < types.length; i++) {
        imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
      }
      return imports;
    }
​
}

 org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
  org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
  org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
  org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
  org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
  org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
  org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
  org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
  org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration
  org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration【默认】
  org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration

@Bean
public ConcurrentMapCacheManager cacheManager() {
  ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
  List<String> cacheNames = this.cacheProperties.getCacheNames();
  if (!cacheNames.isEmpty()) {
   cacheManager.setCacheNames(cacheNames);
  }
  return this.customizerInvoker.customize(cacheManager);
}

public Cache getCache(String name) {
  Cache cache = this.cacheMap.get(name); //cacheMap 为ConcurrentMap 类型，获取一个cache组件
  if (cache == null && this.dynamic) {
   synchronized (this.cacheMap) {
     cache = this.cacheMap.get(name); //cahceMap不为空获取
     if (cache == null) {
      //可以获取或者创建ConcurrentMapCache类型的缓存组件；他的作用将数据保存在ConcurrentMap中；
      cache = createConcurrentMapCache(name);  
      this.cacheMap.put(name, cache); //ConcurrentMapCache.lookup();
     }
   }
  }
  return cache;
}

 //这个方法 SimpleKeyGenerator.generateKey()  方法生成key
public static Object generateKey(Object... params) {
  if (params.length == 0) {
   return SimpleKey.EMPTY;
  }
  if (params.length == 1) { //如果只有一个参数，直接返回这个参数为key
   Object param = params[0];
   if (param != null && !param.getClass().isArray()) {
     return param;
   }
  }
  return new SimpleKey(params);
}

//第一步CacheAspectSupport 中execute（）
private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts) 
//第二步 CacheAspectSupport
private Cache.ValueWrapper findCachedItem(Collection<CacheOperationContext> contexts) {
  Object result = CacheOperationExpressionEvaluator.NO_RESULT;
  for (CacheOperationContext context : contexts) {
    if (isConditionPassing(context, result)) {
      Object key = generateKey(context, result); //获取key
      Cache.ValueWrapper cached = findInCaches(context, key);
      if (cached != null) {
        return cached;
      }
      else {
        if (logger.isTraceEnabled()) {
          logger.trace("No cache entry for key '" + key + "' in cache(s) " + context.getCacheNames());
        }
      }
    }
  }
  return null;
}
//第三步：CacheAspectSupport.findInCaches()
//第四步：AbstractCacheInvoker.doGet()
//第五步：AbstractValueAdaptingCache.get();
@Override
public ValueWrapper get(Object key) {
    Object value = lookup(key);
    return toValueWrapper(value);
}
// 第六步：ConcurrentMapCache.lookup(); 从ConcurrentMap 中根据key获取值
@Override
protected Object lookup(Object key) {
    return this.store.get(key);
}

@Cacheable(value = {"emp"}/*,keyGenerator = "myKeyGenerator",condition = "#a0>1",unless = "#a0==2"*/)
public Employee getEmp(Integer id){
  System.out.println("查询"+id+"号员工");
  Employee emp = employeeMapper.getEmpById(id);
  return emp;
}

@Bean("myKeyGenerator")
public KeyGenerator keyGenerator(){
  return new KeyGenerator(){
​
    @Override
    public Object generate(Object target, Method method, Object... params) {
      return method.getName()+"["+ Arrays.asList(params).toString()+"]";
    }
  };
}

/**
   * @CachePut：既调用方法，又更新缓存数据；同步更新缓存
   * 修改了数据库的某个数据，同时更新缓存；
   * 运行时机：
   * 1、先调用目标方法
   * 2、将目标方法的结果缓存起来
   *
   * 测试步骤：
   * 1、查询1号员工；查到的结果会放在缓存中；
   *     key：1 value：lastName：张三
   * 2、以后查询还是之前的结果
   * 3、更新1号员工；【lastName:zhangsan；gender:0】
   *     将方法的返回值也放进缓存了；
   *     key：传入的employee对象 值：返回的employee对象；
   * 4、查询1号员工？
   *   应该是更新后的员工；
   *     key = "#employee.id":使用传入的参数的员工id；
   *     key = "#result.id"：使用返回后的id
   *       @Cacheable的key是不能用#result
   *   为什么是没更新前的？【1号员工没有在缓存中更新】
   *
   */
  @CachePut(value = "emp",key = "#result.id")
  public Employee updateEmp(Employee employee){
    System.out.println("updateEmp:"+employee);
    employeeMapper.updateEmp(employee);
    return employee;
  }

/**
 * @CacheEvict：缓存清除
 * key：指定要清除的数据
 * allEntries = true：指定清除这个缓存中所有的数据
 * beforeInvocation = false：缓存的清除是否在方法之前执行
 *   默认代表缓存清除操作是在方法执行之后执行;如果出现异常缓存就不会清除
 *
 * beforeInvocation = true：
 *   代表清除缓存操作是在方法运行之前执行，无论方法是否出现异常，缓存都清除
 *
 *
 */
@CacheEvict(value="emp",beforeInvocation = true，key = "#id")
public void deleteEmp(Integer id){
  System.out.println("deleteEmp:"+id);
  //employeeMapper.deleteEmpById(id);
  int i = 10/0;
}

// @Caching 定义复杂的缓存规则
@Caching(
   cacheable = {
     @Cacheable(/*value="emp",*/key = "#lastName")
   },
   put = {
     @CachePut(/*value="emp",*/key = "#result.id"),
     @CachePut(/*value="emp",*/key = "#result.email")
   }
)
public Employee getEmpByLastName(String lastName){
  return employeeMapper.getEmpByLastName(lastName);
}

@CacheConfig(cacheNames="emp",cacheManager = "employeeCacheManager") //抽取缓存的公共配置
@Service
public class EmployeeService {