Springboot 本地缓存

第一步：添加maven依赖

      <!-- Spring Boot Cache Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

        <!-- 可选：Caffeine 缓存实现 2.8.1兼容springboot 2.2.5-->
        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>2.8.1</version>
        </dependency>

第二步：启用缓存功能

@EnableCaching
@SpringBootApplication
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

第三步：配置 application.yml

cache:
  caffeine:
    # 每个 cacheName 的独立配置
    configs:
      tokenClientCache:
        maxSize: 1000
        expireMinutes: 5
      userCache:
        maxSize: 500
        expireMinutes: 30
      appDataCache:
        maxSize: 200
        expireMinutes: 60
    # 默认配置（当 cacheName 没有单独配置时使用）
    default:
      maxSize: 100
      expireMinutes: 10

第四步：创建配置类用于映射 YAML 数据

import org.springframework.boot.context.properties.ConfigurationProperties;
import java.util.Map;

@ConfigurationProperties(prefix = "cache.caffeine")
public class CaffeineCacheProperties {

    private Map<String, CacheConfig> configs;
    private CacheConfig defaults = new CacheConfig();

    // Getter and Setter

    public static class CacheConfig {
        private long maxSize = 100;
        private int expireMinutes = 10;

        public long getMaxSize() {
            return maxSize;
        }

        public void setMaxSize(long maxSize) {
            this.maxSize = maxSize;
        }

        public int getExpireMinutes() {
            return expireMinutes;
        }

        public void setExpireMinutes(int expireMinutes) {
            this.expireMinutes = expireMinutes;
        }
    }

    public Map<String, CacheConfig> getConfigs() {
        return configs;
    }

    public void setConfigs(Map<String, CacheConfig> configs) {
        this.configs = configs;
    }

    public CacheConfig getDefault() {
        return defaults;
    }

    public void setDefault(CacheConfig defaults) {
        this.defaults = defaults;
    }
}

第五步：注册配置类到 Spring 容器

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class PropertiesConfig {

    @Bean
    public CaffeineCacheProperties caffeineCacheProperties() {
        return new CaffeineCacheProperties();
    }
}

第六步：自定义 CaffeineCacheManager

import org.springframework.cache.Cache;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import com.github.benmanes.caffeine.cache.Caffeine;
import java.util.concurrent.TimeUnit;

public class PerCacheNameCaffeineCacheManager extends CaffeineCacheManager {

    private final CaffeineCacheProperties caffeineCacheProperties;

    public PerCacheNameCaffeineCacheManager(CaffeineCacheProperties caffeineCacheProperties) {
        this.caffeineCacheProperties = caffeineCacheProperties;
    }

    @Override
    protected Cache createCaffeineCache(String name) {
        CaffeineCacheProperties.CacheConfig config = caffeineCacheProperties.getConfigs() != null ?
                caffeineCacheProperties.getConfigs().get(name) : null;

        if (config == null) {
            config = caffeineCacheProperties.getDefault();
        }

        // 创建 Caffeine 的 Cache 实例
        com.github.benmanes.caffeine.cache.Cache<Object, Object> nativeCaffeineCache =
                Caffeine.newBuilder()
                        .maximumSize(config.getMaxSize())
                        .expireAfterWrite(config.getExpireMinutes(), TimeUnit.MINUTES)
                        .build();

        // 使用 Spring 的 CaffeineCache 包装它，以满足 Spring Cache 接口
        return new CaffeineCache(name, nativeCaffeineCache);
    }
}

 第七步：在主配置中注册自定义 CacheManager

import com.hieasy.pos.common.config.cache.CaffeineCacheProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class PropertiesConfig {

    @Bean
    public CaffeineCacheProperties caffeineCacheProperties() {
        return new CaffeineCacheProperties();
    }




}

第八步：编写工具类

import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.stereotype.Component;

@Component
public class MineCacheUtil {

    private final CacheManager cacheManager;

    public MineCacheUtil(CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }

    /**
     * 获取缓存中的值
     */
    public <T> T get(String cacheName, Object key, Class<T> type) {
        Cache cache = cacheManager.getCache(cacheName);
        if (cache != null) {
            Cache.ValueWrapper wrapper = cache.get(key);
            if (wrapper != null) {
                return type.cast(wrapper.get());
            }
        }
        return null;
    }

    /**
     * 设置缓存值
     */
    public void put(String cacheName, Object key, Object value) {
        Cache cache = cacheManager.getCache(cacheName);
        if (cache != null) {
            cache.put(key, value);
        }
    }

    /**
     * 删除缓存
     */
    public void evict(String cacheName, Object key) {
        Cache cache = cacheManager.getCache(cacheName);
        if (cache != null) {
            cache.evict(key);
        }
    }

    /**
     * 清空整个缓存
     */
    public void clear(String cacheName) {
        Cache cache = cacheManager.getCache(cacheName);
        if (cache != null) {
            cache.clear();
        }
    }
}

第九步：使用

   @Autowired protected MineCacheUtil cacheUtil;           

    public Integer _getClientByToken(String token) {
        Integer client = cacheUtil.get(CACHE_NAME_CLIENT, token, Integer.class);
        if (client == null) {
            // 模拟从 Redis 或其他地方获取
            client = _loadClientFromRedis(token);
            cacheUtil.put(CACHE_NAME_CLIENT, token, client);
        }else{
            log.info("从缓存读取token:{},client:{}",token,client);
        }
        return client;
    }
    private Integer _loadClientFromRedis(String token) {
        // 这里模拟远程调用，实际可能是 Redis、DB 等
        JSONObject jo=  redisService.getCacheObject(Constants.ACCESS_TOKEN + token);
        String clientStr = jo.getString("client");
        log.info("从redis读取token:{},client:{}",token,clientStr);
        return _str2Int(clientStr);
    }

springboot 监控中心可以看到缓存已存在