spring boot集成Caffeine

       SpringBoot 有两种方式集成 Caffeine ：

• 方式一：直接引入 Caffeine 依赖，然后使用 Caffeine 方法实现缓存。
• 方式二：引入 Caffeine 和 Spring Cache 依赖，使用 SpringCache 注解方法实现缓存。

 方式一：

     1、引入相关依赖

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

      2、缓存配置类

@Configuration
public class CacheConfig {
    @Bean
    public Cache<String, Object> caffeineCache() {
        return Caffeine.newBuilder()
                // 设置最后一次写入或访问后两个小时后过期
                .expireAfterWrite(7200, TimeUnit.SECONDS)
                // 初始的缓存空间大小
                .initialCapacity(100)
                // 缓存的最大条数
                .maximumSize(1000)
                .build();
    }
}

      3、数据存取

// 1. 注入
@Resource
private Cache<String, Object> caffeineCache;
// 2. 存储数据
caffeineCache.put("access_token", token);
// 3. 读取数据
String token = (String) caffeineCache.asMap().get("access_token");

 方式二（SpringCache + 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.8.8</version>
        </dependency>

     如果出现Caffeine，CaffeineCacheManager将会自动配置。使用spring.cache.cache-names属性可以在启动时创建缓存，并可以通过以下配置进行自定义（按顺序）：

• spring.cache.caffeine.spec： 定义的特殊缓存
• com.github.benmanes.caffeine.cache.CaffeineSpec： bean定义
• com.github.benmanes.caffeine.cache.Caffeine： bean定义

　　配置创建一个foo和bar缓存，最大数量为500，存活时间为10分钟：

spring.cache.cache-names=foo,bar
spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s

　　如果定义com.github.benmanes.caffeine.cache.CacheLoader，它会自动关联到CaffeineCacheManager。由于该CacheLoader将关联被该缓存管理器管理的所有缓存，所以它必须定义为CacheLoader<Object, Object>，自动配置将忽略所有泛型类型。

　　使用@EnableCaching注解让Spring Boot开启对缓存的支持

@EnableCaching
@SpringBootApplication
public class BootCaffeineApplication {

    public static void main(String[] args) {
        SpringApplication.run(BootCaffeineApplication.class, args);
    }

}

　　配置文件：新增对缓存的特殊配置，如最大容量、过期时间等

spring.cache.cache-names=people
spring.cache.caffeine.spec=initialCapacity=50,maximumSize=500,expireAfterWrite=10s,refreshAfterWrite=5s

　　另一种配置

@Bean(name = "caffeine")
    public CacheManager cacheManagerWithCaffeine(CacheLoader cacheLoader) {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        Caffeine caffeine = Caffeine.newBuilder()
                //cache的初始容量值
                .initialCapacity(100)
                //maximumSize用来控制cache的最大缓存数量，maximumSize和maximumWeight(最大权重)不可以同时使用，
                .maximumSize(1000)
                //最后一次写入或者访问后过久过期
                .expireAfterAccess(500, TimeUnit.SECONDS)
                //创建或更新之后多久刷新,需要设置cacheLoader
                .refreshAfterWrite(10, TimeUnit.SECONDS);
        cacheManager.setCaffeine(caffeine);
        cacheManager.setCacheLoader(cacheLoader);
        cacheManager.setCacheNames(Arrays.asList("people"));
        //是否允许值为空
        cacheManager.setAllowNullValues(false);
        return cacheManager;
    }

      如果使用refreshAfterWrite配置还必须指定一个CacheLoader，如：

/**
 * 必须要指定这个Bean，refreshAfterWrite=5s这个配置属性才生效
 *
 * @return
 */
@Bean
public CacheLoader<Object, Object> cacheLoader() {

    CacheLoader<Object, Object> cacheLoader = new CacheLoader<Object, Object>() {

        @Override
        public Object load(Object key) throws Exception {
            return null;
        }
    };

    return cacheLoader;
}

　　配置说明

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

expireAfterWrite和expireAfterAccess同事存在时，以expireAfterWrite为准。
maximumSize和maximumWeight不可以同时使用
weakValues和softValues不可以同时使用

　　示例代码

 @Autowired
    private PeopleRepository peopleRepository;


    @CachePut(value = "people", key = "#people.peopleId")
    public void save(People people) {
        peopleRepository.save(people);
    }

    /**
     * Cacheable
     * value：缓存key的前缀。
     * key：缓存key的后缀。
     * sync：设置如果缓存过期是不是只放一个请求去请求数据库，其他请求阻塞，默认是false。
     */
    @Cacheable(value = "people", key = "#peopleId", sync = true)
    public People findById(Integer peopleId) {
        People p = peopleRepository.findById(peopleId);
        return p;
    }

    @CacheEvict(value = "people", key = "#peopleId")
    public void remove(Integer peopleId) {
        log.info("删除了id、key为" + peopleId + "的数据缓存");
    }