什么是缓存
缓存就是数据交换的缓冲区(称作Cache),是存贮数据的临时地方,一般读写性能较高。
缓存的作用
- 降低后端负载
- 提高读写效率,降低响应时间
缓存的成本
- 数据一致性成本
- 代码维护成本
- 运维成本
添加Redis缓存
缓存工作模型
代码实现
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
public static final String CACHE_SHOP_KEY = "cache:shop:";
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Resource
private StringRedisTemplate stringRedisTemplate;
@Override
public Shop queryById(Long id) {
String key = RedisConstants.CACHE_SHOP_KEY + id;
// 从redis查询商铺缓存
String shopJson = stringRedisTemplate.opsForValue().get(key);
// 判断是否存在
if (StrUtil.isNotBlank(shopJson)) {
// 存在
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return shop;
}
// 不存在,查询数据库
Shop shop = getById(id);
if (shop != null) {
// 存在,写入redis
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));
}
return shop;
}
}
缓存更新策略
三种策略
内存淘汰 | 超时剔除 | 主动更新 | |
---|---|---|---|
说明 | 不用自己维护,利用Redis的内存淘汰机制,当内存不足时自动淘汰部分数据。下次查询时更新缓存 | 给缓存数据添加TTL时间,到期后自动删除缓存,下次查询时更新缓存 | 编写业务逻辑,在修改数据库的同时,更新缓存 |
一致性 | 差 | 一般 | 好 |
维护成本 | 无 | 低 | 高 |
业务场景:
- 低一致性需求:使用内存淘汰机制。例如店铺类型的查询缓存
- 高一致性需求:主动更新,并以超时剔除作为兜底方案。例如店铺详情查询的缓存
主动更新策略
三种模式
- Cache Aside Pattern:由缓存的调用者,在更新数据库的同时更新缓存。 ✅
- Read/Write Through Pattern:缓存与数据库整合为一个服务,由服务来维护一致性。调用者调用该服务,无需关心缓存一致性问题。
- Write Behind Caching Pattern:调用者只操作缓存,由其他线程异步的将缓存数据持久化到数据库,保证最终一致。
三个问题
- 删除缓存还是更新缓存?
- 更新缓存:每次更新数据时都更新缓存,无效写操作太多 ❌
- 删除缓存:更新数据库时让缓存失效,查询时再更新缓存 ✅
- 如何保证缓存与数据库的操作的同时成功或失败?
- 单体系统,将缓存与数据库操作放在同一个事务
- 分布式系统,利用TCC等分布式事务方案
- 先操作缓存还是先操作数据库?
- 先删除缓存,再操作数据库
- 先操作数据库,再删除缓存 ✅
最佳实践方案
- 第一致性需求:使用Redis自带的内存淘汰机制
- 高一致性需求:主动更新,并以超时剔除作为兜底方案
- 读操作:
- 缓存命中则直接返回
- 缓存未命中查询数据库,并写入缓存,设定超时时间
- 写操作
- 先写数据库,然后再删除缓存
- 要确保数据库与缓存操作的原子性
- 读操作:
代码实操
在查询操作中添加超时时间
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Resource
private StringRedisTemplate stringRedisTemplate;
@Override
public Shop queryById(Long id) {
String key = RedisConstants.CACHE_SHOP_KEY + id;
// 从redis查询商铺缓存
String shopJson = stringRedisTemplate.opsForValue().get(key);
// 判断是否存在
if (StrUtil.isNotBlank(shopJson)) {
// 存在
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return shop;
}
// 不存在,查询数据库
Shop shop = getById(id);
if (shop != null) {
// 存在,写入redis
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
}
return shop;
}
}
更新操作
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
@Resource
private StringRedisTemplate stringRedisTemplate;
@Override
@Transactional
public Boolean update(Shop shop) {
Long id = shop.getId();
if (id == null) {
return null;
}
// 1.更新数据库
Boolean state1 = updateById(shop);
// 2.删除缓存
String key = RedisConstants.CACHE_SHOP_KEY + shop.getId();
Boolean state2 = stringRedisTemplate.delete(key);
return state1 && state2;
}
}
缓存穿透
缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在,这样缓存永远不会生效,这些请求都会到达数据库。
常见的两种解决方案
- 缓存空对象
- 优点:实现简单
- 缺点:额外的内存消耗,可能造成短期的不一致
- 布隆过滤
- 优点:内存占用少,没有多余key
- 缺点:实现复杂,存在误判可能
通常采用第一种方式
实现思路
代码实操
更新之前的查询代码,解决内存穿透问题
@Override
public Shop queryById(Long id) {
String key = RedisConstants.CACHE_SHOP_KEY + id;
// 从redis查询商铺缓存
String shopJson = stringRedisTemplate.opsForValue().get(key);
// 判断是否存在
if (StrUtil.isNotBlank(shopJson)) {
// 存在
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return shop;
}
// 判断命中的是否为空值 => shopJson == ""
if (shopJson != null) {
// 返回错误信息
return null;
}
// 不存在,查询数据库
Shop shop = getById(id);
if (shop != null) {
// 存在,写入redis
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
} else {
// 不存在,写入空值,解决内存穿透问题
stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
}
return shop;
}
当查询不存在的数据时,缓存为空值
总结
缓存穿透产生的原因是什么?
- 用户请求的数据在缓存中和数据库中都不存在,不断发起这样的请求,给数据库带来巨大的压力
缓存穿透的解决方案有哪些?
- 缓存null值
- 布隆过滤
- 增强id的复杂度,避免被猜测id规律
- 做好数据的基础格式校验
- 加强用户权限校验
- 做好热点参数的限流
缓存雪崩
缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机,导致大量请求到达数据库,带来巨大压力
解决方案
-
给不同的Key的TTL添加随机值
-
利用Redi集群提高服务的可用性
-
给缓存业务添加降级限流策略
-
给业务添加多级缓存
缓存击穿
缓存击穿问题也叫热点Key问题,就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了,无数的请求访问会在瞬间给数据库带来巨大冲击。
解决方案
-
互斥锁
-
逻辑过期
KEY VALUE heima:user:1 {name:"Jack", age:"21", expire:"114514114514"}
优缺点
解决方案 | 优点 | 缺点 |
---|---|---|
互斥锁 | 没有额外的内存消耗 保证一致性 实现简单 |
线程需要等待,性能受影响 可能有死锁风险 |
逻辑过期 | 线程无需等待,性能较好 | 不保证一致性 有额外的内存消耗 实现复杂 |
互斥锁
- 优点
- 没有额外的内存消耗
- 保证一致性
- 实现简单
- 缺点
- 线程需要等待,性能受影响
- 可能有死锁风险
逻辑过期
- 优点
- 线程无需等待,性能较好
- 缺点
- 不保证一致性
- 有额外的内存消耗
- 实现复杂
代码实操
互斥锁解决
利用互斥锁解决缓存击穿问题
public Shop queryWithMutex(Long id) {
String key = RedisConstants.CACHE_SHOP_KEY + id;
// 从redis查询商铺缓存
String shopJson = stringRedisTemplate.opsForValue().get(key);
// 判断是否存在
if (StrUtil.isNotBlank(shopJson)) {
// 存在
Shop shop = JSONUtil.toBean(shopJson, Shop.class);
return shop;
}
// 判断命中的是否为空值 => shopJson == ""
if ("".equals(shopJson)) {
// 返回错误信息
return null;
}
// 实现缓存重建
// 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
Shop shop = null;
try {
boolean isLock = tryLock(lockKey);
if (!isLock) {
// 失败,休眠并重试
Thread.sleep(50);
return queryWithMutex(id);
}
// 成功,查询数据库
shop = getById(id);
if (shop != null) {
// 存在,写入redis
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
} else {
// 不存在,写入空值,解决内存穿透问题
stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
// 释放互斥锁
unLock(lockKey);
}
return shop;
}
// 获取锁
private boolean tryLock(String key) {
Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
return BooleanUtil.isTrue(flag);
}
// 释放锁
private void unLock(String key) {
stringRedisTemplate.delete(key);
}
逻辑过期解决
基于逻辑过期方式解决缓存击穿问题,数据需要提前写入Redis
代码
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public Shop queryWithLogicalExpire(Long id) {
String key = CACHE_SHOP_KEY + id;
// 从redis查询商铺缓存
String shopJson = stringRedisTemplate.opsForValue().get(key);
// 判断是否存在
if (StrUtil.isBlank(shopJson)) {
// 不存在,直接返回
return null;
}
// 命中,需要先把json反序列化为对象
RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
LocalDateTime expireTime = redisData.getExpireTime();
// 判断是否过期
if (expireTime.isAfter(LocalDateTime.now())) {
// 未过期,直接返回店铺信息
return shop;
}
// 过期,需要重建缓存
// 缓存重建
// 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
boolean isLock = tryLock(lockKey);
// 判断是否获取锁成功
if (isLock) {
// DoubleCheck
String doubleShopJson = stringRedisTemplate.opsForValue().get(key);
RedisData doubleRedisData = JSONUtil.toBean(doubleShopJson, RedisData.class);
if (doubleRedisData.getExpireTime().isAfter(LocalDateTime.now())) {
// 未过期,直接返回店铺信息
return JSONUtil.toBean((JSONObject) doubleRedisData.getData(), Shop.class);
}
// 成功,开启独立线程,实现缓存重建
CACHE_REBUILD_EXECUTOR.submit(() -> {
try {
// 重建缓存
saveShop2Redis(id, 1800L);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
// 释放锁
unLock(lockKey);
}
});
}
// 返回过期的商铺信息
return shop;
}
// 数据预热
private void saveShop2Redis(Long id, Long expireSeconds) {
// 查询店铺数据
Shop shop = getById(id);
// 逻辑过期时间
RedisData redisData = new RedisData();
redisData.setData(shop);
redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
// 写入redis
String key = RedisConstants.CACHE_SHOP_KEY + id;
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}
缓存工具封装
基于StringRedisTemplate封装一个缓存工具类,满足下列需求:
- 方法1:将任意java对象序列化为json并存储在string类型中的key中,并且可以设置TTL过期时间
- 方法2:将任意java对象序列化为json并存储在string类型中的key中,并且可以设置逻辑过期时间,用于处理缓存击穿问题。
- 方法3:根据指定key查询缓存,并反序列化为指定类型,利用缓存空值的方式解决缓存穿透问题
- 方法4:根据指定key查询缓存,并反序列化为指定类型,需要利用逻辑过期解决缓存击穿问题
方法1+方法3:设置过期时间,解决缓存穿透
方法2+方法4:针对热点key,解决缓存击穿
工具类
@Slf4j
@Component
public class CacheClient {
private final StringRedisTemplate stringRedisTemplate;
public CacheClient(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
public void set(String key, Object value, Long time, TimeUnit unit) {
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
}
public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
// 设置逻辑过期
RedisData redisData = new RedisData();
redisData.setData(value);
redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
// 写入Redis
stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}
// 解决缓存穿透问题
public <R, ID> R queryWithPassThrough(
String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
String key = keyPrefix + id;
// 从redis查询商铺缓存
String json = stringRedisTemplate.opsForValue().get(key);
// 判断是否存在
if (StrUtil.isNotBlank(json)) {
// 存在
return JSONUtil.toBean(json, type);
}
// 判断命中的是否为空值 => "".equals(shopJson)
if (json != null) {
// 返回错误信息
return null;
}
// 不存在,查询数据库
R r = dbFallback.apply(id);
if (r != null) {
// 存在,写入redis
this.set(key, r, time, unit);
} else {
// 不存在,写入空值,解决内存穿透问题
stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
}
return r;
}
// 解决缓存击穿问题,逻辑锁
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public <R, ID> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
String key = keyPrefix + id;
// 从redis查询商铺缓存
String json = stringRedisTemplate.opsForValue().get(key);
// 判断是否存在
if (StrUtil.isBlank(json)) {
// 不存在,直接返回
return null;
}
// 命中,需要先把json反序列化为对象
RedisData redisData = JSONUtil.toBean(json, RedisData.class);
R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
LocalDateTime expireTime = redisData.getExpireTime();
// 判断是否过期
if (expireTime.isAfter(LocalDateTime.now())) {
// 未过期,直接返回店铺信息
return r;
}
// 过期,需要重建缓存
// 缓存重建
// 获取互斥锁
String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
boolean isLock = tryLock(lockKey);
// 判断是否获取锁成功
if (isLock) {
// DoubleCheck
String json2 = stringRedisTemplate.opsForValue().get(key);
RedisData redisData2 = JSONUtil.toBean(json2, RedisData.class);
if (redisData2.getExpireTime().isAfter(LocalDateTime.now())) {
// 未过期,直接返回店铺信息
return JSONUtil.toBean((JSONObject) redisData2.getData(), type);
}
// 成功,开启独立线程,实现缓存重建
CACHE_REBUILD_EXECUTOR.submit(() -> {
try {
// 重建缓存
R r1 = dbFallback.apply(id);
this.setWithLogicalExpire(key, r1, time, unit);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
// 释放锁
unLock(lockKey);
}
});
}
// 返回过期的商铺信息
return r;
}
private boolean tryLock(String key) {
Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
return BooleanUtil.isTrue(flag);
}
private void unLock(String key) {
stringRedisTemplate.delete(key);
}
}
使用方法
@Override
public Shop queryById(Long id) {
// 缓存穿透
Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
// 逻辑过期解决缓存击穿
// Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
return shop;
}
相关文章:
Redis快速入门
使用Redis实现短信登陆