黑马redis实战-商户查询缓存

最新推荐文章于 2023-11-02 14:34:32 发布
最新推荐文章于 2023-11-02 14:34:32 发布
阅读量673 收藏 4
点赞数 1
分类专栏： 项目 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43156556/article/details/124085866
版权

商户查询缓存

本文的主题是商铺缓存。主要包括：添加商铺缓存到 redis，实现缓存和数据库的一致，
redis 缓存面临的三个问题的解决：缓存穿透，缓存雪崩，缓存击穿

实现效果：
在这里插入图片描述

1. 添加商户缓存

需求分析：根据 id 查询商铺，若 redis 中有商铺缓存，直接返回。否则查询数据库并将商铺信息缓存到 redis 中

代码实现：
① Controller 层，获取url中的请求参数 “id”

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

② redis 查询缓存，若缓存未命中，查询数据库，并保存到 redis 中

\\ ShopServiceImpl.java
@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        String key = CACHE_SHOP_KEY + id;
        // 1.从 redis 查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
            // 3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        // 4.不存在，根据id查询数据库
        Shop shop = getById(id);
        // 5.不存在，返回错误
        if(shop == null){
            return Result.fail("店铺不存在！");
        }
        // 6.存在，写入 redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));
        // 7.返回
        return Result.ok(shop);
    }
}

问题记录：前端商铺显示 NaN
① return Result.ok() ，里面没有返回 shop

② redis 中有缓存记录，但是给店铺添加了过期时间，然后缓存没有清理掉，所以过期不显示。删除缓存刷新即可

2. 缓存与数据库双写一致

缓存更新策略：
① 内存淘汰：一致性差，利用 redis 的内存淘汰机制，当内存不足时自动淘汰部分数据，下次查询时更新缓存

② 超时剔除：给缓存数据添加 TTL 时间，到期后自动删除缓存，下次查询时更新缓存

③ 主动更新：编写业务逻辑，在修改数据库的同时，更新缓存

采用主动更新方式：修改数据库并更新缓存

问题：先修改数据库再更新缓存，还是先更新缓存再修改数据库？
在这里插入图片描述
根据上面添加商铺缓存的逻辑，若线程查询redis 缓存未命中，即执行 查询数据库并写入 redis 缓存的逻辑

方案一：线程1删除缓存之后，导致缓存失效. 由于操作数据库是涉及IO，不如redis直接操作内存，因此大概率情况下线程1在更新数据库期间会有线程查询缓存. 可以看到，线程2在线程1更新数据库的时候，查询缓存并拿到了数据库中的快照版本，并将过期的值写入缓存。最后的结果是 redis 中 a = 10，而 mysql 中 a = 20，缓存和数据库不一致

方案二：线程1 先更新数据库再删除缓存，之后线程2由于缓存未命中，查询到数据库中更新的值并写入缓存. 结果上，数据库和缓存数据库一致

问题：更新数据库和删除缓存之间有线程请求业务呢？
在这里插入图片描述
线程取到过期缓存：在线程 1 更新数据库还未来得及删除缓存前，线程2查询缓存，由于缓存还未删除，线程2拿到旧数据。但之后的线程由于缓存未命中，会查询数据库并更新缓存

多线程操作数据库：这种情况也会发生缓存和数据库不一致。接着左侧线程3缓存未命中去查询数据库的情况，这时有线程更新数据库，则会出现对缓存更新丢失的情况.即线程1 写入缓存的操作覆盖了线程2 写入缓存的操作。这种情况发生的前提是：更新数据库和删除缓存之间有线程查询缓存导致缓存被删除【即左图】，其次是 查询数据库和写入缓存之前有线程查询数据库并写入了缓存。这种情况会发生但是因为有条件限制，所以概率较低

综合来看，方案二虽然也会发生缓存过期以及缓存与数据库不一致的情况，但是出错概率要小一点

因此选择：先更新数据库，再删除缓存

更新方式：利用 postman 修改店铺信息并发送给服务器
在这里插入图片描述
代码实现:

// ShopController.java
/**
 * 更新商铺信息
 * @param shop 商铺数据
 * @return 无
 */
@PutMapping
public Result updateShop(@RequestBody Shop shop) {
    // 写入数据库
    return shopService.update(shop);
}
// ShopServiceImpl.java
@Override
@Transactional
public Result update(Shop shop) {
    Long id = shop.getId();
    if(id == null){
        return Result.fail("店铺id不能为空");
    }
    // 1. 更新数据库
    updateById(shop);
    // 2. 删除缓存
    stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
    return Result.ok();
}

3. 缓存穿透

缓存穿透：客户端请求的数据在缓存中和数据库中都不存在，每次查询数据库都不会写入缓存，缓存无法生效

解决方案：
① 缓存空对象：查询数据库不存在，写入缓存时写入null

② redis + 布隆过滤器：不存在则直接拒绝，不再查询缓存及数据库

缓存空对象解决缓存穿透：查询数据库不存在，在redis 中写入 null；查询 redis 为 null，返回错误信息

@Override
public Result queryById(Long id) {
    String key = CACHE_SHOP_KEY + id;
    // 1.从 redis 查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 2.判断是否存在
    if(StrUtil.isNotBlank(shopJson)){
        // 3.存在，直接返回
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }
    // ② 判断命中的是否是空值
    if(shopJson != null){
        // 返回一个错误信息
        return Result.fail("店铺信息不存在!");
    }
    // 4.不存在，根据id查询数据库
    Shop shop = getById(id);
    // 5.不存在，返回错误
    if(shop == null){
        //① 将空值写入 redis
        stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
        //返回错误信息
        return Result.fail("店铺不存在！");
    }
    // 6.存在，写入 redis
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);

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

4. 缓存雪崩

缓存雪崩：同一时段大量缓存 key 同时失效或 Redis 服务宕机，导致大量请求到达数据库

解决方案：

① 给不同的 key 的TTL 添加随机值

② 利用 Redis 集群提高服务可用性

③ 给缓存业务添加降级限流策略

④ 给业务添加多级缓存

5. 缓存击穿

缓存击穿：热点 key 被高并发访问且缓存重建业务较复杂的 key 失效

解决方案：

① 互斥锁：加锁保证只有一个线程执行 缓存重建，未获取互斥锁的线程休眠重试直到缓存命中

② 逻辑过期：不设置TTL而是设置逻辑过期时间，保证国歌线程可读取旧值，也会因逻辑过期执行缓存重建。只有获取互斥锁的线程执行缓存重建，未获取互斥锁的线程返回旧数据

5.1 互斥锁解决缓存击穿

① 缓存未命中的情况下，才执行缓存重建

② 互斥锁实现缓存重建的逻辑

  1. 获取锁

  2. 缓存重建：查询数据库，若存在则写到缓存

  3. 释放锁

@Override
public Result queryById(Long id) {
    // 互斥锁解决缓存击穿
    Shop shop = queryWithMutex(id);
    if(shop == null){
        return Result.fail("店铺不存在！");
    }
    return Result.ok(shop);
}
// 缓存击穿
public Shop queryWithMutex(Long id){
    String key = CACHE_SHOP_KEY + id;
    // 1.从 redis 查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 2.判断是否存在
    if(StrUtil.isNotBlank(shopJson)){
        // 3.存在，直接返回
        return JSONUtil.toBean(shopJson, Shop.class);
    }
    // 判断命中的是否是空值
    if(shopJson != null){
        // 返回一个错误信息
        return null;
    }
    // 4.未命中，实现缓存重建
    // 4.1. 获取互斥锁
    String lockKey = LOCK_SHOP_KEY + id;
    Shop shop = null;// 这里是代码被放到 try-catch后自动添加的
    try {
        boolean isLock = tryLock(lockKey);
        // 4.2. 判断是否获取成功
        if(!isLock){
            // 4.3. 失败则休眠并重试
            Thread.sleep(50);
            return queryWithMutex(id);
        }
        // 4.4. 成功获取互斥锁则根据id查询数据库执行缓存重建
        shop = getById(id);
        // 模拟重建延时
        Thread.sleep(200);
        // 5.不存在，返回错误
        if(shop == null){
            //将空值写入 redis
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            //返回错误信息
            return null;
        }
        // 6.存在，写入 redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        // 7.释放互斥锁
        unlock(lockKey);
    }
    // 8. 返回
    return shop;
}
private boolean tryLock(String key){
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.MINUTES);
    return BooleanUtil.isTrue(flag);
}

private void unlock(String key){
    stringRedisTemplate.delete(key);
}
5.2 逻辑过期时间解决缓存击穿

问题：如何设置逻辑过期时间？

① 定义 RedisData 类使用聚合的方式封装原有信息为 data 属性，并添加 expireTime 作为逻辑过期时间

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

② 缓存重建时获取当前时间设置 expireTime ，并将 RedisData 保存到 redis 中

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.写入Redis
    stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
}

逻辑过期解决缓存击穿的思路：

  1. 从redis中获取 redisData 对象，从而获取逻辑过期时间

  2. 将获取的逻辑过期时间与当前时间比较，未过期直接返回

  3. 已过期则执行缓存重建

  4. 获取互斥锁进行缓存重建 tryLock()

  5. 获取到互斥锁的线程开启独立线程，实现缓存重建

利用上面创建的线程池进行缓存重建

  1. 重建缓存 saveShop2Redis()

  2. 释放锁

问题：获取到互斥锁的线程如何实现实现缓存重建？

① 创建线程池用于开启独立线程重建缓存

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

② 使用 executor.submit() 异步执行缓存重建任务

if (isLock) {
    // 6.3 获取锁成功，开启独立线程，实现缓存重建
    CACHE_REBUILD_EXECUTOR.submit(()->{
        try {
            // 重建缓存
            this.saveShop2Redis(id, 20L);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        // 释放锁
        unlock(lockKey);
    });
}

完整代码

@Override
public Result queryById(Long id) {
    // 逻辑过期解决缓存击穿
    Shop shop = queryWithLogicalExpire(id);
    if(shop == null){
        return Result.fail("店铺不存在！");
    }
    return Result.ok(shop);
}
// 缓存击穿
// ② 使用逻辑过期时间的方式解决缓存击穿

private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public Shop queryWithLogicalExpire(Long id){
    String key = CACHE_SHOP_KEY + id;
    // 1.从 redis 查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    // 2.判断是否存在
    if(StrUtil.isBlank(shopJson)){
        // 3.不存在，返回空
        return null;
    }
    // 4.命中，先把json反序列化为对象
    RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
    Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();

    // 5.判断是否过期
    if(expireTime.isAfter(LocalDateTime.now())){
        // 5.1 未过期，直接返回店铺信息
        return shop;
    }
    // 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 {
                // 重建缓存
                this.saveShop2Redis(id, 20L);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            // 释放锁
            unlock(lockKey);
        });
    }
    return shop;
}
private boolean tryLock(String key){
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.MINUTES);
    return BooleanUtil.isTrue(flag);
}

private void unlock(String key){
    stringRedisTemplate.delete(key);
}
执霜
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马redis小作业：给店铺类型查询业务添加缓存
ZZDT099的博客
02-17 288
黑马redis小作业：给店铺类型查询业务添加缓存
黑马点评-商户查询缓存
weixin_57393590的博客
10-11 449
redis缓存
【小项目】Spring boot基于Redis缓存商城分类，商品信息（含源码下载）
不羁鱼|Karle
10-13 6961
商品分类：数据唯一，且一次性全部拿取，使用Set（集合）进行缓存 商品列表：数据具备排序支持，使用SortedSet（有序集合）进行缓存 商品详情：准确定位获取数据信息，使用Hash（哈希表）进行缓存
黑马Redis-实战篇（黑马点评）
十二间记，知不足而奋斗，望远山而前行。千里不辞行路远，时光早晚到天涯。
04-01 1022
Redis实战篇--黑马点评项目
黑马程序员redis详细笔记（基础篇、实战篇）
weixin_50523986的博客
08-16 1817
RedisTemplate可以接收任意Object作为值写入Redis：只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的：可读性差、内存占用较大可以自定义RedisTemplate的序列化方式，代码如下：// redis配置类@Bean// 1 创建RedisTemplate对象// 2 设置连接工厂// 3 创建JSON序列化工具// 4.1 设置Key的序列化 key和hashkey采用String序列化。
黑马Redis基础篇笔记
温涛的博客
04-06 1537
nosql与sql区别、Redis的初识、Redis安装、Redis图像化界面安装、Redis常用命令、Redis常见数据结构、Jedis客户端、SpringDataRedis客户端、RedisTemplate、自定义序列化方式、StringRedisTemplate
redis实战-redis-action.zip
最新发布
11-07
在"redis实战-redis-action.zip"这个压缩包中，很可能是包含了一个关于Redis实际应用的项目或教程，名为"redis-action-master"。在这个项目中，我们可以学习到关于Redis的多个核心概念和操作，以及如何在实际开发中...
redis分布式缓存实战-redis事务
02-24
　redis事务没有隔离级别的概念：队列中的命令没有提交之前都不会实际的被执行，因为事务提交前任何指令都不会被实际执行，也就不存在“事务内的查询看到事务里的更新，在事务外查询不能看到”。　redis事务不保证...
redis 分布式缓存实战-redis 事务
01-26
redis 事务单独的隔离操作：事务中的所有命令都会序列化、按顺序执行。事务在执行过程中，不会被其他客户端发送过来的命令请求所打断。
redis 实战-redis-in-action.zip
11-07
《Redis实战：Redis in Action》是一本深入探讨Redis这一高性能键值存储系统的书籍。Redis以其卓越的速度、灵活性和丰富的数据结构而备受青睐，广泛应用于缓存、消息队列、数据库等多个场景。通过这本书，读者可以...
redis实战-redisLearn.zip
11-07
1. 缓存：利用其高速读写性能，可以缓存数据库查询结果，减轻数据库压力。 2. 消息队列：通过发布/订阅模型或列表，实现消息传递。 3. 排行榜：有序集合的特性使得构建排行榜变得简单。 4. 计数器：例如统计网站访问...
黑马---Redis实战篇
qq_52714234的博客
11-19 961
redis
黑马---Redis入门到实战【实战篇】
Father_Of_Soft的博客
05-08 1654
黑马程序员Redis项目实战---实战篇，体验真实场景应用Redis~
黑马点评作业P37_店铺类型查询业务添加缓存
m0_73865631的博客
11-02 472
首先是ShopTypeController。然后service层添加方法。
黑马点评【Redis】
weixin_52487106的博客
02-19 464
简单记录一下黑马点评
黑马Redis学习笔记 (基础篇+实战篇)
热门推荐
weixin_51515308的博客
11-24 1万+
传统关系型数据库能满足事务ACID的原则 ，而非关系型数据库往往不支持事务，或者不能严格保证ACID的特性，只能实现基本的一致性。特征：键值（key-value）型，value支持多种不同数据结构，功能丰富单线程，每个命令具备原子性低延迟，速度快（基于内存、IO多路复用、良好的编码）。支持数据持久化(定期将内存搬运到磁盘)支持主从集群、分片集群（数据拆分）支持多语言客户端Redis的官方网站地址：RedisRedis RedisRedis是基于C编写，所以需要先安装Redis所需的gcc依赖 如果有了就跳过
【黑马程序员】Redis 课程 P37 的练习_三种方式实现功能_【黑马点评项目】给店铺类型查询业务添加缓存
做笔记，记录学习中遇到的问题。
11-11 2194
记录学习时刻。三种方式（String、List、ZSet）实现【黑马程序员】于 2022-2-28 的Redis 课程 P37 的练习，即实现【黑马点评项目】中给店铺类型查询业务添加缓存的功能。（其实就是熟悉一下 SpringDataRedis）
黑马redis实战篇-商铺缓存
温涛的博客
04-25 893
黑马redis实战篇-商铺缓存笔记，包含有jmeter下载
黑马Redis笔记高级篇 | 分布式缓存
2301_77450803的博客
05-11 1349
RDB全称Redis Database Backup file（Redis数据备份文件），也被叫做Redis数据快照。简单来说就是把内存中的所有数据都记录到磁盘中。当Redis实例故障重启后，从磁盘读取快照文件，恢复数据。快照文件称为RDB文件，默认是保存在当前运行目录Redis停机时会执行一次RDB。（save命令由Redis主进程来执行RDB，会阻塞所有命令；bgsave命令则开启子进程执行RDB，是异步的，避免主进程受到影响）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值