Springboot整合缓存组件

spring-boot-cache支持如下缓存

Generic、JCache (JSR-107)、EhCache 2.x、Hazelcast、Infinispan、Redis、Guava、Simple

	org.springframework.boot
	spring-boot-starter-cache

• @EnableCaching 用于缓存配置类或者启动类上

spring.cache.type指定缓存组件，详细的见下面的

spring:
  cache:
    type: XXX  ## 设置缓存类型为caffeine

• @CacheConfig 单个缓存管理配置，添加在需要缓存类上
  • cacheNames或value 指定缓存名称
  • cacheManager 指定的缓存换利器
  • cacheResolver 指定的缓存解析器
• @Cacheable 用于查询方法上，表示缓存查询的结果
  • key= “#root.methodName” 指定缓存key的表达式，一般采用spEL表达式
  • condition = “#id>2” 缓存的条件，例如id>2
  • unless = “#a0==null” 不缓存的条件，例如第一个参数为null
  • keyGenerator 指定缓存的key生成器
  • sync 默认为false,实际调用方法获取数据时是否要保持同步
• @CachePut 用于更新方法上，表示更新缓存
  • key = “#student.id”
  • condition 满足条件时更新缓存,支持SpEL表达式
  • unless 满足条件时不更新缓存，支持spEL表达式
• @CacheEvict 用于删除方法上，表示删除缓存
  • key = “#id” 指定缓存的key
  • allEntries = true 默认为false,是否要清除所有缓存数据
  • value或cacheNames 指定缓存名称
  • condition 满足条件时删除缓存,支持SpEL表达式
  • beforeInvocation 默认为false，调用方法之前或之后清除缓存
• @Caching 用在一个方法上多种注解
  • cacheable 对应的是@Cacheable
  • put 对应的是配置@CachePut
  • evict 对应的是@CacheEvict

@CacheConfig(cacheNames = "student")
public class StudentService {
    
    //表示将sno作为key,添加key
	@Cacheable(key= "#root.methodName",condition = "#id>2"，unless = "#a0==null")
	public Student queryStudentBySno(Integer id){
	    //添加缓存
	}
	
    //#p0.sno表示将student的sno作为key，更新key
	@CachePut(key = "#student.id")
	public Student update(Student student){
	    //更新缓存
	}
	
    //将sno作为key,移除缓存中的key
	@CacheEvict(key = "#id", allEntries = true)
	public void deleteStudentBySno(Integer id){
	    //删除缓存
	}
}

    com.github.ben-manes.caffeine
    caffeine
    2.6.0

• maximumWeight=[long]: 缓存的最大权重
• expireAfterAccess=[duration]: 最后一次写入或访问后经过固定时间过期
• expireAfterWrite=[duration]: 最后一次写入后经过固定时间过期
• refreshAfterWrite=[duration]: 创建缓存或者最近一次更新缓存后经过固定的时间间隔，刷新缓存
• weakKeys: 打开key的弱引用
• softValues：打开value的软引用
• recordStats：开发统计功能
• initialCapacity=[integer]: 初始的缓存空间大小

spring:
  cache:
    type: caffeine  ## 设置缓存类型为caffeine
    cache-names:
    - getPersonById  # 指定缓存名称
    - name2
    caffeine:
      spec: maximumSize=500,expireAfterWrite=5s   # 缓存配置

@Getter
@NoArgsConstructor
@AllArgsConstructor
public enum Caches{
    getPersonById(5), //有效期5秒
    getSomething, //缺省10秒
    getOtherthing(300, 1000), //5分钟，最大容量1000
    ;
    //缺省情况
    private int maxSize=50000;    //最大數量
    private int ttl=10;        //过期时间（秒）

    Caches(int ttl) {
        this.ttl = ttl;
    }
}

@Configuration
@EnableCaching
public class CacheConfig {

    public static final int DEFAULT_MAXSIZE = 50000;
    public static final int DEFAULT_TTL = 10;

    @Bean
    @Primary
    public CacheManager caffeineCacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        ArrayList caches = new ArrayList();
        //从缓存枚举中获取到所有情况的缓存
        for(Caches c : Caches.values()){
            caches.add(new CaffeineCache(c.name(), 
                Caffeine.newBuilder().recordStats()
                .expireAfterWrite(c.getTtl(), TimeUnit.SECONDS)
                .maximumSize(c.getMaxSize())
                .build())
            );
        }
        cacheManager.setCaches(caches);
        return cacheManager;
    }
    
    @Bean
    public CacheLoader cacheLoader() {
        CacheLoader cacheLoader = new CacheLoader() {
            @Override
            public Object load(Object key) throws Exception {
                return null;
            }
            // 重写这个方法将oldValue值返回回去，进而刷新缓存
            @Override
            public Object reload(Object key, Object oldValue) throws Exception {
                return oldValue;
            }
        };
        return cacheLoader;
    }
}   

//缓存加载器
LoadingCache loadingCache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build(key -> createExpensiveGraph(key));
//查询数据先查询缓存
private Object createExpensiveGraph(String key) {
    Object graph = null;
    //先查询缓存是否存在，这里也可以做成函数式编程
    graph = manualCache.getIfPresent(key);
    if(null != graph){
        return  graph;
    }
    return personService.findOne1();
}
//关于Caffine缓存的增删改查使用
public Object testManual(Person person) {
    String key = "name1";
    Object graph = null;
    // 根据key查询一个缓存，如果没有返回NULL
    graph = manualCache.getIfPresent(key);
    // 根据Key查询一个缓存，如果没有调用createExpensiveGraph方法，并将返回值保存到缓存。
    // 如果该方法返回Null则manualCache.get返回null，如果该方法抛出异常则manualCache.get抛出异常
    graph = manualCache.get(key, k -> createExpensiveGraph(k));
    // 将一个值放入缓存，如果以前有值就覆盖以前的值
    manualCache.put(key, graph);
    // 删除一个缓存
    manualCache.invalidate(key);
    ConcurrentMap map = manualCache.asMap();
    System.out.println(map.toString());
    return graph;
}
//异步缓存
AsyncLoadingCache asyncLoadingCache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .buildAsync(key -> createExpensiveGraph(key));

private CompletableFuture