cache如何在Spring boot中使用

cache如何在Spring boot中使用？相信很多沒有經驗的人對此束手無策，為此本文總結了問題出現的原因和解決方法，通過這篇文章希望你能解決這個問題。

Spring 的緩存技術還具備相當的靈活性，不僅能夠使用 SpEL（Spring Expression Language）來定義緩存的 key 和各種 condition，還提供開箱即用的緩存臨時存儲方案，也支持和主流的專業緩存例如 EHCache 集成。

其特點總結如下：

1. 通過少量的配置 annotation 注釋即可使得既有代碼支持緩存
2. 支持開箱即用 Out-Of-The-Box，即不用安裝和部署額外第三方組件即可使用緩存
3. 支持 Spring Express Language，能使用對象的任何屬性或者方法來定義緩存的 key 和 condition
4. 支持 AspectJ，并通過其實現任何方法的緩存支持
5. 支持自定義 key 和自定義緩存管理者，具有相當的靈活性和擴展性

一、Spring boot cache原理

第一步、自動配置類；

自動啟動類：CacheAutoConfiguration

屬性配置：CacheProperties

主啟動類添加：@EnableCaching注解

cache POM添加：

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

第二步、從緩存的配置類 中獲取 多個cache

CacheConfigurationImportSelector.selectImports()方法獲取

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;
    }

}

獲取結果：SimpleCacheConfiguration 默認cache

 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

第三步：SimpleCacheConfiguration.cacheManager()

此方法中給容器中注冊了一個CacheManager組件：類型為ConcurrentMapCacheManager

@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);
}

第四步：查看獲取緩存方法getCache（）

ConcurrentMapCacheManager 類里，數據都存儲到為ConcurrentMap 中

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;
}

二、Cacheable運行流程：

@Cacheable： 1、方法運行之前，先去查詢Cache（緩存組件），按照cacheNames指定的名字獲取； （CacheManager先獲取相應的緩存），第一次獲取緩存如果沒有Cache組件會自動創建。 2、去Cache中查找緩存的內容(ConcurrentMapCache.lookup()方法中去查找)，使用一個key，默認就是方法的參數； key是按照某種策略生成的；默認是使用keyGenerator生成的，默認使用SimpleKeyGenerator生成key； SimpleKeyGenerator生成key的默認策略； 如果沒有參數；key=new SimpleKey()； 如果有一個參數：key=參數的值 如果有多個參數：key=new SimpleKey(params)；

 //這個方法 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);
}

3、沒有查到緩存就調用目標方法； 4、將目標方法返回的結果，放進緩存中ConcurrentMapCache.put();

@Cacheable標注的方法執行之前先來檢查緩存中有沒有這個數據，默認按照參數的值作為key去查詢緩存， 如果沒有就運行方法并將結果放入緩存；以后再來調用就可以直接使用緩存中的數據；

核心： 1）、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】組件 2）、key使用keyGenerator生成的，默認是SimpleKeyGenerator

詳細執行流程：ConcurrentMapCache.lookup()上斷點查看，執行過程

//第一步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 注解的幾個屬性：

1、cacheNames/value：指定緩存組件的名字;將方法的返回結果放在哪個緩存中，是數組的方式，可以指定 多個緩存；

2、key：緩存數據使用的key；可以用它來指定。默認是使用方法參數的值 1-方法的返回值

編寫SpEL； #i d;參數id的值 #a0 #p0 #root.args[0]

getEmp[2]

3、keyGenerator：key的生成器；可以自己指定key的生成器的組件id

key/keyGenerator：二選一使用;

4、cacheManager：指定緩存管理器；或者cacheResolver指定獲取解析器

5、condition：指定符合條件的情況下才緩存；

,condition = "#id>0"

condition = "#a0>1"：第一個參數的值》1的時候才進行緩存

6、unless:否定緩存；當unless指定的條件為true，方法的返回值就不會被緩存；可以獲取到結果進行判斷

unless = "#result == null"

unless = "#a0==2":如果第一個參數的值是2，結果不緩存；

7、sync：是否使用異步模式；異步模式的情況下unless不支持

四、Cache使用：

1.Cacheable的使用

@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;
}

2.自定義keyGenerator：

@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()+"]";
    }
  };
}

3.CachePut的使用：更新緩存

/**
   * @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;
  }

4.CacheEvict 緩存清除

/**
 * @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;
}

5.Caching 復雜配置

// @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);
}

6.CacheConfig緩存清除

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

看完上述內容，你們掌握cache如何在Spring boot中使用的方法了嗎？如果還想學到更多技能或想了解更多相關內容，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！