Redis封装工具类，解决缓存穿透、缓存击穿

缓存穿透和缓存击穿的解决思路

1.缓存穿透 ：缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库。

常见的解决方案有两种：

• 缓存空对象
  • 优点：实现简单，维护方便
  • 缺点：
    • 额外的内存消耗
    • 可能造成短期的不一致
• 布隆过滤器
  • 优点：内存占用较少，没有多余key
  • 缺点：
    • 实现复杂
    • 存在误判可能

缓存空对象思路分析：当我们客户端访问不存在的数据时，先请求redis，但是此时redis中没有数据，此时会访问到数据库，但是数据库中也没有数据，这个数据穿透了缓存，直击数据库，我们都知道数据库能够承载的并发不如redis这么高，如果大量的请求同时过来访问这种不存在的数据，这些请求就都会访问到数据库，简单的解决方案就是哪怕这个数据在数据库中也不存在，我们也把这个数据存入到redis中去，这样，下次用户过来访问这个不存在的数据，那么在redis中也能找到这个数据就不会进入到缓存了

布隆过滤器：布隆过滤器其实采用的是哈希思想来解决这个问题，通过一个庞大的二进制数组，走哈希思想去判断当前这个要查询的这个数据是否存在，如果布隆过滤器判断存在，则放行，这个请求会去访问redis，哪怕此时redis中的数据过期了，但是数据库中一定存在这个数据，在数据库中查询出来这个数据后，再将其放入到redis中。

假设布隆过滤器判断这个数据不存在，则直接返回

这种方式优点在于节约内存空间，存在误判，误判原因在于：布隆过滤器走的是哈希思想，只要哈希思想，就可能存在哈希冲突

2.缓存击穿：缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。

常见的解决方案有两种：

• 互斥锁
• 逻辑过期

逻辑分析：假设线程1在查询缓存之后，本来应该去查询数据库，然后把这个数据重新加载到缓存的，此时只要线程1走完这个逻辑，其他线程就都能从缓存中加载这些数据了，但是假设在线程1没有走完的时候，后续的线程2，线程3，线程4同时过来访问当前这个方法， 那么这些线程都不能从缓存中查询到数据，那么他们就会同一时刻来访问查询缓存，都没查到，接着同一时间去访问数据库，同时的去执行数据库代码，对数据库访问压力过大

基于StringRedisTemplate封装一个缓存工具类，满足下列需求：

• 方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
• 方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
• 方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
• 方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
• 方法5：根据指定的key查询缓存，并反序列化为指定类型，需要互斥锁解决缓存击穿问题

方法1和方法3是对应的
方法2和方法4、方法5是对应的

代码如下：

package com.hmdp.utils;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import static com.hmdp.utils.RedisConstants.*;

/**
 * Redis封装工具类
 *
 * @author 胡子龙
 * @date 2023/12/20 16:58
 **/
@Slf4j
@Component
public class CacheClient {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // 线程池
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    /**
     * 将任意Java对象序列化为Json并存储在string类型的key中，并且可以设置TTL过期时间
     *
     * @param key      key
     * @param value    value
     * @param time     时间
     * @param timeUnit 时间单位
     */
    public void set(String key, Object value, Long time, TimeUnit timeUnit) {
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, timeUnit);
    }


    /**
     * 将任意Java对象序列化为Json并存储在String类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
     *
     * @param key      key
     * @param value    value
     * @param time     时间
     * @param timeUnit 时间单位
     */
    public void setWithLogicalExpireTime(String key, Object value, Long time, TimeUnit timeUnit) {
        // 封装RedisData
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(time)));
        // 存入redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    /**
     * 利用缓存空值的方式解决缓存穿透问题
     * @param prefix key的前缀
     * @param id 数据id
     * @param type 返回值类型
     * @param dbFallback 数据库查询的函数
     * @param ttl 过期时间
     * @param timeUnit 时间单位
     * @return 查询结果
     * @param <R> 泛型
     * @param <ID> 泛型
     */
    public <R, ID> R queryWithPassThrough(String prefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long ttl, TimeUnit timeUnit) {
        //拼接key
        String key = prefix + id;
        // 判断Redis中是否有缓存
        String cacheShop = stringRedisTemplate.opsForValue().get(key);
        // 如果有 直接返回
        if (StrUtil.isNotBlank(cacheShop)) {
            return JSONUtil.toBean(cacheShop, type);
        }
        // 以上方法只判断了字符串不为空 考虑如果为null或""的情况 需要再判断
        // 如果以上if不成立 cacheShop只能是null或""
        if (cacheShop != null) {
            // 如果值为"" 证明数据库和缓存中都没有该数据，防止缓存穿透，需要返回错误信息
            return null;
        }
        // 如果没有 在数据库查询
        R r = dbFallback.apply(id);
        // 判断数据库查询结果是否为空,防止缓存穿透，查询结果为空的话将空值存入Redis
        if (BeanUtil.isEmpty(r)) {
            this.set(key, "", 2L, timeUnit);
            // 返回错误信息
            return null;
        }
        // 如果不为空 将查询结果存入Redis
        this.set(key, r, ttl, timeUnit);
        // 返回结果
        return r;
    }

    /**
     * 利用逻辑过期时间解决缓存击穿问题
     * @param prefix key的前缀
     * @param id 数据id
     * @param type 返回值类型
     * @param dbFallback 数据库查询的函数
     * @param ttl 过期时间
     * @param timeUnit 时间单位
     * @return 查询结果
     * @param <R> 泛型
     * @param <ID> 泛型
     */
    public <R,ID> R queryWithLogicalExpireTime(String prefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long ttl, TimeUnit timeUnit){
        //拼接key
        String key = prefix + id;
        // 从redis中查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 如果为空，返回空
        if (StrUtil.isBlank(json)) {
            return null;
        }
        // 判断是否过期
        RedisData shopData = JSONUtil.toBean(json, RedisData.class);
        R r = JSONUtil.toBean(JSONUtil.toJsonStr(shopData.getData()), type);
        LocalDateTime expireTime = shopData.getExpireTime();
        if (LocalDateTime.now().isBefore(expireTime)) {
            // 如果未过期，返回信息
            return r;
        }
        // 如果过期，尝试获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        Boolean isLock = tryLock(lockKey);
        // 如果获取到互斥锁，开启独立线程进行缓存重建
        if (isLock) {
            log.info("获取到互斥锁。。。。。");
            // 开启独立线程进行缓存重建
            CACHE_REBUILD_EXECUTOR.execute(() -> {
                try {
                    log.info("缓存重建开始。。。");
                    R newR = dbFallback.apply(id);
                    setWithLogicalExpireTime(key,newR,ttl,timeUnit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    log.info("释放互斥锁。。。。。");
                    unlock(lockKey);
                }
            });
        }
        return r;
    }


    /**
     * 利用互斥锁解决缓存击穿问题
     * @param prefix key的前缀
     * @param id 数据id
     * @param type 返回值类型
     * @param dbFallback 数据库查询的函数
     * @param ttl 过期时间
     * @param timeUnit 时间单位
     * @return 查询结果
     * @param <R> 泛型
     * @param <ID> 泛型
     */
    public <R,ID> R queryWithMutex(String prefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long ttl, TimeUnit timeUnit) {
        //拼接key
        String key = prefix + id;
        // 判断Redis中是否有缓存
        String cacheShop = stringRedisTemplate.opsForValue().get(key);
        // 如果有 直接返回
        if (StrUtil.isNotBlank(cacheShop)) {
            return JSONUtil.toBean(cacheShop, type);
        }
        // 以上方法只判断了字符串不为空 考虑如果为null或""的情况 需要再判断
        // 如果以上if不成立 cacheShop只能是null或""
        if (cacheShop != null) {
            // 如果值为"" 证明数据库和缓存中都没有该数据，防止缓存穿透，需要返回错误信息
            return null;
        }
        R r = null;


        String lockKey = LOCK_SHOP_KEY + id;
        try {
            // 1.尝试获取互斥锁
            boolean isLock = tryLock(lockKey);
            // 2.如果获取锁失败，说明其他线程已经获取到了锁，则休眠重试
            if (!isLock) {
                log.info("互斥锁被占用中。。。");
                // 休眠后重试
                Thread.sleep(50);
                return queryWithMutex(prefix,id,type,dbFallback,ttl,timeUnit);
            }
            log.info("获取到互斥锁。。。");
            // 3. 如果获取锁成功，在数据库查询
            r = dbFallback.apply(id);
            // 判断数据库查询结果是否为空,防止缓存穿透，查询结果为空的话将空值存入Redis
            if (BeanUtil.isEmpty(r)) {
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                // 返回错误信息
                return null;
            }
            // 如果不为空 将查询结果存入Redis
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(r),ttl,timeUnit);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            unlock(lockKey);
        }
        // 返回结果
        log.info(r.toString());
        return r;
    }

    /**
     * 获取互斥锁
     * @param key 互斥锁的Key
     * @return true:获取成功 false:获取失败
     */
    private Boolean tryLock(String key) {
        // 获取锁
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 释放互斥锁
     * @param key 互斥锁的Key
     */
    private void unlock(String key) {
        // 释放锁
        stringRedisTemplate.delete(key);
    }
}