Redis实战（黑马点评）——关于缓存（缓存更新策略、缓存穿透、缓存雪崩、缓存击穿、Redis工具）

redis实现查询缓存的业务逻辑 

 service层实现

@Overridepublic Result queryById(Long id) {String key = CACHE_SHOP_KEY + id;// 现查询redis内有没有数据String shopJson = (String) redisTemplate.opsForValue().get(key);if(StrUtil.isNotBlank(shopJson)){ // 如果redis的数据为存在，那么解析为对象// 将json转为对象Shop shop = JSONUtil.toBean(shopJson, Shop.class);return Result.ok(shop);}// 如果不存在，就先查数据库，再存入redisShop shop = getById(id);if(shop == null){return Result.fail("店铺不存在");}// 存在就写入redis，包括将对象转为jsonredisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));return Result.ok(shop);}

缓存更新策略 

缓存更新策略的最佳实践方案：

1. 低一致性需求：使用Redis自带的内存淘汰机制
2. 高一致性需求：主动更新，并以超时删除作为处理方案

读操作：（查询）

• 缓存命中则直接返回
• 缓存未命中则查询数据库，并写入缓存，设定超时时间

写操作：（增删改）

• 先写数据库，然后再删除缓存
• 要确保数据库与缓存操作的原子性

缓存穿透

缓存穿透产生的原因是什么？

• 用户请求的数据在缓存中和数据库中都不存在，不断发起这样的请求，给数据库带来巨大压力。

缓存穿透的解决方案有哪些？

• 缓存null值
• 布隆过滤器
• 增强id的复杂度，避免被猜测id规律
• 做好数据的基本格式校验
• 加强用户权限校验
• 做好热点参数的限流

 缓存空对象的方法解决缓存穿透

@Override  
public Result queryById(Long id) {  // 使用店铺ID构建缓存键  String key = CACHE_SHOP_KEY + id;  // 检查店铺信息是否已经缓存到Redis中  String shopJson = (String) redisTemplate.opsForValue().get(key);  // 如果缓存中存在数据，则将JSON字符串解析为Shop对象  if (StrUtil.isNotBlank(shopJson)) {   // 将JSON转换为Shop对象  Shop shop = JSONUtil.toBean(shopJson, Shop.class);  return Result.ok(shop); // 返回店铺对象作为成功结果  }  // 如果缓存中包含表示无数据的占位符，则返回错误信息  if ("#".equals(shopJson)) {  return Result.fail("没有店铺相关信息"); // 没有店铺信息可用  }  // 如果缓存中未找到店铺数据，则查询数据库  Shop shop = getById(id);  // 如果数据库中不存在该店铺  if (shop == null) {  // 在缓存中存储一个占位符，以表示该店铺不存在  // 这可以防止对同一ID的进一步查询再次访问数据库  redisTemplate.opsForValue().set(key, "#", CACHE_NULL_TTL, TimeUnit.MINUTES);  return Result.fail("店铺不存在"); // 返回错误，指示店铺不存在  }  // 如果找到店铺，则将店铺对象以JSON字符串的形式存储到缓存中  redisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);  return Result.ok(shop); // 返回店铺对象作为成功结果  
}

缓存雪崩

缓存击穿 

缓存击穿是指在高并发环境下，某个热点数据的缓存同时失效，导致大量请求直接访问数据库，从而造成数据库压力骤增的现象。

缓存击穿解决方案

解决方案	优点	缺点
互斥锁	- 没有额外的内存消耗 - 保证一致性 - 实现简单	- 线程需要等待，性能受到影响 - 可能有死锁风险
逻辑锁	- 线程无需等待，性能较好	- 不保证一致性 - 有额外的内存消耗 - 实现复杂

基于互斥锁解决缓存击穿 

 基于互斥锁解决缓存击穿 + 缓存空对象的方法解决缓存穿透

// 查询店铺信息，使用互斥锁解决缓存击穿问题
public Shop queryWithMutex(Long id) {// 构造缓存的keyString key = CACHE_SHOP_KEY + id;// 1. 先从Redis中查询店铺信息String shopJson = (String) redisTemplate.opsForValue().get(key);// 如果Redis中存在缓存数据，直接解析JSON并返回对象if (StrUtil.isNotBlank(shopJson)) {// 将JSON字符串转换为Shop对象Shop shop = JSONUtil.toBean(shopJson, Shop.class);return shop;}// 如果Redis中缓存的值为"#", 表示数据库中没有该店铺信息if ("#".equals(shopJson)) {return null;}// 2. 构造互斥锁的keyString lockKey = "lock:shop:" + id;// 定义店铺对象Shop shop = null;try {// 尝试获取互斥锁boolean isLock = tryLock(lockKey);// 如果获取锁失败，线程休眠50ms后重试if (!isLock) {Thread.sleep(50); // 等待50msreturn queryWithMutex(id); // 递归调用，再次尝试获取锁}// 3. 如果没有获取到缓存数据，查询数据库shop = getById(id);// 模拟数据库查询的延时，生产环境应该去掉这段代码// Thread.sleep(200);// 4. 如果数据库中没有该店铺信息if (shop == null) {// 在Redis中存储一个特殊的标记值"#", 表示该店铺不存在redisTemplate.opsForValue().set(key, "#", CACHE_NULL_TTL, TimeUnit.MINUTES);return null;}// 5. 如果数据库中有数据，将店铺信息存入Redis// 将Shop对象转换为JSON字符串redisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);} catch (InterruptedException e) {// 捕获线程中断异常throw new RuntimeException(e);} finally {// 释放互斥锁unlock(lockKey);}// 返回查询到的店铺信息return shop;
}// 封装获取锁，释放锁
// 尝试获取互斥锁
private boolean tryLock(String key) {// 使用Redis的setIfAbsent方法尝试设置锁// 如果key不存在，则设置成功并返回true；否则返回falseBoolean flag = redisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);// 并设置一个过期时间（这里是 10 秒）return BooleanUtil.isTrue(flag);
}// 释放互斥锁
private void unlock(String key) {// 删除锁对应的keyredisTemplate.delete(key);
}

setIfAbsent 方法是 Redis 中的一种操作，用于设置一个键的值，仅在该键不存在的情况下进行设置。具体来说，它的功能如下：

• 键不存在时：如果指定的键（key）在 Redis 中不存在，则将其设置为指定的值（在这个例子中是 "1"），并可以指定该键的过期时间（这里是 10 秒）。此时，方法返回 true。

• 键已存在时：如果指定的键已经存在于 Redis 中，则不会进行任何操作，保持原有的值不变，方法返回 false。

基于逻辑锁解决缓存击穿 

 // 创建一个固定大小的线程池，用于缓存重建任务，避免频繁创建线程带来的开销private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);/*** 查询商铺信息，考虑逻辑过期* @param id 商铺ID* @return 商铺信息，如果不存在或已过期则返回null*/public Shop queryWithLogicalExpire(Long id){// 构建缓存的key，用于从Redis中查询对应的商铺信息String key = CACHE_SHOP_KEY + id;// 1. 从Redis查询商铺缓存，获取商铺信息的JSON字符串String shopJson = (String) redisTemplate.opsForValue().get(key);// 2. 判断缓存是否存在if (StrUtil.isBlank(shopJson)) {// 3. 缓存不存在，直接返回nullreturn null;}// 4. 缓存命中，需要先将JSON字符串反序列化为RedisData对象RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);// 从RedisData对象中提取商铺信息，并将其反序列化为Shop对象Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);// 获取缓存的过期时间LocalDateTime expireTime = redisData.getExpireTime();// 5. 判断缓存是否过期if (expireTime.isAfter(LocalDateTime.now())) {// 5.1. 缓存未过期，直接返回商铺信息return shop;}// 构建锁的key，用于控制缓存重建的并发访问String lockKey = LOCK_SHOP_KEY + id;// 尝试获取锁，确保缓存重建操作的线程安全boolean isLock = tryLock(lockKey);// 6.2. 判断是否成功获取锁if (isLock) {// 6.3. 成功获取锁，开启独立线程进行缓存重建，避免阻塞主线程CACHE_REBUILD_EXECUTOR.submit(() -> {try {// 重建缓存，将最新的商铺信息保存到Redis中，并设置过期时间this.saveShop2Redis(id, 20L); // 假设20L是过期时间，单位为秒} catch (Exception e) {// 如果在缓存重建过程中发生异常，抛出运行时异常，并记录日志throw new RuntimeException(e);} finally {// 无论缓存重建成功与否，都需要释放锁，避免死锁unlock(lockKey);}});}// 返回当前查询到的商铺信息（可能已过期）return shop;}public void saveShop2Redis(Long id, Long expireSeconds) {// 1. 查询店铺数据Shop shop = getById(id);// 2. 封装逻辑过期时间RedisData redisData = new RedisData();redisData.setData(shop);redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));// 3. 写入RedisredisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));}

RedisData类

@Data
public class RedisData {private LocalDateTime expireTime;private Object data;
}

 封装redis工具类

    @Resourceprivate CacheClient cacheClient;public static final String CACHE_SHOP_KEY = "cache:shop:";public static final Long CACHE_SHOP_TTL = 30L;@Overridepublic Result queryById(Long id)  {// 解决缓存穿透
//        Shop shop = cacheClient // 传入一个从数据库内获取Shop对象的函数：this::getById
//                .queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);// 互斥锁解决缓存击穿Shop shop = cacheClient.queryWithMutex(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);if(shop == null){return Result.fail("店铺不存在");}return Result.ok(shop);}

1. queryWithPassThrough

这个方法用于处理缓存穿透问题。缓存穿透是指查询一个数据库中不存在的数据，由于缓存中也没有这个数据，所以每次查询都会直接打到数据库上，增加数据库的压力。

• 参数：

  • keyPrefix：缓存的前缀。

  • id：缓存的ID。

  • type：返回对象的类型。

  • dbFallback：数据库查询的回调函数。

  • time：缓存时间。

  • unit：时间单位。

2. queryWithLogicalExpire

这个方法用于处理缓存击穿问题。缓存击穿是指一个缓存中非常热门的数据突然过期，导致大量请求同时打到数据库上，增加数据库的压力。

• 参数：与 queryWithPassThrough 相同。

最大的缺点是运行前要把所有缓存加到redis内，不然怎么查都是null

3. queryWithMutex（互斥锁）

这个方法结合了 queryWithPassThrough 和 queryWithLogicalExpire 的功能，用于处理缓存穿透和缓存击穿问题。

• 参数：与 queryWithPassThrough 相同。

@Slf4j
@Component
public class CacheClient {public static final Long CACHE_NULL_TTL = 2L;public static final String LOCK_SHOP_KEY = "lock:shop:";private final RedisTemplate redisTemplate;private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);public CacheClient(RedisTemplate redisTemplate) {this.redisTemplate = redisTemplate;}public void set(String key, Object value, Long time, TimeUnit unit) {redisTemplate.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)));// 写入RedisredisTemplate.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;// 1.从redis查询商铺缓存String json = (String) redisTemplate.opsForValue().get(key);// 2.判断是否存在if (StrUtil.isNotBlank(json)) {// 3.存在，直接返回return JSONUtil.toBean(json, type);}// 判断命中的是否是空值if (json != null) {// 返回一个错误信息return null;}// 4.不存在，根据id查询数据库R r = dbFallback.apply(id);// 5.不存在，返回错误if (r == null) {// 将空值写入redisredisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);// 返回错误信息return null;}// 6.存在，写入redisthis.set(key, r, time, unit);return r;}public <R, ID> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {String key = keyPrefix + id;// 1.从redis查询商铺缓存String json = (String) redisTemplate.opsForValue().get(key);// 2.判断是否存在if (StrUtil.isBlank(json)) {// 3.存在，直接返回return null;}// 4.命中，需要先把json反序列化为对象RedisData redisData = JSONUtil.toBean(json, RedisData.class);R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);LocalDateTime expireTime = redisData.getExpireTime();// 5.判断是否过期if(expireTime.isAfter(LocalDateTime.now())) {// 5.1.未过期，直接返回店铺信息return r;}// 5.2.已过期，需要缓存重建// 6.缓存重建// 6.1.获取互斥锁String lockKey = LOCK_SHOP_KEY + id;boolean isLock = tryLock(lockKey);// 6.2.判断是否获取锁成功if (isLock){// 6.3.成功，开启独立线程，实现缓存重建CACHE_REBUILD_EXECUTOR.submit(() -> {try {// 查询数据库R newR = dbFallback.apply(id);// 重建缓存this.setWithLogicalExpire(key, newR, time, unit);} catch (Exception e) {throw new RuntimeException(e);}finally {// 释放锁unlock(lockKey);}});}// 6.4.返回过期的商铺信息return r;}public <R, ID> R queryWithMutex(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {String key = keyPrefix + id;// 1.从redis查询商铺缓存String shopJson = (String) redisTemplate.opsForValue().get(key);// 2.判断是否存在if (StrUtil.isNotBlank(shopJson)) {// 3.存在，直接返回return JSONUtil.toBean(shopJson, type);}// 判断命中的是否是空值if (shopJson != null) {// 返回一个错误信息return null;}// 4.实现缓存重建// 4.1.获取互斥锁String lockKey = LOCK_SHOP_KEY + id;R r = null;try {boolean isLock = tryLock(lockKey);// 4.2.判断是否获取成功if (!isLock) {// 4.3.获取锁失败，休眠并重试Thread.sleep(50);return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);}// 4.4.获取锁成功，根据id查询数据库r = dbFallback.apply(id);// 5.不存在，返回错误if (r == null) {// 将空值写入redisredisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);// 返回错误信息return null;}// 6.存在，写入redisthis.set(key, r, time, unit);} catch (InterruptedException e) {throw new RuntimeException(e);}finally {// 7.释放锁unlock(lockKey);}// 8.返回return r;}private boolean tryLock(String key) {Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);return BooleanUtil.isTrue(flag);}private void unlock(String key) {redisTemplate.delete(key);}
}