黑马点评项目-商户查询缓存

喵先森爱吃鱼

已于 2022-04-24 22:50:20 修改

阅读量1.4k

点赞数 1

分类专栏： Redis 文章标签： redis

于 2022-04-17 22:31:46 首次发布

本文链接：https://blog.csdn.net/dingd1234/article/details/124238182

版权

Redis 专栏收录该内容

19 篇文章 11 订阅

订阅专栏

一、什么是缓存

缓存就是数据交换的缓冲区，是存储数据的临时地方，一般读写性能较高。

缓存的作用：

降低后端负载。当用户进行请求时，先去查询缓存，查询到之后直接返回给用户，而不必查询数据库，大大降低了后端的压力。
提高读写效率，降低响应时间。数据库的读写是磁盘读写，其响应时间一般比较长，而 Redis 是基于内存的，读写时间快。

缓存的成本：

一致性成本。当数据库中的数据发生了改变，而缓存中的数据还是旧的数据，当用户从缓存中读取数据时，获取到的依旧是旧的数据。
代码维护成本。为了解决一致性成本，以及缓存雪崩，缓存击穿等问题，就需要非常复杂的业务编码。
运维成本。缓存集群的部署维护需要额外的人力成本、硬件成本。

二、添加 Redis 缓存

2.1 分析

当我们查询商铺信息时，首先先去 Redis 中查询，如果查询到了，则直接返回商铺信息，未查询到则查询数据库，将查询到的信息先写入 Redis 中，以便下次查询时可以直接命中缓存，然后再将商铺信息返回给用户。
在这里插入图片描述

2.2 代码实现

ShopController

@RestController
@RequestMapping("/shop")
public class ShopController {

    @Resource
    public IShopService shopService;

    /**
     * 根据id查询商铺信息
     * @param id 商铺id
     * @return 商铺详情数据
     */
    @GetMapping("/{id}")
    public Result queryShopById(@PathVariable("id") Long id) {
        return shopService.queryById(id);
    }
}

IShopService

public interface IShopService extends IService<Shop> {

    Result queryById(Long id);
}

ShopServiceImpl

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        // 1、根据 Id 查询 Redis
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isNotBlank(shopJson)) {
            // 3、存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        // 4、不存在，查询数据库
        Shop shop = getById(id);

        // 5、不存在，返回错误
        if(shop == null){
            return Result.fail("店铺不存在！");
        }

        // 6、存在，写入 Redis
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop));
        // 7、返回
        return Result.ok(shop);
    }
}

三、Redis 的缓存更新策略

3.1 知识介绍

在这里插入图片描述
主动更新策略：

Cache Aside Pattern：由缓存的调用者，在更新数据库的同时更新缓存
Read/Writer Through Pattern：缓存与数据库整合为一个服务，由服务来维护一致性。调用者调用该服务，无需关心缓存一致性问题。
Writer Behind Caching Pattern：调用者只操作缓存，由其他线程异步的将缓存数据持久化到数据库，保证最终一致。

Read/Writer Through Pattern 最大的问题是目前很难找到这样的服务。
Writer Behind Caching Pattern 的效率比较高，但是一致性难以保证，当缓存数据更新，还未开始异步更新数据库，如果此时 Redis 发生宕机，就会丢失数据。
Cache Aside Pattern 尽管需要自己编码，但其可控性更高，所以一般使用该种策略来进行缓存更新。

使用 Cache Aside Pattern 策略来操作缓存和数据库时有三个问题需要考虑：

1、删除缓存还是更新缓存？

更新缓存：每次更新数据库都更新缓存，无效写操作较多。
如果我们对数据库做了上百次操作，那么就需要对缓存进行上百次操作，在进行这上百次的操作过程中，如果没有任何的查询操作，也就是写多读少，那么对于缓存的上百次操作都可以看作成是无效的操作。
删除操作：更新数据库时让缓存失效，查询时再更新缓存。（一般选择此种方案）

2、如何保证缓存与数据库的操作的同时成功或失败？

单体系统，将缓存与数据库操作放在一个事务。
分布式事务，利用 TCC 等分布式事务方案。

3、先操作缓存还是先操作数据库？

（1）先删除缓存，再操作数据库：假设有两个线程：线程1 和线程2，线程1执行更新操作，先将缓存中的数据删除，然后执行更新数据库操作，由于更新逻辑复杂，执行时间较长，此时线程2 也开始执行，线程2 执行查询操作，由于缓存中的数据被线程 1 删除了，导致查询缓存未命中，于是线程2转而去查询数据库，此时数据库并未完成更新操作，查询出的数据依旧为旧数据，接着程序就将旧数据重新写入到了缓存。这就会导致后续的所有查询操作查询到的数据依旧是旧数据。
（2）先操作数据库，再删除缓存：
情况一：假设有两个线程，线程 1 和线程 2，线程 1 执行更新操作，线程 1 先去更新数据库，然后再删除缓存，由于更新逻辑复杂，执行时间较长，此时线程2 也开始执行，线程 2 执行查询操作，由于此时数据库尚未更新完成，且缓存未被删除，线程 2 依然能从缓存中查询到旧的数据，一旦线程 1 更新数据库完成，且删除了缓存中的数据，那么其他线程再查询时就会无法命中缓存，从而去查询数据库同步缓存数据。这种情况的一个好处就是，即使线程1 未完成数据库的更新，其他线程在查询时依然能够命中缓存，哪怕是旧的缓存，也不会额外浪费时间去查询数据库。而且一旦数据库更新完成，后续的查询便都是最新的数据。
在这里插入图片描述

情况二：还有一种情况就是当线程 2 执行查询操作时，此时缓存中的数据恰好过期，然后线程 2 便会去数据库中查询，但是此时线程 1 未完成更新操作，所以数据库中还是原先的数据，线程 2 在将旧数据重新写入缓存的同时，恰巧线程 1 完成了数据库更新操作，并将缓存删除，这就导致缓存中的数据一直是旧数据。但实际上这种情况发生的概率极低，为了避免这种情况的发生，可以在写入缓存的时候设置过期时间。
在这里插入图片描述

这两种情况虽然也会存在数据不一致的情况，但在数据库更新完成后，再下一次执行查询操作时，必定查询出的是最新的数据，那么写入缓存的也就是最新数据了。

双写一致性有以下三个要求：

缓存不能读到脏数据
缓存可能会读到过期数据，但要在可容忍时间内实现最终一致
这个可容忍时间尽可能的小

总结下就是双写不一致的情况是无法彻底避免的，只能选取发生概率最小的方案。

根据这个要求，很明显，“先更新数据库，再删除缓存”这一种方案胜出。
内容取自浅析数据库与缓存的双写一致性问题

总结

缓存更新策略的最佳实践方案：
1、低一致性需求：使用 Redis 自带的内存淘汰机制
2、高一致性需求：主动更新，并以超时剔除作为兜底方案

读操作：缓存命中则直接返回，缓存未命中则查询数据库，并写入缓存，设定超时时间
写操作：先写数据库，然后再删除缓存，要确保数据库与缓存操作的原子性

3.2 代码实现

给查询商铺的缓存添加超时剔除和主动更新的策略：
修改 ShopController 中的业务逻辑，满足下面的需求：

根据 id 查询店铺时，如果缓存未命中，则查询数据库，将数据库结果写入缓存，并设置超时时间
根据 id 修改店铺时，先修改数据库，再删除缓存。

3.2.3 添加店铺过期时间

根据 id 查询店铺时，如果缓存未命中，则查询数据库，将数据库结果写入缓存，并设置超时时间

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        // 1、根据 Id 查询 Redis
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isNotBlank(shopJson)) {
            // 3、存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        // 4、不存在，查询数据库
        Shop shop = getById(id);

        // 5、不存在，返回错误
        if(shop == null){
            return Result.fail("店铺不存在！");
        }

        // 6、存在，写入 Redis
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        // 7、返回
        return Result.ok(shop);
    }
}

3.2.4 创建修改店铺的方法

ShopController

@RestController
@RequestMapping("/shop")
public class ShopController {

    @Resource
    public IShopService shopService;

    /**
     * 更新商铺信息
     * @param shop 商铺数据
     * @return 无
     */
    @PutMapping
    public Result updateShop(@RequestBody Shop shop) {
        // 写入数据库
        return shopService.update(shop);
    }
}

IShopService

public interface IShopService extends IService<Shop> {
    Result update(Shop shop);
}

ShopServiceImpl

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    @Transactional
    public Result update(Shop shop) {

        Long id = shop.getId();
        if(id == null){
            return Result.fail("店铺 id 不能为空！");
        }
        updateById(shop);
        stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + id);

        return Result.ok();
    }
}

四、缓存穿透

缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会到达数据库。
如果有恶意用户，使用大量线程并发访问这些不存在的数据，这样所有的请求都会到达数据库，数据库顶不住访问压力，就会崩掉。

常见的解决方案有两种：

缓存空对象
将数据库中不存在的数据以 null 的形式存储到缓存中。但是这种方式会增加额外的内存消耗，我们可以在缓存 null 的时候，设置过期时间。
优点：实现简单，维护方便
缺点：①额外的内存消耗 ②可能造成短期的不一致。
布隆过滤（一种算法）
在客户端与 Redis 之间增加一层过滤，当用户请求来的时候，先去访问布隆过滤器，判断请求的数据是否存在，如果不存在则拒绝请求，如果存在，则放行。
优点：内存占用较少，没有多余的 key
缺点：①实现复杂 ②存在误判的可能

布隆过滤器判断时，如果数据不存在，就是真的不存在，如果判断数据存在，那么有可能不存在。存在一定的穿透风险。

2.2 查询店铺时增加空值缓存

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        // 1、根据 Id 查询 Redis
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isNotBlank(shopJson)) {
            // 3、存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }

        // 增加对空字符串的判断
        if(shopJson != null){
            return Result.fail("店铺不存在！");
        }

        // 4、不存在，查询数据库
        Shop shop = getById(id);

        // 5、不存在，返回错误
        if(shop == null){
            // 店铺不存在时，缓存空值
            stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
            return Result.fail("店铺不存在！");
        }

        // 6、存在，写入 Redis
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        // 7、返回
        return Result.ok(shop);
    }
}

五、缓存雪崩

缓存雪崩是指在同一时段大量的缓存 key 同时失效或者 Redis 服务宕机，导致大量请求到达数据库，给数据库带来巨大压力。

解决方案：

给不同的 Key 的 TTL（过期时间）添加随机值
一般在做缓存预热时，可能会提前将数据库中的数据批量导入到缓存中，由于是批量导入的，所以这些 key 的 TTL 是一样的，这就很有可能导致这些 key 在未来的某一时刻一起过期，从而引发缓存雪崩问题。为了解决这个问题，我们可以在做缓存预热时，可以在设置 TTL 时，在 TTL 后面追加一个随机数，比如 TTL 设置的 30 分钟，我们在30 的基础上加上一个 1~5之间的随机数，那么这些 key 的过期时间就会在 30 ~ 35 之间，这样就可以将 key 的过期时间分散开来，而不是一起失效。
利用 Redis 集群提高服务的可用性
利用 Redis 的哨兵机制，Redis 哨兵机制可以实现服务的监控，比如在一个主从模式下的 Redis 集群，当主机宕机时，哨兵就会从从机中选出一个来替代主机，这样就可以确保 Redis 一直对外提供服务。另外，主从模式还可以实现数据的同步，当主机宕机，从机上的数据也不会丢失。
给缓存业务添加降级限流策略
给业务添加多级缓存
可以先在反向代理服务器 Nginx 中做缓存，在 Nginx 中未命中缓存时，再去 Redis 中查询。

六、缓存击穿

6.1 知识介绍

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

常见的解决方案：

互斥锁
假设线程 1 查询缓存未命中，那么线程 1 就需要进行缓存重建工作，为了避免其他线程重复线程1 的工作，那么线程 1 就必须要先获取互斥锁，只有获取锁成功的线程才能够重建缓存数据。重建完成后，线程 1 就会将数据写入到缓存中，并将锁释放。如果在线程 1 将数据写入缓存之前，其他线程涌入，这个时候，其他线程查询缓存依然是未命中的，那么这些线程为了重建缓存，也必须先获取到互斥锁，但是，由于此时线程 1 未释放锁，所以其他线程就会获取锁失败，一旦获取锁失败，一般程序处理是让线程休眠一会儿，然后再重试（包括查询缓存以及获取互斥锁），如果线程 1 执行缓存重建时间过长，就会导致其他线程一直处于阻塞等待重试的状态，效率过低。
逻辑过期
当我们在向 Redis 中存储数据时，不再为 key 设置过期时间（TTL），但是，需要在 value 中额外添加一个逻辑时间（以当前时间为基础，加上需要设置的过期时间），也就是说，这个 key 一旦存入到 Redis 中，就会永不过期。假设线程 1 在查询缓存时发现逻辑时间已经过期，为了避免出现多个线程重建缓存，线程 1 就会去获取互斥锁，一旦线程 1 获取互斥锁成功，线程 1 就会开启一个独立线程，由独立线程去查询数据库重建缓存数据，以及写入缓存重置逻辑过期时间等操作，一旦完成操作，独立线程就会将互斥锁释放掉。线程 1 在开启独立线程后，会直接将过期数据返回。而在独立线程释放锁之前，缓存中的数据都是过期数据。当其他线程在此之前涌入程序时，去查询缓存获取到依旧是逻辑时间过期的数据，那么这些线程就会试图获取互斥锁，此时由于独立线程还未释放锁，所以会获取锁失败，一旦失败，这些线程就会将查询到的旧数据返回。只有当独立线程执行结束，其他线程才会从缓存中获取到新数据。

两种方案对比：
在这里插入图片描述

6.2 案例分析

6.2.1 基于互斥锁方式解决缓存击穿问题

6.2.1.1 需求分析

需求：修改根据 id 查询商铺的业务，基于互斥锁方式来解决缓存击穿问题。业务流程如下：
在这里插入图片描述
我们使用 SETNX 命令来实现互斥锁。
SETNX 只有在 key 不存在的时候才能存储成功，并且返回；如果 Redis 中存在要设置的 key，则存储不成功，并且返回 0。

当有多个线程同时获取互斥锁时，根据 SETNX 的特性，那么只会有其中一个线程 SETNX 成功，其他线程在 SETNX 时，只能返回 0，而释放锁也很简单，只需要删除 key 即可。但是，这种方案会存在一个问题，当线程获取到互斥锁后，由于程序出现问题，导致锁迟迟无法释放，所以我们在获取互斥锁时，即在执行 SETNX 命令时，往往会添加上一个有效期，一般有效期时长会是业务程序执行时间10~20倍，避免异常情况。

6.2.1.2 代码实现

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        // 解决缓存穿透
//        Shop shop = queryWithPassThrough(id);

        // 互斥锁解决缓存击穿
        Shop shop = queryWithMetux(id);

        if(shop == null){
            return Result.fail("店铺不存在！");
        }

        // 7、返回
        return Result.ok(shop);
    }

    /**
     * 解决缓存击穿问题
     * */
    public Shop queryWithMetux(Long id){
        // 1、根据 Id 查询 Redis
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isNotBlank(shopJson)) {
            // 3、存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }

        // 增加对空字符串的判断
        if(shopJson != null){
            return null;
        }

        // 获取互斥锁
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        Shop shop = null;
        try {
        	// 获取互斥锁
            boolean isLock = tryLock(lockKey);
            // 如果获取失败，则重新获取
            if (!isLock) {
                Thread.sleep(30);
                return queryWithMetux(id);
            }

            // 4、不存在，查询数据库
            shop = getById(id);

            // 5、不存在，返回错误
            if (shop == null) {
                // 店铺不存在时，缓存空值
                stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }

            // 6、存在，写入 Redis
            stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        }catch (InterruptedException e){
            throw new RuntimeException(e);
        } finally {
            // 释放互斥锁
            unLock(lockKey);
        }

        return shop;
    }

    /**
     * 解决缓存穿透
     * */
    public Shop queryWithPassThrough(Long id){
        // 1、根据 Id 查询 Redis
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isNotBlank(shopJson)) {
            // 3、存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }

        // 增加对空字符串的判断
        if(shopJson != null){
            return null;
        }

        // 4、不存在，查询数据库
        Shop shop = getById(id);

        // 5、不存在，返回错误
        if(shop == null){
            // 店铺不存在时，缓存空值
            stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }

        // 6、存在，写入 Redis
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return shop;
    }

    // 获取锁
    private boolean tryLock(String key){
        Boolean isTrue = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", RedisConstants.LOCK_SHOP_TTL, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(isTrue);
    }

    // 释放锁
    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }

    @Override
    @Transactional
    public Result update(Shop shop) {

        Long id = shop.getId();
        if(id == null){
            return Result.fail("店铺 id 不能为空！");
        }
        updateById(shop);
        stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + id);

        return Result.ok();
    }
}

6.2.1.3 测试

使用 Jmeter 进行并发测试，Jmeter 安装教程可以参考：MAC系统下jmeter安装教程

6.2.2 基于逻辑过期方式解决缓存击穿问题

6.2.2.1 需求分析

需求：修改根据id查询商铺的业务，基于逻辑过期方式来解决缓存击穿问题

理论上来讲，一旦热点 key 添加 Redis 中，key 就不会过期，就会永久存在，只有活动结束才会将热点 key 从缓存中删除。一般而言，热点 key 通常是参加活动的商品或者其他一些东西，这些数据会提前加入缓存，并设置逻辑过期时间，所以说，这些热点 key 理论上是一直存在的，直至活动结束删除。因此，当我们查询热点 key 时不用判断有没有命中，如果说缓存未命中，说明这个商品不在活动当中，不属于热点 key。
综上，在程序设计时，针对热点 key 可以不用进行缓存穿透的处理。

流程分析：
在这里插入图片描述

6.2.2.2 代码实现

创建 RedisData，用于保存热点店铺以及设置过期时间，当然也可以使用继承方式。

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

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    @Override
    public Result queryById(Long id) {
        // 解决缓存穿透
//        Shop shop = queryWithPassThrough(id);

        // 互斥锁解决缓存击穿
//        Shop shop = queryWithMetux(id);
        Shop shop = queryWithLogicalExpire(id);

        if(shop == null){
            return Result.fail("店铺不存在！");
        }

        // 7、返回
        return Result.ok(shop);
    }

    public Shop queryWithLogicalExpire(Long id){
        // 1、根据 Id 查询 Redis
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isBlank(shopJson)) {
            // 3、存在，直接返回
            return null;
        }

        // 命中，需要先把 json 反序列化为对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);

        // 判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())){
            return shop;
        }

        // 已过期，需要缓存重建
        // 获取互斥锁
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;

        boolean isLock = tryLock(lockKey);
        if (isLock) {
            // 开辟独立线程
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                    try {
                        // 缓存重建
                        this.saveShop2Redis(id, 20L);
                    }catch (Exception e) {
                        throw new RuntimeException(e);
                    } finally {
                        unLock(lockKey);
                    }
            });
        }

        // 6、存在，写入 Redis
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);

        return shop;
    }

    /**
     * 解决缓存击穿问题
     * */
    public Shop queryWithMetux(Long id){
        // 1、根据 Id 查询 Redis
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isNotBlank(shopJson)) {
            // 3、存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }

        // 增加对空字符串的判断
        if(shopJson != null){
            return null;
        }

        // 获取互斥锁
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockKey);
            if (!isLock) {
                Thread.sleep(30);
                return queryWithMetux(id);
            }


            // 4、不存在，查询数据库
            shop = getById(id);

            // 5、不存在，返回错误
            if (shop == null) {
                // 店铺不存在时，缓存空值
                stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }

            // 6、存在，写入 Redis
            stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        }catch (InterruptedException e){
            throw new RuntimeException(e);
        } finally {
            // 释放互斥锁
            unLock(lockKey);
        }

        return shop;
    }

    /**
     * 解决缓存穿透
     * */
    public Shop queryWithPassThrough(Long id){
        // 1、根据 Id 查询 Redis
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isNotBlank(shopJson)) {
            // 3、存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }

        // 增加对空字符串的判断
        if(shopJson != null){
            return null;
        }

        // 4、不存在，查询数据库
        Shop shop = getById(id);

        // 5、不存在，返回错误
        if(shop == null){
            // 店铺不存在时，缓存空值
            stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }

        // 6、存在，写入 Redis
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return shop;
    }

    // 获取锁
    private boolean tryLock(String key){
        Boolean isTrue = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", RedisConstants.LOCK_SHOP_TTL, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(isTrue);
    }

    // 释放锁
    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }

    public void saveShop2Redis(Long id, Long expireSeconds) throws InterruptedException {
        // 查询数据库
        Shop shop = getById(id);
        Thread.sleep(200);
        // 封装缓存过期时间
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY, JSONUtil.toJsonStr(redisData));
    }

    @Override
    @Transactional
    public Result update(Shop shop) {

        Long id = shop.getId();
        if(id == null){
            return Result.fail("店铺 id 不能为空！");
        }
        updateById(shop);
        stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + id);

        return Result.ok();
    }
}

6.3 Redis 工具类

@Slf4j
@Component
public class CacheClient {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);


    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    /**
     * 向缓存中添加 key
     * */
    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)));
        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;
        // 1、根据 Id 查询 Redis
        String json = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isNotBlank(json)) {
            // 3、存在，直接返回
            R r = JSONUtil.toBean(json, type);
            return r;
        }

        // 增加对空字符串的判断
        if(json != null){
            return null;
        }

        // 4、不存在，查询数据库
        R r = dbFallback.apply(id);

        // 5、不存在，返回错误
        if(r == null){
            // 店铺不存在时，缓存空值
            stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }

        // 6、存在，写入 Redis
        this.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、根据 Id 查询 Redis
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isBlank(json)) {
            // 3、存在，直接返回
            return null;
        }

        // 命中，需要先把 json 反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);

        // 判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())){
            return r;
        }

        // 已过期，需要缓存重建
        // 获取互斥锁
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;

        boolean isLock = tryLock(lockKey);
        if (isLock) {
            // 开辟独立线程
            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);
                }
            });
        }

        // 6、存在，写入 Redis
        this.set(key, r, time, unit);
        return r;
    }



    // 获取锁
    private boolean tryLock(String key){
        Boolean isTrue = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", RedisConstants.LOCK_SHOP_TTL, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(isTrue);
    }

    // 释放锁
    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }


}

ShopServiceImpl

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private CacheClient cacheClient;

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    @Override
    public Result queryById(Long id) {
        // 解决缓存穿透
//        Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, this::getById, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);

        // 互斥锁解决缓存击穿
//        Shop shop = queryWithMetux(id);

        // 使用逻辑过期时间解决缓存击穿问题
//        Shop shop = queryWithLogicalExpire(id);
        Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);

        if(shop == null){
            return Result.fail("店铺不存在！");
        }

        // 7、返回
        return Result.ok(shop);
    }

    public Shop queryWithLogicalExpire(Long id){
        // 1、根据 Id 查询 Redis
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 2、判断 shopJSON 是否为空
        if (StrUtil.isBlank(shopJson)) {
            // 3、存在，直接返回
            return null;
        }

        // 命中，需要先把 json 反序列化为对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);

        // 判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())){
            return shop;
        }

        // 已过期，需要缓存重建
        // 获取互斥锁
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;

        boolean isLock = tryLock(lockKey);
        if (isLock) {
            // 开辟独立线程
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                    try {
                        // 缓存重建
                        this.saveShop2Redis(id, 20L);
                    }catch (Exception e) {
                        throw new RuntimeException(e);
                    } finally {
                        unLock(lockKey);
                    }
            });
        }

        // 6、存在，写入 Redis
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);

        return shop;
    }

}

喵先森爱吃鱼

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
黑马点评项目-商户查询缓存

一、什么是缓存缓存就是数据交换的缓冲区，是存储数据的临时地方，一般读写性能较高。缓存的作用：降低后端负载。当用户进行请求时，先去查询缓存，查询到之后直接返回给用户，而不必查询数据库，大大降低了后端的压力。提高读写效率，降低响应时间。数据库的读写是磁盘读写，其响应时间一般比较长，而 Redis 是基于内存的，读写时间快。缓存的成本：一致性成本。当数据库中的数据发生了改变，而缓存中的数据还是旧的数据，当用户从缓存中读取数据时，获取到的依旧是旧的数据。代码维护成本。为了解决一致性成本，以及缓存
复制链接

扫一扫