首页 > 编程语言 > Spring Boot Cache使用方法整合代码实例
2020
09-23

Spring Boot Cache使用方法整合代码实例

参考:

Spring Cache扩展功能实现

项目地址

使用本地Caffeine缓存

引入依赖包

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
  <groupId>com.github.ben-manes.caffeine</groupId>
  <artifactId>caffeine</artifactId>
  <version>2.6.2</version>
</dependency>

自定义Caffeine配置

CachingConfig.java

package com.vcredit.vmp.checkcenter.config;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.vcredit.vmp.checkcenter.common.properties.CaffeineCacheProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import java.time.Duration;
import java.util.*;
/**
 * 缓存配置
 * @author kancy
 */
@Configuration
@EnableCaching
public class CachingConfig {

  @Autowired
  CaffeineCacheProperties caffeineCacheProperties;

  /**
   * 创建基于Caffeine的Cache Manager
   * @return
   */
  @Bean
  @Primary
  @ConditionalOnProperty(prefix = "system.cache.caffeine" , name = "enabled", havingValue = "true")
  public CacheManager caffeineCacheManager() {
    SimpleCacheManager cacheManager = new SimpleCacheManager();
    Map<String, CaffeineCache> cacheMap = new HashMap();

    // 设置全局配置的本地缓存
    List<String> globalCacheNames = caffeineCacheProperties.getCacheName();
    if(globalCacheNames !=null && !globalCacheNames.isEmpty()){
      addCacheObject(cacheMap, globalCacheNames, caffeineCacheProperties.getExpireAfterWrite(),
          caffeineCacheProperties.getExpireAfterAccess(), caffeineCacheProperties.getMaximumSize());
    }

    // 设置自定义属性缓存, 可以覆盖全局缓存
    List<CaffeineCacheProperties.Config> configs = caffeineCacheProperties.getConfigs();
    if(configs != null && !configs.isEmpty()){
      for (CaffeineCacheProperties.Config config : configs) {
        List<String> cacheNames = config.getCacheName();
        if (cacheNames == null || cacheNames.isEmpty()){
          continue;
        }
        Duration expireAfterWrite = Optional.ofNullable(config.getExpireAfterWrite()).orElse(caffeineCacheProperties.getExpireAfterWrite());
        Duration expireAfterAccess = Optional.ofNullable(config.getExpireAfterAccess()).orElse(caffeineCacheProperties.getExpireAfterAccess());
        Long maximumSize = Optional.ofNullable(config.getMaximumSize()).orElse(caffeineCacheProperties.getMaximumSize());
        addCacheObject(cacheMap, cacheNames, expireAfterWrite, expireAfterAccess, maximumSize);
      }
    }
    // 加入到缓存管理器进行管理
    cacheManager.setCaches(cacheMap.values());
    return cacheManager;
  }

  private void addCacheObject(Map<String, CaffeineCache> cacheMap, List<String> cacheNames, Duration expireAfterWrite, Duration expireAfterAccess, Long maximumSize) {
    for (String cacheName : cacheNames) {
      // spring.cache.caffeine: maximumSize=500,expireAfterAccess=10s,expireAfterWrite=15s
      Caffeine<Object, Object> recordStats = Caffeine.newBuilder().recordStats().maximumSize(maximumSize);
      if(expireAfterAccess != null) recordStats.expireAfterAccess(expireAfterAccess);
      if(expireAfterWrite != null) recordStats.expireAfterWrite(expireAfterWrite);
      Cache<Object, Object> cache = recordStats.build();
      CaffeineCache caffeineCache = new CaffeineCache(cacheName,cache);

      // 覆盖添加
      cacheMap.put(cacheName, caffeineCache);
    }
  }
}

CaffeineCacheProperties.java

package com.vcredit.vmp.checkcenter.common.properties;
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import java.time.Duration;
import java.util.List;
/**
 * Caffeine本地缓存自定义配置
 * @author kancy
 */
@Getter
@Setter
@Configuration
@ConfigurationProperties("system.cache.caffeine")
@ConditionalOnProperty(prefix = "system.cache.caffeine" , name = "enabled", havingValue = "true")
public class CaffeineCacheProperties {
  private List<String> cacheName;
  private Duration expireAfterWrite;
  private Duration expireAfterAccess;
  private Long maximumSize = Long.valueOf(-1);
  private List<Config> configs;
  @Getter
  @Setter
  public static class Config {
    private List<String> cacheName;
    Duration expireAfterWrite;
    Duration expireAfterAccess;
    Long maximumSize;
  }
}

application.yml

system.cache.caffeine:
 enabled: true
 # 全局配置
 cacheName: cache1,cache2,cache3
 expireAfterWrite: 60s
 expireAfterAccess: 30s
 maximumSize: 500
 # 自定义配置,cacheName相同可覆盖全局
 configs:
 - cacheName: checkApplyCache
  expireAfterAccess: 10s
 - cacheName: userQueryCache
  expireAfterAccess: 15s

使用缓存

@Cacheable(value = { "checkApplyCache" }, key="#req.md5")
public Result check(CheckReq req) {
  // your code...
  return Result.ok();
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持自学编程网。

编程技巧