点评day02 商户缓存

1.概览

复制代码

实际开发中,会构筑多级缓存来使系统运行速度进一步提升,例如:本地缓存与redis中的缓存并发使用

浏览器缓存：主要是存在于浏览器端的缓存

应用层缓存：可以分为tomcat本地缓存，比如之前提到的map，或者是使用redis作为缓存

数据库缓存：在数据库中有一片空间是 buffer pool，增改查数据都会先加载到mysql的缓存中

CPU缓存：当代计算机最大的问题是 cpu性能提升了，但内存读写速度没有跟上，所以为了适应当下的情况，增加了cpu的L1，L2，L3级的缓存

这里主要是利用redis进行并发使用：标准的操作方式就是查询数据库之前先查询缓存，如果缓存数据存在，则直接从缓存中返回，如果缓存数据不存在，再查询数据库，然后将数据存入redis。（外卖中有直接的注解可以完成此类功能，无需自己写代码），复习一下：

复制代码

 缓存更新策略

缓存更新是redis为了节约内存而设计出来的一个东西，主要是因为内存数据宝贵，当我们向redis插入太多数据，此时就可能会导致缓存中的数据过多，所以redis会对部分数据进行更新，或者把他叫为淘汰更合适。

内存淘汰：redis自动进行，当redis内存达到设定的max-memery的时候，会自动触发淘汰机制，淘汰掉一些不重要的数据

超时剔除：当我们给redis设置了过期时间ttl之后，redis会将超时的数据进行删除，方便咱们继续使用缓存

主动更新：我们可以手动调用方法把缓存删掉，通常用于解决缓存和数据库不一致问题，重点说一下这个问题：

复制代码

3.数据库缓存不一致解决方案：

复制代码

由于我们的缓存的数据源来自于数据库,而数据库的数据是会发生变化的,因此,如果当数据库中数据发生变化,而缓存却没有同步,此时就会有一致性问题存在,其后果是:

用户使用缓存中的过时数据,就会产生类似多线程数据安全问题,从而影响业务,产品口碑等;怎么解决呢？有如下几种方案

Cache Aside Pattern 人工编码方式：缓存调用者在更新完数据库后再去更新缓存，也称之为双写方案

Read/Write Through Pattern : 由系统本身完成，数据库与缓存的问题交由系统本身去处理

Write Behind Caching Pattern ：调用者只操作缓存，其他线程去异步处理数据库，实现最终一致


数据库和缓存不一致采用什么方案：

方案	核心逻辑	一致性	实现成本	性能	风险	适用场景
Cache Aside（方案一）	查：缓存无→查库→写缓存；更 / 删：改库→删缓存（或更缓存）	强一致（做好兜底）	低	中	低（易监控、易回滚）	90% 以上的业务场景（电商、后台管理、社交等）
Read/Write Through（方案二）	调用者只操作缓存，缓存层自动同步数据库	强一致	高（需封装缓存中间件）	中	中（缓存层故障会直接影响数据库）	自研缓存中间件、大型分布式系统
Write Behind（方案三）	调用者只写缓存，异步线程批量刷库	最终一致	中高（需处理异步重试、幂等）	高	高（异步丢数据、数据延迟）	非核心业务（日志、统计、点赞数等）

复制代码

综合考虑使用方案一，但是方案一调用者如何处理呢？这里有三个问题：

复制代码

* 删除缓存还是更新缓存？
    更新缓存：每次更新数据库都更新缓存，无效写操作较多
    删除缓存：更新数据库时让缓存失效，查询时再更新缓存
这里我们选择删除缓存，为了避免很多无效的操作

* 如何保证缓存与数据库的操作的同时成功或失败？
    单体系统，将缓存与数据库操作放在一个事务（但是也要注意事务的失效场景）
    分布式系统，利用TCC等分布式事务方案（微服务说）

复制代码

* 先操作缓存还是先操作数据库？
    先删除缓存，再操作数据库
    先操作数据库，再删除缓存

复制代码

应该具体操作缓存还是操作数据库，我们应当是先操作数据库，再删除缓存，原因在于，如果你选择第一种方案，在两个线程并发来访问时，假设线程1先来，他先把缓存删了，此时线程2过来，他查询缓存数据并不存在，此时他写入缓存，当他写入缓存后，线程1再执行更新动作时，实际上写入的就是旧的数据，新的数据被旧数据覆盖了。这是因为数据库的操作一般来说需要耗时比较长，如果是先处理缓存，这时候第一个线程对数据库做了很多更改，导致很慢，然后第二个线程查缓存没有，然后查数据库，查的效率要高于改，所以就把查到的脏数据放到了缓存里，这样就不对了，但是如果先操作数据库，线程一改的过程中如果线程二进来要查数据，缓存现在还有，所以它会拿到数据，只不过现在是老的数据，伤害也比那个方案要小很多。代码如下：我这里就不用那个注解了，因为有些东西需要学习：首先是查询的时候

java 复制代码

    public Object getById1(Long id) {
        String keyShop  = CACHE_SHOP_KEY + id;
        //1.从redis中查询
        String shop = stringRedisTemplate.opsForValue().get(keyShop);
        //2.有直接返回,这里存储商户信息我们使用string类型
        //StrUtil.isNotBlank(shop)判断字符串类型是不是空
        if(StrUtil.isNotBlank(shop)){
            //拿出来的是字符串，需要转换成对象
            Shop bean = JSONUtil.toBean(shop, Shop.class);
            return Result.ok(bean);
        }
        //3.没有查询数据库，并判断是不是空
        Shop shop1 = shopMapper.getById(id);
        //4.写入redis
        if(shop1 == null){
            return Result.fail("商户不存在");
        }
        stringRedisTemplate.opsForValue().set(keyShop,JSONUtil.toJsonStr(shop1),30L,TimeUnit.MINUTES);
        //5.返回数据
        return Result.ok(shop1);
    }

JSONUtil.toJsonStr(shop1)，把一个对象转换为json字符串存起来

JSONUtil.toBean(shop, Shop.class)，这就是反过来，拿到一个json字符串变成一个对象，需要指定对象的字节码文件。

然后是更新商户信息的时候要先更新数据库再删除缓存。

java 复制代码

    public Result updateById1(Shop shop) {
        //先更新数据库
        Long id = shop.getId();
        if (id == null){
            return Result.fail("商户id不能为空");
        }
        shopMapper.updateById(shop);
        //再删除redis
        stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
        return Result.ok();
    }

3.缓存穿透问题

复制代码

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

常见的解决方案有两种：

* 缓存空对象
  * 优点：实现简单，维护方便
  * 缺点：
    * 额外的内存消耗
    * 可能造成短期的不一致
* 布隆过滤
  * 优点：内存占用较少，没有多余key
  * 缺点：
    * 实现复杂
    * 存在误判可能
还有其他：
* 增强id的复杂度，避免被猜测id规律
* 做好数据的基础格式校验
* 加强用户权限校验
* 做好热点参数的限流



这些都可以写在项目拓展中，，我以后会实现，先留个印象。

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

布隆过滤：布隆过滤器其实采用的是哈希思想来解决这个问题，通过一个庞大的二进制数组，走哈希思想去判断当前这个要查询的这个数据是否存在，如果布隆过滤器判断存在，则放行，这个请求会去访问redis，哪怕此时redis中的数据过期了，但是数据库中一定存在这个数据，在数据库中查询出来这个数据后，再将其放入到redis中，假设布隆过滤器判断这个数据不存在，则直接返回，这种方式优点在于节约内存空间，存在误判，误判原因在于：布隆过滤器走的是哈希思想，只要哈希思想，就可能存在哈希冲突，布隆过滤器只要判断没有就一定没有，有的话可能没有

布隆过滤器本质上就是一个二进制数组 ，不管要存多少数据，都是往这同一个数组里做标记，这也是它能极大节省内存的关键原因。

布隆过滤器的核心是二进制数组 + 多个哈希函数，工作流程：

添加元素 ：当你往布隆过滤器中加入一个值（比如 "user123"）时：

用多个独立的哈希函数（比如 3 个）对这个值计算，得到 3 个不同的数组下标（比如 5、18、29）；

把二进制数组中这 3 个下标对应的位置，从 0 置为 1。

查询元素 ：当你判断 "user123" 是否存在时：

用同样的 3 个哈希函数计算，得到同样的 3 个下标；

检查这 3 个位置是否全部为 1 ：

如果有任意一个位置是 0 → 判定 "不存在"；

如果全部是 1 → 判定 "存在"。

为什么 "判断不存在则一定不存在"？

这是布隆过滤器的绝对准确性，核心逻辑很简单：

布隆过滤器的规则是 "只有添加过的元素，才会把对应的哈希位置置为 1"；

如果你去查一个元素的对应二进制位有一个是零，就不可能有这个元素，因为如果有这个元素就不会是0

举个例子：你没加过 "user456"，那它的哈希下标 8、20、31 肯定至少有一个是 0，所以能 100% 确定它不存在。

为什么 "判断存在却可能不存在"（误判）？

这就是哈希冲突导致的，本质是 "不同元素的哈希下标碰巧全部重叠"：

假设你先添加了元素 A，它的哈希下标是 5、18、29 → 这三个位置被置 1；

你又添加了元素 B，它的哈希下标是 7、12、29 → 29 位置已经是 1，只需把 7、12 置 1；

现在有一个从未添加过的元素 C，它的哈希下标碰巧是5，7，29 → 这三个位置全是 1；

布隆过滤器会误判 "元素 C 存在"，但实际上 C 从未被添加过。

这种误判的本质是：二进制数组的 1 是 "共享" 的，多个不同元素的哈希操作可能把同一批位置置 1，导致新元素的哈希下标刚好匹配这些 "被共享的 1"，从而产生误判。

这里我们采用缓存空对象进行避免：

复制代码

在原来的逻辑中，如果发现这个数据在mysql中不存在，直接就返回404了，这样是会存在缓存穿透问题的

现在的逻辑中：如果这个数据不存在，我们不会返回404 ，还是会把这个数据写入到Redis中，并且将value设置为空，欧当再次发起查询时，我们如果发现命中之后，判断这个value是否是null，如果是null，则是之前写入的数据，证明是缓存穿透数据，如果不是，则直接返回数据。

java 复制代码

    public Object getById1(Long id) {
        String keyShop  = CACHE_SHOP_KEY + id;
        //1.从redis中查询
        String shop = stringRedisTemplate.opsForValue().get(keyShop);
        //2.有直接返回,这里存储商户信息我们使用string类型
        //StrUtil.isNotBlank(shop)判断字符串类型是不是空，注意只有里面是具体有值才对
        if(StrUtil.isNotBlank(shop)){
            //说明商户信息不为空，一定是一个商户信息json字符串，不可能要么是一个空对象，
            Shop bean = JSONUtil.toBean(shop, Shop.class);
            return Result.ok(bean);
        }
        if(shop != null){
            //说明是空对象，空对象直接返回给客户端
            return Result.fail("商户不存在");
        }
        //3.没有查询数据库，并判断是不是空
        Shop shop1 = shopMapper.getById(id);
        //4.写入redis
        if(shop1 == null){
            //商户不存在，我们放到redis
            stringRedisTemplate.opsForValue().set(keyShop,"",30L,TimeUnit.MINUTES);
            return Result.fail("商户不存在");
        }
        //不是空，也放在redis
        stringRedisTemplate.opsForValue().set(keyShop,JSONUtil.toJsonStr(shop1),30L,TimeUnit.MINUTES);
        //5.返回数据
        return Result.ok(shop1);
    }

StrUtil.isNotBlank(shop)判断字符串类型是不是空，注意只有里面是具体有值才对，而我们存进去的是空字符串，所以不会成立会往下走，然后

复制代码

if(shop != null){
    //说明是空字符串，空对象直接返回给客户端
    return Result.fail("商户不存在");
}这里应该是不等于null因为这样才是空字符串，一定要注意这里的逻辑，差点弄错哈哈哈。

4.缓存雪崩问题

复制代码

缓存雪崩是指在同一时段大量的缓存key同时失效（同时失效就要一起去数据库里查询然后放在redis里）或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。

解决方案：
* 给不同的Key的TTL添加随机值（避免同时失效）
* 利用Redis集群提高服务的可用性（单机 Redis 存在单点故障风险，比如 Redis 宕机，整个缓存服务不可用，Redis 集群（主从 + 哨兵 / Cluster）能实现故障自动切换、负载均衡、高可用，保证缓存服务不中断，在redis高级中有，我先略过）
* 给缓存业务添加降级限流策略（springcloud里边）
* 给业务添加多级缓存（springcloud里边）

5.缓存击穿问题

复制代码

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。
逻辑分析：假设线程1在查询缓存之后，本来应该去查询数据库，然后把这个数据重新加载到缓存的，此时只要线程1走完这个逻辑，其他线程就都能从缓存中加载这些数据了，但是假设在线程1没有走完的时候，后续的线程2，线程3，线程4同时过来访问当前这个方法， 那么这些线程都不能从缓存中查询到数据，那么他们就会同一时刻来访问查询缓存，都没查到，接着同一时间去访问数据库，同时的去执行数据库代码，对数据库访问压力过大


常见的解决方案有两种：
* 互斥锁

复制代码

因为锁能实现互斥性。假设线程过来，只能一个人一个人的来访问数据库，从而避免对于数据库访问压力过大，但这也会影响查询的性能，因为此时会让查询的性能从并行变成了串行，所以一般不推荐。

* 逻辑过期
方案分析：我们之所以会出现这个缓存击穿问题，主要原因是在于我们对热点key设置了过期时间，假设我们不设置过期时间，其实就不会有缓存击穿的问题，但是不设置过期时间，这样数据不就一直占用我们内存了吗，可以采用逻辑过期方案。

把过期时间设置在 redis的value中，注意：这个过期时间并不会直接作用于redis，而是我们后续通过逻辑去处理。假设线程1去查询缓存，然后从value中判断出来当前的数据已经过期了，此时线程1去获得互斥锁，那么其他线程会进行阻塞，获得了锁的线程他会开启一个新线程去进行 以前的重构数据的逻辑，直到新开的线程完成这个逻辑后，才释放锁， 而线程1直接进行返回，假设现在线程3过来访问，由于线程线程2持有着锁，所以线程3无法获得锁，线程3也直接返回数据，只有等到新开的线程2把重建数据构建完后，其他线程才能走返回正确的数据。

这种方案巧妙在于，异步的构建缓存，缺点在于在构建完缓存之前，返回的都是脏数据，但不会产生缓存击穿问题。

方案分析：

实现方案：

（1）通过互斥锁解决缓存击穿问题，天然的可以使用redis中的sennx实现锁，setnx如果已经存在就会返回false，如果没有就会产生一个key，天然拿到锁，返回true，所以可以用1代表获取成功，0代表失败。注意我们必须得设置这个锁的过期时间，进行兜底处理，防止形成死锁

这是两个封装函数用来获取锁和释放锁

java 复制代码

    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);
    }

Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);

return BooleanUtil.isTrue(flag)

首先setIfAbsent这个函数就是sexnx的效果，然后它会返回三种情况：

如果 Redis 操作成功，返回 Boolean.TRUE。

如果 Redis 操作失败（比如 key 已存在），返回 Boolean.FALSE。

如果 Redis 服务异常、连接超时或操作被中断，它可能返回 null。

如果直接返回那个包装类型的变量，万一出现情况，就会返回null，这样就会报错，可能会产生空指针异常，而使用BooleanUtil.isTrue(flag)，

如果 flag 是 Boolean.TRUE，返回 true。

如果 flag 是 Boolean.FALSE 或 null，返回 false。

这才是健壮性的体现

java 复制代码

public Object getById1(Long id) throws InterruptedException {
        String keyShop  = CACHE_SHOP_KEY + id;
        //1.从redis中查询
        String shop = stringRedisTemplate.opsForValue().get(keyShop);
        //2.有直接返回,这里存储商户信息我们使用string类型
        //StrUtil.isNotBlank(shop)判断字符串类型是不是空，注意空对象不是空！！！
        if(StrUtil.isNotBlank(shop)){
            //说明商户信息不为空，要么是一个商户信息json字符串，不可能要么是一个空对象
            Shop bean = JSONUtil.toBean(shop, Shop.class);
            return Result.ok(bean);
        }
        if(shop != null){
            //说明是空字符串，空对象直接返回给客户端
            return Result.fail("商户不存在");
        }
        //（1）构造锁的key
        String lockKey = "lock:shop:" + id;
        try {
            /*
            * 利用互斥锁实现缓存击穿，能走到这里说明redis里返回的不是一个具体数值，
            * 也不是空字符串，所以就是一个空值，现在要完成缓存重建，要获取锁了
            * */
            //实现缓存重建
            //（2）尝试获取锁
            boolean b = tryLock(lockKey);
            //（3）失败，可以先休眠一段时间，然后重试
            if(!b){
                //说明失败
                Thread.sleep(50);
                //重新调用方法
                return getById1(id);
            }
            //（4）成功查询数据库...就可以加上以前的缓存空字符串和正常存入redis
            //（5）释放锁
            //3.没有查询数据库，并判断是不是空
            Shop shop1 = shopMapper.getById(id);
            //4.写入redis
            if(shop1 == null){
                //商户不存在，我们放到redis
                stringRedisTemplate.opsForValue().set(keyShop,"",30L,TimeUnit.MINUTES);
                return Result.fail("商户不存在");
            }
            //不是空，也放在redis
            stringRedisTemplate.opsForValue().set(keyShop,JSONUtil.toJsonStr(shop1),30L,TimeUnit.MINUTES);
            //5.返回数据
            return Result.ok(shop1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            unlock(lockKey);
        }
    }

这里其实还有一个问题需要处理，在获取锁成功后应该还得判断缓存里有没有数据，如果有就不需要重建了，直接释放锁，没有再往下执行，因为可能你在获取锁之前有其他线程已经实现了重建，这时你就没必要了，所以加了双层判断

（2）逻辑过期代码实现

要给每个对象都加上一个过期时间，这样对原始代码改动是很大的，不建议，所以新建一个实体类

java 复制代码

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

首先因为这是逻辑过期，就不会出现空值，只会出现我们故意放的空字符串，所以StrUtil.isBlack如果是true，只有空字符串的可能

java 复制代码

    public Object getById2(Long id) {
        //1.查询redis
        String keyShop  = CACHE_SHOP_KEY + id;
        String shop = stringRedisTemplate.opsForValue().get(keyShop);
        //2.如果是空字符串。直接返回
        if(StrUtil.isBlank(shop)){
            return Result.fail("商户不存在");
        }
        //3.如果不是则判断缓存是否过期
        RedisData bean = JSONUtil.toBean(shop, RedisData.class);
        LocalDateTime expireTime = bean.getExpireTime();
        //4.未过期，直接返回
        if (expireTime.isAfter(LocalDateTime.now())){
            return JSONUtil.toBean((JSONObject) bean.getData(), Shop.class);
        }
        //5.缓存过期，需要缓存重建
        //5.1 获取锁
        String lockKey = "lock:shop:" + id;
        if (!tryLock(lockKey)){
            //5.2 获取锁失败，返回原来信息
            return JSONUtil.toBean((JSONObject) bean.getData(), Shop.class);
        }
        //5.3 获取成功，做二次检查
        String s = stringRedisTemplate.opsForValue().get(keyShop);
        RedisData bean1 = JSONUtil.toBean(s, RedisData.class);
        LocalDateTime expireTime1 = bean1.getExpireTime();
        //5.3.1查询过期时间，如果未过期，直接返回，无需重建
        if (expireTime1.isAfter(LocalDateTime.now())){
            return JSONUtil.toBean((JSONObject) bean1.getData(), Shop.class);
        }
        //5.3.2过期，开启独立线程，进行缓存重建
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            try {
                //5.4查询数据库
                Shop shop1 = shopMapper.getById(id);
                //5.5有则写入redis，加上有效时间
                if (shop1 != null) {
                    RedisData redisData = new RedisData();
                    redisData.setData(shop1);
                    redisData.setExpireTime(LocalDateTime.now().plusMinutes(30));
                    stringRedisTemplate.opsForValue().set(keyShop, JSONUtil.toJsonStr(redisData));
                }
                //5.6没有，缓存空字符
                stringRedisTemplate.opsForValue().set(keyShop, "", 30L, TimeUnit.MINUTES);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                unlock(lockKey);
            }
        });
        return JSONUtil.toBean((JSONObject) bean.getData(), Shop.class);
    }

复制代码

封装Redis工具类

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

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

这是1和2，比较简单，把这四个方法封装到了一个工具类里面，需要注意的是

unit.toSeconds(time)，方法把所有单位统一为秒处理。

java 复制代码

public class CacheClient {
    private StringRedisTemplate stringRedisTemplate;
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);.

    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }
    /*
    * 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
    *TimeUnit表示时间单位
    * */
    public void set(String key, Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }
    /*
    * 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
    *
    * */
    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)));
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }
}

3和4的话有必要先做一下说明

复制代码

public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit)，其中最前面那个<R,ID>是表示R,ID这是两个泛型，后面出现这两个都是代表泛型，因为你传入的id类型和最后返回的类型不确定，所以很明显需要这两个，Class<R> type表示R的字节码文件，因为在反序列化的时候要用到，而Function<ID, R> dbFallback表示传入的是一个函数，其中参数是ID类型，返回值是R类型，这里应该传入查询的一个函数，因为我们要用到，在方法内部调用函数：dbFallback.apply()即可。。

注意要求返回R，我们返回的是null，需要调用者在调用时判断结果，如果时null返回错误信息即可。

java 复制代码

    /*
    * 根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
    * */
    public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
        String key = keyPrefix + id;
        String value = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(value)) {
            return JSONUtil.toBean(value, type);
        }
        if (value != null) {
            return null;
        }
        R r = dbFallback.apply(id);
        if (r == null){
            stringRedisTemplate.opsForValue().set(key, "", time, unit);
            return null;
        }
        this.set(key, r, time, unit);
        return r;
    }

java 复制代码

public <R, ID> R queryWithLogicalExpire(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
        //1.查询redis
        String keyShop  = keyPrefix + id;
        String shop = stringRedisTemplate.opsForValue().get(keyShop);
        //2.如果是空字符串。直接返回
        if(StrUtil.isBlank(shop)){
            return null;
        }
        //3.如果不是则判断缓存是否过期
        com.hmdp.entity.RedisData bean = JSONUtil.toBean(shop, com.hmdp.entity.RedisData.class);
        LocalDateTime expireTime = bean.getExpireTime();
        R r = JSONUtil.toBean((JSONObject) bean.getData(), type);
        //4.未过期，直接返回
        if (expireTime.isAfter(LocalDateTime.now())){
            return r;
        }
        //5.缓存过期，需要缓存重建
        //5.1 获取锁
        String lockKey = "lock:shop:" + id;
        if (!tryLock(lockKey)){
            //5.2 获取锁失败，返回原来信息
            return r;
        }
        //5.3 获取成功，做二次检查
        String s = stringRedisTemplate.opsForValue().get(keyShop);
        com.hmdp.entity.RedisData bean1 = JSONUtil.toBean(s, com.hmdp.entity.RedisData.class);
        LocalDateTime expireTime1 = bean1.getExpireTime();
        R r2 = JSONUtil.toBean((JSONObject) bean1.getData(), type);
        //5.3.1查询过期时间，如果未过期，直接返回，无需重建
        if (expireTime1.isAfter(LocalDateTime.now())){
            return r2;
        }
        //5.3.2过期，开启独立线程，进行缓存重建
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            try {
                //5.4查询数据库
                R r3 = dbFallback.apply(id);
                //5.5有则写入redis，加上有效时间
                if ( r3 != null) {
                    this.setWithLogicalExpire(keyShop, r3, time, unit);
                }
                //5.6没有，缓存空字符
                this.set(keyShop, "", 30L, TimeUnit.MINUTES);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                unlock(lockKey);
            }
        });
        //返回旧的
        return r;
    }