Spring Boot 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();
}