SpringBoot 集成Caffeine实现一级缓存及常遇到场景

更新时间：2025年06月25日 10:28:46 作者：寅灯

文章讲解了SpringBoot集成Caffeine实现一级缓存的方法,包括配置依赖、设置多缓存超时、业务与控制层调用方式,以及注解获取数据,重点指出自调用导致注解失效问题,并提供拆分Service的解决方案,强调Caffeine性能优于GuavaCache,感兴趣的朋友跟随小编一起看看吧

SpeingBoot 集成Caffeine实现一级缓存使我们经常遇到的场景。今天我们具体分享一下：

首先 Caffeine 作为一级缓存，它是 Spring 5.x 默认的本地缓存实现，性能优于 Guava Cache，且支持过期时间设置。缓存执行的流程图如下：

1、pom文件引入包

         <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>

2、换成配置类

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;
    }
}

1）配置多个缓存

@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;
    }

不同缓存数据的超时时间可能不一样，因此需要设置不同的缓存。

3、业务层实现

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) {
        // 实际项目中保存到数据库
    }
}

4、控制层调用

       // 第一次调用，会从数据源加载
        String value1 = myService.getParam("testParam");
        System.out.println("第一次获取: " + value1);
        // 第二次调用，会从缓存获取
        String value2 = myService.getParam("testParam");
        System.out.println("第二次获取: " + value2);

5、通过key获取数据

1)通过key手动插入

@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);
        }
    }
}

2）手动获取

@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;
    }
}

6、通过注解获取数据（注意伪代码）

@Service
public class JTServiceImpl {
    @Service
    public void someMethod() {
        // 自调用 - 导致缓存失效
        String token = this.getGlobalToken("token123"); 
    }
    @Cacheable(value = "timeoutGlobalToken", key = "#globalToken")
    public String getGlobalToken(String globalToken) {
        // 实际获取token的逻辑
    }
}

注意：注解失效原因及解决方案

原因分析：

Spring AOP 工作原理：
- Spring 的缓存功能（包括 @Cacheable）是基于 AOP 代理实现的
- 当调用 @Cacheable 方法时，实际调用的是代理对象的方法，不是原始对象的方法
自调用问题（Self-Invocation）：
- 当同一个类中的方法 A 直接调用方法 B（带 @Cacheable 注解）时
- 调用发生在原始对象内部，绕过了 Spring 代理
- 导致 @Cacheable 注解完全失效

解决方案：将缓存方法移到另一个Service中

// 新建专门处理缓存的服务
@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");
    }
}

这是一个比较常用的解决方案。

8、获取所有缓存信息

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

到此，SpringBoot 集成Caffeine实现一级缓存分享完成，下篇我们会继续分享此种缓存实现的细节，敬请期待！

到此这篇关于SpringBoot 集成Caffeine实现一级缓存的文章就介绍到这了,更多相关SpringBoot Caffeine一级缓存内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

如何准确判断邮件地址是否存在
本文介绍了如何判断邮件地址是否存在的方法，具有很高的使用价值，提高了工作效率
2015-07-07
解决mybatis-plus自动配置的mapper.xml与java接口映射问题
这篇文章主要介绍了解决mybatis-plus自动配置的mapper.xml与java接口映射问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-08-08
spring boot使用自定义注解做AOP的案例代码
这篇文章主要介绍了spring boot使用自定义注解做AOP的案例代码,代码简单易懂,通过创建一个自定注解,接收一个传值type,感兴趣的朋友一起看看吧
2024-06-06
通过代码示例了解submit与execute的区别
这篇文章主要介绍了通过代码示例了解submit与execute的区别,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-09-09
Java的Spring框架中DAO数据访问对象的使用示例
这篇文章主要介绍了Java的Spring框架中DAO数据访问对象的使用示例,分为在Spring中DOA与JDBC以及与Hibernate的配合使用两种情况来进行演示,需要的朋友可以参考下
2016-03-03
Netty分布式获取异线程释放对象源码剖析
这篇文章主要为大家介绍了Netty分布式获取异线程释放的对象源码剖析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步早日升职加薪
2022-03-03
java Hibernate 一对多自身关联问题
formBean在提交表单的时候，域中数据库在下一次中仍然保留引起的，struts formBean 默认的scope为session，手动设置为request，就好了
2008-07-07
SpringBoot结合Ajax实现登录页面实例
大家好，本篇文章主要讲的是SpringBoot结合Ajax实现登录页面实例，感兴趣的同学赶快来看一看，对你有帮助的话记得收藏一下
2022-02-02
并发编程之Java内存模型volatile的内存语义
这篇文章主要介绍了并发编程之Java内存模型volatile的内存语义，理解volatile特性的一个好办法是把对volatile变量的单个读/写，看成是使用同一个锁对单个读/写操作做了同步。下面我们一起进入文章看看具体例子吧,需要的小伙伴可以参考下
2021-11-11
Java自定义异常与异常使用的最佳方式
这篇文章主要介绍了Java自定义异常与异常使用的最佳方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-08-08

SpringBoot 集成Caffeine实现一级缓存及常遇到场景

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具