SpringBoot 集成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.9.3</version> <!-- 兼容 spring boot 2.3.5 的版本 -->
        </dependency>
       

import com.github.benmanes.caffeine.cache.caffeine;
import org.springframework.cache.cachemanager;
import org.springframework.cache.annotation.enablecaching;
import org.springframework.cache.caffeine.caffeinecachemanager;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import java.util.concurrent.timeunit;
@configuration
@enablecaching  
public class cacheconfig {
   /**
    caffeine 配置参数：
    expireafterwrite：写入后多久过期
    expireafteraccess：最后访问后多久过期
    maximumsize：缓存的最大元素数量
    weakkeys/weakvalues：使用弱引用，支持垃圾回收
    **/
    @bean
    public cachemanager cachemanager() {
        caffeinecachemanager cachemanager = new caffeinecachemanager();
        cachemanager.setcaffeine(caffeine.newbuilder()
                .expireafterwrite(1, timeunit.minutes)//可以选多种时间
                .maximumsize(10));//最大缓存个数
        // 配置特定缓存（超时时间5分钟，到时间自动置为null）
        cachemanager.setcachenames(java.util.arrays.aslist("timeoutparam"));
        return cachemanager;
    }
}

@bean
    public cachemanager cachemanager() {
        simplecachemanager cachemanager = new simplecachemanager();
        // 配置不同的缓存区域（可根据业务需求设置不同的超时时间）
        cachemanager.setcaches(arrays.aslist(
                new caffeinecache("timeoutparams",
                        caffeine.newbuilder()
                                .expireafterwrite(5, timeunit.minutes) // 5分钟过期
                                .maximumsize(100)
                                .build()
                ),
                new caffeinecache("longtermcache",
                        caffeine.newbuilder()
                                .expireafterwrite(1, timeunit.hours) // 1小时过期
                                .maximumsize(1000)
                                .build()
                )
        ));
        return cachemanager;
    }

import org.springframework.cache.annotation.cacheable;
import org.springframework.cache.annotation.cacheput;
import org.springframework.stereotype.service;
@service
public class myservice {
    // 获取参数（从缓存读取，若无则执行方法并缓存结果）unless：条件表达式，满足条件则不缓存（如 #result == null）
    @cacheable(value = "timeoutparams", key = "#paramname")
    public string getparam(string paramname) {
        // 模拟从数据库或其他数据源获取
        system.out.println("从数据源加载参数: " + paramname);
        return loadparamfromdb(paramname);
    }
    // 更新参数（强制刷新缓存，即使缓存存在）
    @cacheput(value = "timeoutparams", key = "#paramname")
    public string updateparam(string paramname, string newvalue) {
        // 保存到数据库
        saveparamtodb(paramname, newvalue);
        return newvalue;
    }
    // 清除缓存：调用此方法后，指定缓存键将被删除
    @cacheevict(value = "timeoutparams", key = "#paramname")
    public void clearparam(string paramname) {
        system.out.println("清除缓存: " + paramname);
        // 通常无需方法体，仅用于触发缓存清除
    }
    // 模拟数据库操作
    private string loadparamfromdb(string paramname) {
        // 实际项目中从数据库或其他数据源获取
        return "默认值";
    }
    private void saveparamtodb(string paramname, string value) {
        // 实际项目中保存到数据库
    }
}

       // 第一次调用，会从数据源加载
        string value1 = myservice.getparam("testparam");
        system.out.println("第一次获取: " + value1);
        // 第二次调用，会从缓存获取
        string value2 = myservice.getparam("testparam");
        system.out.println("第二次获取: " + value2);

@service
public class manualcacheservice {
    @autowired
    private cachemanager cachemanager;
    public void initcachemanually(string key, object value) {
        cache cache = cachemanager.getcache("paramcache");
        if (cache != null) {
            cache.put(key, value);  // 手动放入缓存
            system.out.println("手动初始化缓存: " + key + " = " + value);
        }
    }
}

@service
public class cacheaccessservice {
    @autowired
    private cachemanager cachemanager;
    public object getvaluemanually(string key) {
        cache cache = cachemanager.getcache("paramcache");
        if (cache != null) {
            cache.valuewrapper wrapper = cache.get(key);
            return wrapper != null ? wrapper.get() : null;
        }
        return null;
    }
}

@service
public class jtserviceimpl {
    @service
    public void somemethod() {
        // 自调用 - 导致缓存失效
        string token = this.getglobaltoken("token123"); 
    }
    @cacheable(value = "timeoutglobaltoken", key = "#globaltoken")
    public string getglobaltoken(string globaltoken) {
        // 实际获取token的逻辑
    }
}

// 新建专门处理缓存的服务
@service
public class tokencacheservice {
    @cacheable(value = "timeoutglobaltoken", key = "#globaltoken")
    public string getglobaltoken(string globaltoken) {
        // 实际获取token的逻辑
        return fetchtokenfromsource(globaltoken);
    }
    private string fetchtokenfromsource(string globaltoken) {
        // 从数据库/api获取token的实现
    }
}

// 原服务调用缓存服务
@service
public class jtserviceimpl {
    @autowired
    private tokencacheservice tokencacheservice;
    public void businessmethod() {
        // 跨类调用 - 触发缓存
        string token = tokencacheservice.getglobaltoken("token123");
    }
}

@getmapping("/cache/param")
public map<object, object> getcacheentries() {
    cache cache = cachemanager.getcache("paramcache");
    if (cache == null) {
        return collections.emptymap();
    }
    com.github.benmanes.caffeine.cache.cache<object, object> nativecache = 
        (com.github.benmanes.caffeine.cache.cache<object, object>) cache.getnativecache();
    return new hashmap<>(nativecache.asmap());
}