使用 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 的结合，可以构建一个高效、灵活、稳定的二级缓存架构，有效提升系统性能并降低后端服务压力。
热门推荐
太阳能电池充电综合指南
光伏+储能系统的四种应用场景介绍
SiC 技术如何提高太阳能逆变器系统的效率
2025最新研究：企业文化类型如何影响员工满意度
从调查到优化：企业提升员工满意度的完整指南
矿物油5000公里，全合成1万公里：机油更换周期指南
河北春节：从餐桌到民俗，感受燕赵大地年味
腊月二十三还是二十四？小年时间差异的历史由来
从祭灶到扫尘：小年习俗的历史演变与南北差异
联合国教科文组织批准春节申遗，中国非遗项目增至44个
从雪花牛排到蔬菜沙拉：9种高脂食物的隐藏陷阱
解密苏军政委：德军又恨又怕的角色，抓到二话不说，立刻枪毙！
从军府到行省：晚清新疆治理模式的重大转变
天坛公园盖章打卡，你get了吗？
苏港学者综述生物大分子敷料研究进展
医疗器械敷料：七大检测标准与七类敷料应用指南
擦伤烫伤这样处理最安全，6种消毒药物使用指南
怎样在银行办理企业贷款的额度计算？
安全带卡滞，小心车祸找上门！
安全带卡滞怎么办？多种实用解决方案帮你轻松应对
日军炮楼有完整防御体系，八路军攻坚需重炮支持
事故责任认定有异议？这份处理指南请收好
交通事故责任认定可以复议吗
X隐藏点赞功能，似乎终于做了一件对的事情
特写丨旅拍摄影师日赚千元背后：在狂热与谋生之间挣扎
7个拍照姿势，这样拍，随意好看，照片上镜又出圈
提升自拍效果的技巧与自拍杆的完美搭配
如何拍出小红书的质感：成为朋友圈摄影大师的秘诀
万能半身照，9个姿势分享，简单随性，又甜又酷又上镜
瑞安市安阳高级中学：年薪80万招聘教师，引发教育行业热议