使用 Caffeine 和 Redis 实现高效的二级缓存架构
创作时间:
作者:
@小白创作中心
使用 Caffeine 和 Redis 实现高效的二级缓存架构
引用
CSDN
1.
https://m.blog.csdn.net/zhangkunls/article/details/144187863
在现代应用开发中，缓存是提升系统性能的关键手段。为了兼顾本地缓存的高性能和分布式缓存的扩展能力，常见的实现方式是结合使用 Caffeine 和 Redis 实现二级缓存架构。本文将详细介绍如何通过 Spring Boot 实现一个 Caffeine + Redis 二级缓存，并通过合理的架构设计和代码实现，确保缓存的一致性、性能和容错性。
需求与挑战
- 多级缓存的需求
- 一级缓存（Caffeine）：快速响应，存储本地热点数据，减少对远程缓存和数据库的访问。
- 二级缓存（Redis）：共享缓存数据，支持分布式扩展。
- 常见问题
- 数据一致性：一级缓存和二级缓存之间的数据如何保持同步？
- 容错性：Redis 不可用时如何保证系统稳定运行？
- 缓存穿透：如何避免大量无效请求穿透缓存直接访问数据库？
- 高并发：如何避免缓存击穿导致数据库压力激增？
缓存设计与解决方案
缓存查询流程
按照 Cache-Aside 模式，缓存查询流程如下：
- 查询一级缓存（Caffeine）：
- 如果命中，则直接返回结果。
- 查询二级缓存（Redis）：
- 如果 Redis 有数据，则回填到一级缓存，并返回结果。
- 如果 Redis 查询失败（Redis 不可用），直接跳过。
- 查询数据源（数据库等）：
- 如果 Redis 也未命中，则从数据源获取数据，同时回填到一级和二级缓存中。
缓存更新流程
- 数据更新或写入时，同时更新一级和二级缓存。
- 如果 Redis 写入失败，仅更新一级缓存，确保数据可用性。
代码实现
缓存接口设计
定义一个通用的缓存接口，便于不同实现类的扩展和切换：
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.function.Supplier;
public interface CacheService {
<T> T get(String key, Class<T> type, Supplier<T> dataLoader); // 获取单个键的数据
void put(String key, Object value); // 存储单个键的数据
void evict(String key); // 删除单个键
boolean exists(String key); // 检查键是否存在
Map<String, Object> getAll(Set<String> keys); // 批量获取多个键的数据
Object getHash(String key, String hashKey); // 获取哈希表中单个字段的值
void putHash(String key, String hashKey, Object value); // 存储哈希表中的字段
void evictAll(Collection<String> keys); // 批量删除多个键
}
Caffeine + Redis 实现
使用 Caffeine 和 Redis 的结合实现二级缓存：
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
@Service
public class OptimizedCacheService implements CacheService {
private final Cache<String, Object> caffeineCache;
private final RedisTemplate<String, Object> redisTemplate;
public OptimizedCacheService(RedisTemplate<String, Object> redisTemplate) {
this.caffeineCache = Caffeine.newBuilder()
.initialCapacity(100)
.maximumSize(1000)
.expireAfterWrite(10, TimeUnit.MINUTES)
.build();
this.redisTemplate = redisTemplate;
}
@Override
public <T> T get(String key, Class<T> type, Supplier<T> dataLoader) {
// Step 1: 查询一级缓存（Caffeine）
T value = (T) caffeineCache.getIfPresent(key);
if (value != null) {
return value;
}
// Step 2: 查询二级缓存（Redis）
try {
value = (T) redisTemplate.opsForValue().get(key);
if (value != null) {
// 回填到一级缓存
caffeineCache.put(key, value);
return value;
}
} catch (Exception e) {
// Redis 不可用时记录日志
System.err.println("Redis 不可用：" + e.getMessage());
}
// Step 3: 查询数据源（数据库等）
value = dataLoader.get();
if (value != null) {
// 回填到缓存
caffeineCache.put(key, value);
try {
redisTemplate.opsForValue().set(key, value, 10, TimeUnit.MINUTES);
} catch (Exception e) {
System.err.println("Redis 存储失败：" + e.getMessage());
}
}
return value;
}
@Override
public void put(String key, Object value) {
// 同时更新一级缓存和二级缓存
caffeineCache.put(key, value);
try {
redisTemplate.opsForValue().set(key, value, 10, TimeUnit.MINUTES);
} catch (Exception e) {
System.err.println("Redis 存储失败：" + e.getMessage());
}
}
@Override
public void evict(String key) {
// 同时移除一级缓存和二级缓存
caffeineCache.invalidate(key);
try {
redisTemplate.delete(key);
} catch (Exception e) {
System.err.println("Redis 删除失败：" + e.getMessage());
}
}
@Override
public boolean exists(String key) {
// 检查一级缓存
if (caffeineCache.asMap().containsKey(key)) {
return true;
}
// 检查二级缓存
try {
return Boolean.TRUE.equals(redisTemplate.hasKey(key));
} catch (Exception e) {
System.err.println("Redis 检查键失败：" + e.getMessage());
return false;
}
}
@Override
public Map<String, Object> getAll(Set<String> keys) {
// 优先从一级缓存中获取
Map<String, Object> result = caffeineCache.getAllPresent(keys);
// 还需要获取的键
Set<String> missingKeys = keys.stream()
.filter(key -> !result.containsKey(key))
.collect(Collectors.toSet());
if (!missingKeys.isEmpty()) {
try {
// 从 Redis 获取剩余的键
List<Object> redisResults = redisTemplate.opsForValue().multiGet(missingKeys);
if (redisResults != null) {
for (int i = 0; i < missingKeys.size(); i++) {
String key = missingKeys.toArray(new String[0])[i];
Object value = redisResults.get(i);
if (value != null) {
result.put(key, value);
caffeineCache.put(key, value); // 回填一级缓存
}
}
}
} catch (Exception e) {
System.err.println("Redis 批量获取失败：" + e.getMessage());
}
}
return result;
}
@Override
public Object getHash(String key, String hashKey) {
try {
return redisTemplate.opsForHash().get(key, hashKey);
} catch (Exception e) {
System.err.println("Redis 获取哈希字段失败：" + e.getMessage());
return null;
}
}
@Override
public void putHash(String key, String hashKey, Object value) {
try {
redisTemplate.opsForHash().put(key, hashKey, value);
} catch (Exception e) {
System.err.println("Redis 存储哈希字段失败：" + e.getMessage());
}
}
@Override
public void evictAll(Collection<String> keys) {
// 删除一级缓存
caffeineCache.invalidateAll(keys);
// 删除二级缓存
try {
redisTemplate.delete(keys);
} catch (Exception e) {
System.err.println("Redis 批量删除失败：" + e.getMessage());
}
}
}
空值缓存（防止缓存穿透）
为了避免查询不存在的数据穿透到数据库，可以将空值存储到缓存中：
if (value == null) {
// 存储空值到缓存，防止穿透
caffeineCache.put(key, "NULL");
try {
redisTemplate.opsForValue().set(key, "NULL", 1, TimeUnit.MINUTES);
} catch (Exception e) {
System.err.println("Redis 存储空值失败：" + e.getMessage());
}
return null;
}
if ("NULL".equals(value)) {
return null;
}
异步更新 Redis（提升写性能）
为了提高写操作性能，可以将 Redis 的更新操作放到异步线程中：
private void asyncUpdateRedis(String key, Object value) {
new Thread(() -> {
try {
redisTemplate.opsForValue().set(key, value, 10, TimeUnit.MINUTES);
} catch (Exception e) {
System.err.println("Redis 异步更新失败：" + e.getMessage());
}
}).start();
}
在 put 和 get 方法中调用 asyncUpdateRedis。
定时清理 Caffeine
Caffeine 默认是惰性清理（Lazy Cleanup）。如果需要主动清理，可以通过定时任务触发：
@Scheduled(fixedRate = 60000) // 每分钟执行一次
public void cleanUpCache() {
caffeineCache.cleanUp();
}
总结与优势
架构特点
- 性能更高：直接按一级缓存 -> 二级缓存 -> 数据库的顺序查询，减少了 Redis 可用性检查的开销。
- 降级容错：当 Redis 不可用时，不影响数据加载和缓存更新。
- 缓存一致性：通过回填机制，尽量保持一级缓存和二级缓存的数据一致性。
- 可扩展性：支持空值缓存、异步更新、主动清理等增强功能。
应用场景
- 高频访问的数据（如热门商品、热点新闻）。
- 分布式应用需要共享缓存的数据。
- 对性能和容错性有较高要求的业务场景。
通过 Caffeine 和 Redis 的结合，可以构建一个高效、灵活、稳定的二级缓存架构，有效提升系统性能并降低后端服务压力。
热门推荐
人力资源部门薪酬机制中，绩效考核占多大比重？
农村自建房是否需要房管局备案？全面解读农村房屋登记备案制度
如何利用360度评估做好民主评议促进干部管理与选拔？
桂附地黄丸可阴阳双补，药效却天差地别，要注意3技巧和2误区
南辕北辙寓言故事解析，教你如何避免方向错误！
C语言指针完全解析：从入门到实战
黏液脓血便常见于哪些疾病
丁烷库房防静电措施怎么做？
超智融合研究报告：通用全精度高算力芯片成为关键技术
延毕生在求职时需要注意哪些问题？
2025 年计算机视觉相机校准指南
成都推出240小时免签旅游线路
交换机VLAN划分方法详解：三种主流方式全解析
品牌 让贵州非遗“活”在当下“火”在市场
吞下的口香糖，会一直在肚子里吗？
赋能千行百业 扬州加快推动北斗规模化应用
证据的收集与保全是什么
「看不见」的眼底出血，你了解多少？
分子筛的特性及应用范围介绍
自体全能干细胞技术平台：核移植开启个性化医疗新纪元
生物工程专业求职者怎样写好技能特长
共鸣在音乐艺术中的表现与影响分析
员工申请离职后反悔,公司如何处理
如何制定高效的软件开发版本管理规范？
AE是美国哪个州的缩写
生育保险使用方法详解：津贴申领、医疗费用报销等关键信息
财产保全解封申请书写作指南及解封时间说明
哪些人可以获取生育基金建议？
中铁十一局到二十五局综合实力对比
气缸排列形式