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一级缓存内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java实现文件变化监听代码实例
这篇文章主要介绍了Java实现文件变化监听代码实例,通过定时任务,轮训查询文件的最后修改时间,与上一次进行对比,如果发生变化,则说明文件已经修改,进行重新加载或对应的业务逻辑处理,需要的朋友可以参考下
2024-01-01
java当中的定时器的4种使用方式
这篇文章主要介绍了java当中的定时器的4种使用方式，有需要的朋友可以参考一下
2013-12-12
java中double强制转换int引发的OOM问题记录
这篇文章主要介绍了java中double强制转换int引发的OOM问题记录,本文给大家分享问题排查过程,感兴趣的朋友跟随小编一起看看吧
2024-10-10
如何通过maven最快搭建Springboot项目
因为Springboot项目的启动依赖是通过pom.xml文件实现的,所以我们直接创建项目后,调整pom.xml即可快速开发,这篇文章给大家介绍如何通过maven最快搭建Springboot项目,感兴趣的朋友一起看看吧
2025-05-05
Java中的Semaphore信号量详解
这篇文章主要介绍了Java中的Semaphore信号量详解,Semaphore（信号量）是用来控制同时访问特定资源的线程数量,通过协调各个线程以保证合理地使用公共资源,需要的朋友可以参考下
2023-12-12
Spring注解@Profile实现开发环境/测试环境/生产环境的切换
在进行软件开发过程中，一般会将项目分为开发环境，测试环境，生产环境。本文主要介绍了Spring如何通过注解@Profile实现开发环境、测试环境、生产环境的切换，需要的可以参考一下
2023-04-04
很简单的Java断点续传实现原理
这篇文章主要以实例的方式为大家详细介绍了简单的Java断点续传实现原理，感兴趣的小伙伴们可以参考一下
2016-07-07
Spring ComponentScan的扫描过程解析
这篇文章主要介绍了spring ComponentScan的扫描过程解析，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
2022-03-03
泛谈Java中的不可变数据结构
开发人员通常认为拥有final引用，或者val在Kotlin或Scala中，足以使对象不可变。这篇博客文章深入研究了不可变引用和不可变数据结构，下面小编来和大家一起学习它
2019-05-05
Java中CyclicBarrier和CountDownLatch的用法与区别
CyclicBarrier和CountDownLatch这两个工具都是在java.util.concurrent包下，并且平时很多场景都会使用到。本文将会对两者进行分析，记录他们的用法和区别，感兴趣的可以了解一下
2021-08-08

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

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具