<think>我们正在讨论
Spring Boot中同时集成
Caffeine和Redis
缓存的问题。根据引用内容，我们可以确认这是可行的，并且通常用于构建两级
缓存（本地
缓存+分布式
缓存）系统。
引用[1]提到“
Spring Boot 使用多级
缓存 {
Caffeine+Redis}”，并给出了快速入门的示例。
引用[2]解释了在分布式环境下
使用Redis的发布/订阅功能来同步各个节点的
缓存，解决一致性问题。
引用[3]则展示了具体的配置代码，其中通过条件
注解@ConditionalOnProperty来控制本地
缓存（
Caffeine）的开关。
因此，我们可以分步骤解释如何在
Spring Boot中同时集成
Caffeine和Redis：
步骤1：添加Maven依赖
需要同时添加
spring-
boot-starter-cache（用于支持
Spring缓存抽象）、
spring-
boot-starter-data-redis（用于Redis）和
caffeine（用于本地
缓存）的依赖。
步骤2：配置
缓存
在application.properties或application.yml中配置Redis和
Caffeine的相关属性。
步骤3：启用
缓存
在启动类上添加@EnableCaching
注解。
步骤4：配置多级
缓存
如引用[3]所示，可以创建配置类来定义Redis
缓存和
Caffeine缓存，并且通过条件
注解来控制
Caffeine缓存的启用。
步骤5：
使用缓存
在业务代码中，可以
使用@
Cacheable等
注解来
使用缓存。同时，为了支持多级
缓存，可能需要自定义
缓存管理器，将
Caffeine作为一级
缓存，Redis作为二级
缓存。
引用[2]提到，为了解决分布式环境下本地
缓存不一致的问题，可以
使用Redis的发布/订阅功能来同步各个节点的
缓存。
下面是一个简化的示例代码，展示如何配置多级
缓存：
```java
@Configuration
@EnableCaching
public class CacheConfig {
// 配置Redis连接工厂
@Bean
public RedisConnectionFactory redisConnectionFactory
() {
return new LettuceConnectionFactory
();
}
// 配置RedisTemplate
@Bean
public RedisTemplate<String, Object> redisTemplate
() {
RedisTemplate<String, Object> template = new RedisTemplate<>
();
template.setConnectionFactory
(redisConnectionFactory
());
template.setKeySerializer
(new StringRedisSerializer
());
template.setValueSerializer
(new GenericJackson2JsonRedisSerializer
());
return template;
}
// 配置Redis
缓存管理器
@Bean
public RedisCacheManager redisCacheManager
(RedisTemplate<String, Object> redisTemplate
) {
RedisCacheManager cacheManager = new RedisCacheManager
(redisTemplate
);
cacheManager.setTransactionAware
(true
);
cacheManager.setLoadRemoteCachesOnStartup
(true
);
cacheManager.setUsePrefix
(true
);
return cacheManager;
}
// 配置
Caffeine缓存管理器
@Bean
public
CaffeineCacheManager
caffeineCacheManager
() {
CaffeineCacheManager cacheManager = new
CaffeineCacheManager
();
cacheManager.set
Caffeine(Caffeine.newBuilder
()
.expireAfterWrite
(10, TimeUnit.MINUTES
)
.maximumSize
(1000
));
return cacheManager;
}
// 配置多级
缓存管理器（组合
Caffeine和Redis）
@Primary
@Bean
public CacheManager multiLevelCacheManager
(CaffeineCacheManager
caffeineCacheManager, RedisCacheManager redisCacheManager
) {
// 这里需要自定义一个组合
缓存管理器，可以
使用已有的开源实现或者自己实现
// 通常，读取时先读本地
缓存，再读Redis；写入时同时写入两级
缓存
// 注意：需要处理
缓存同步和一致性问题
return new MultiLevelCacheManager
(caffeineCacheManager, redisCacheManager
);
}
}
```
注意：上述代码中的MultiLevelCacheManager需要自定义实现，它负责协调两级
缓存。同时，为了保持
缓存一致性，当数据更新时，需要使所有节点的一级
缓存失效，这可以通过Redis的发布/订阅机制实现（如引用[2]所述）。
另外，引用[3]中提到了
使用条件
注解来控制本地
缓存的开关，我们可以这样实现：
```java
@Configuration
@ConditionalOnProperty
(name = "cache.local.enabled", havingValue = "true"
)
public class LocalCacheConfig {
// 配置本地
缓存相关的Bean
}
```
这样，通过配置文件中的`cache.local.enabled`属性，可以动态开启或关闭本地
缓存。
综上所述，
Spring Boot可以同时集成
Caffeine和Redis，构建多级
缓存系统，并通过配置灵活控制。
生成相关问题：
1. 如何自定义多级
缓存管理器（MultiLevelCacheManager）？
2. 如何利用Redis的发布/订阅实现
缓存同步？
3. 在
Spring Boot中配置多级
缓存时，需要注意哪些问题？</think>在
Spring Boot 项目中，**可以同时集成
Caffeine 和 Redis
缓存**，形成多级
缓存架构（本地
缓存 + 分布式
缓存）。这种组合能显著提升系统性能，同时解决分布式环境下的
缓存一致性问题。以下是关键实现方案：
---
### **一、实现原理**
1. **两级
缓存架构**
- **一级
缓存（本地）**：
使用 Caffeine 提供超高速访问（纳秒级响应），适合高频访问的热点数据。
- **二级
缓存（分布式）**：
使用 Redis 保证多节点间数据一致性，作为后备存储。
```mermaid
graph LR
A[应用] --> B[
Caffeine 本地
缓存]
B -->|
缓存未命中| C[Redis 分布式
缓存]
C -->|
缓存未命中| D[数据库]
```
2. **
缓存同步机制**
- 通过 Redis 的 **发布/订阅（Pub/Sub）** 功能同步各节点的本地
缓存（如引用[2]所述）。
- 当某节点修改数据时，发布消息使其他节点失效本地
缓存。
---
### **二、集成步骤**
#### 1. **添加 Maven 依赖**
```xml
<!--
Caffeine -->
<dependency>
<groupId>com.github.ben-manes.
caffeine</groupId>
<artifactId>
caffeine</artifactId>
</dependency>
<!-- Redis -->
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-data-redis</artifactId>
</dependency>
```
#### 2. **启用
缓存（启动类）**
```java
@
SpringBootApplication
@EnableCaching // 开启
缓存抽象
public class Application {
public static void main
(String[] args
) {
SpringApplication.run
(Application.class, args
);
}
}
```
#### 3. **配置多级
缓存管理器**
```java
@Configuration
public class CacheConfig {
@Bean
public CacheManager cacheManager
(RedisConnectionFactory factory
) {
//
Caffeine 作为一级
缓存（本地）
CaffeineCacheManager
caffeineCacheManager = new
CaffeineCacheManager
();
caffeineCacheManager.set
Caffeine(Caffeine.newBuilder
()
.expireAfterWrite
(10, TimeUnit.MINUTES
) // 本地
缓存过期时间
.maximumSize
(1000
)
);
// Redis 作为二级
缓存（分布式）
RedisCacheManager redisCacheManager = RedisCacheManager.create
(factory
);
// 组合多级
缓存（优先本地，其次Redis）
return new MultiLevelCacheManager
(caffeineCacheManager, redisCacheManager
);
}
}
```
#### 4. **实现
缓存同步（关键）**
通过 Redis 发布/订阅同步本地
缓存失效（如引用[2]）：
```java
@Bean
public RedisMessageListenerContainer container
(RedisConnectionFactory factory
) {
RedisMessageListenerContainer container = new RedisMessageListenerContainer
();
container.setConnectionFactory
(factory
);
container.addMessageListener
(new MessageListenerAdapter
(this
), new ChannelTopic
("cache-invalidate"
));
return container;
}
// 收到消息时失效本地
缓存
public void handleMessage
(String cacheKey
) {
caffeineCacheManager.getCache
(cacheKey
).clear
();
}
```
#### 5. **动态开关本地
缓存（如引用[3]）**
```java
@Configuration
@ConditionalOnProperty
( // 通过配置控制开关
name = "cache.local.enabled",
havingValue = "true",
matchIfMissing = false
)
public class LocalCacheConfig {
@Bean
public
CaffeineCacheManager
caffeineCacheManager
() {
// 本地
缓存配置
}
}
```
配置文件 `application.yml`：
```yaml
cache:
local:
enabled: true # 动态启用/禁用
Caffeine
```
---
### **
三、
使用缓存示例**
```java
@Service
public class UserService {
@
Cacheable(value = "users", key = "#id"
) // 自动
使用多级
缓存
public User getUserById
(Long id
) {
return userRepository.findById
(id
); // 数据库查询
}
@
CacheEvict(value = "users", key = "#id"
)
public void updateUser
(User user
) {
// 更新数据后发布
缓存失效消息
redisTemplate.convertAndSend
("cache-invalidate", "users:" + user.getId
());
}
}
```
---
### **四、优势与适用场景**
| **优势** | **适用场景** |
|-------------------------|----------------------------------|
| **高性能**：
Caffeine 本地
缓存响应极快 | 高频读取的热点数据（如商品详情） |
| **一致性**：Redis 保证多节点同步 | 分布式集群环境 |
| **灵活性**：动态开关本地
缓存 | 测试环境降级、流量高峰控制 |
> **注意**：需权衡本地
缓存带来的内存消耗，建议通过 `maximumSize` 限制
缓存条目（如引用[3]）。
---
### **相关问题**
1. 如何解决
Caffeine 和 Redis 之间的数据一致性问题？
2. 在多级
缓存架构中，如何设计
缓存穿透和雪崩的保护机制？
3. 如何监控
Spring Boot 中
Caffeine 和 Redis 的
缓存命中率？
[^1]:
Spring Boot 使用多级
缓存 {
Caffeine+Redis}，快速入门示例
[^2]: 基于 Redis 发布/订阅实现分布式
缓存同步
[^3]: 通过 `@ConditionalOnProperty` 动态控制本地
缓存开关
本文介绍了Spring Boot中使用Caffeine缓存的注解方式，包括@Cacheable、@CacheEvict、@CachePut的使用场景和区别，并提供了简单的代码示例。此外，还提到了@Caching用于组合多个缓存操作和@CacheConfig在类级别设置缓存配置。
最低0.47元/天 解锁文章
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
