<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【默認(rèn)】
  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 類(lèi)型，獲取一個(gè)cache組件
  if (cache == null && this.dynamic) {
   synchronized (this.cacheMap) {
     cache = this.cacheMap.get(name); //cahceMap不為空獲取
     if (cache == null) {
      //可以獲取或者創(chuàng)建ConcurrentMapCache類(lèi)型的緩存組件；他的作用將數(shù)據(jù)保存在ConcurrentMap中；
      cache = createConcurrentMapCache(name);  
      this.cacheMap.put(name, cache); //ConcurrentMapCache.lookup();
     }
   }
  }
  return cache;
}

 //這個(gè)方法 SimpleKeyGenerator.generateKey()  方法生成key
public static Object generateKey(Object... params) {
  if (params.length == 0) {
   return SimpleKey.EMPTY;
  }
  if (params.length == 1) { //如果只有一個(gè)參數(shù)，直接返回這個(gè)參數(shù)為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 中根據(jù)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+"號(hào)員工");
  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：既調(diào)用方法，又更新緩存數(shù)據(jù)；同步更新緩存
   * 修改了數(shù)據(jù)庫(kù)的某個(gè)數(shù)據(jù)，同時(shí)更新緩存；
   * 運(yùn)行時(shí)機(jī)：
   * 1、先調(diào)用目標(biāo)方法
   * 2、將目標(biāo)方法的結(jié)果緩存起來(lái)
   *
   * 測(cè)試步驟：
   * 1、查詢1號(hào)員工；查到的結(jié)果會(huì)放在緩存中；
   *     key：1 value：lastName：張三
   * 2、以后查詢還是之前的結(jié)果
   * 3、更新1號(hào)員工；【lastName:zhangsan；gender:0】
   *     將方法的返回值也放進(jìn)緩存了；
   *     key：傳入的employee對(duì)象 值：返回的employee對(duì)象；
   * 4、查詢1號(hào)員工？
   *   應(yīng)該是更新后的員工；
   *     key = "#employee.id":使用傳入的參數(shù)的員工id；
   *     key = "#result.id"：使用返回后的id
   *       @Cacheable的key是不能用#result
   *   為什么是沒(méi)更新前的？【1號(hào)員工沒(méi)有在緩存中更新】
   *
   */
  @CachePut(value = "emp",key = "#result.id")
  public Employee updateEmp(Employee employee){
    System.out.println("updateEmp:"+employee);
    employeeMapper.updateEmp(employee);
    return employee;
  }

/**
 * @CacheEvict：緩存清除
 * key：指定要清除的數(shù)據(jù)
 * allEntries = true：指定清除這個(gè)緩存中所有的數(shù)據(jù)
 * beforeInvocation = false：緩存的清除是否在方法之前執(zhí)行
 *   默認(rèn)代表緩存清除操作是在方法執(zhí)行之后執(zhí)行;如果出現(xiàn)異常緩存就不會(huì)清除
 *
 * beforeInvocation = true：
 *   代表清除緩存操作是在方法運(yùn)行之前執(zhí)行，無(wú)論方法是否出現(xiàn)異常，緩存都清除
 *
 *
 */
@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 定義復(fù)雜的緩存規(guī)則
@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 {