黑马点评项目 P35-P47 商铺查询缓存练习

已于 2023-03-08 20:26:25 修改
阅读量338 收藏
点赞数 1
文章标签： redis 学习 spring boot Powered by 金山文档
于 2023-03-08 13:27:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Falcon__/article/details/129401268
版权

1.1 商铺查询

  1. 根据商铺ID查询

  1. 从 redis 中查询商铺,如果没有就从数据库查询然后存入 reids

/**
     * 查询单个店铺
     * @param id 店铺ID
     * @return
     */
    @Override
    public Result queryShopById(Long id) {

        // 1.从 redis 中查询
        String cacheShopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        if(StrUtil.isNotBlank(cacheShopJson)) {
            // 存在直接返回
            return Result.ok(JSONUtil.toBean(cacheShopJson,Shop.class));
        }

        // 2.缓存没有的话从数据库查询
        QueryWrapper<Shop> shopQueryWrapper = new QueryWrapper<>();
        shopQueryWrapper.eq("id",id);
        Shop shop = shopMapper.selectOne(shopQueryWrapper);

        // 3.设置到 redis 里给后面做缓存用
        stringRedisTemplate.opsForValue().
                set(RedisConstants.CACHE_SHOP_KEY + id,
                        JSONUtil.toJsonStr(shop),
                        RedisConstants.CACHE_SHOP_TTL,
                        TimeUnit.MINUTES);

        return Result.ok(shop);
    }

1.2 商铺缓存与数据库的双写一致

两种方法

  • 先更新数据库,删除缓存,写入缓存

  • 先删除缓存,更新数据库,写入缓存

我们这里选用第一种

  1. 缓存命中直接返回,如果没有命中缓存就从数据库查询然后写入缓存

  1. 都存在着线程安全的问题

  1. 更新完之后会删除缓存,后续查询的时候就会没有命中缓存,然后就去数据库查询写入缓存

/**
     * 先操作数据库在更新
     * @param shop
     * @return
     */
    @Override
    @Transactional
    public Result update(Shop shop)
    {
        Long id = shop.getId();
        if(id == null) { return Result.fail("店铺ID不能为空"); }

        // 1.更新数据库
        updateById(shop);
        // 2.删除缓存
        stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + id);
        return Result.ok();
    }
}

1.3 缓存穿透

客户端请求的数据,缓存和数据库中都不存在

方案

  • 缓存空对象

优点 : 实现简单,维护方便

缺点 : 额外的内存消耗

  • 布隆过滤器

优点 : 内存占用少,没有多余的key

缺点 : 实现复杂.可能存在误判

1.3.1 实现缓存空对象

  1. key - 前缀 + ID

  1. 第一次没有命中缓存,然后去查询数据库

  1. 数据库也没有,缓存空值到 redis

  1. 后续再次访问就会命中这个缓存空值,不会再去查询到数据库

/**
     * 查询单个店铺
     * @param id 店铺ID
     * @return
     */
    @Override
    public Result queryShopById(Long id) {

        String key = CACHE_SHOP_KEY + id;

        // 1.从 redis 中查询
        String cacheShopJson = stringRedisTemplate.opsForValue().get(key);
        /**
         * <li>{@code StrUtil.isNotBlank(null)     // false}</li>
         * <li>{@code StrUtil.isNotBlank("")       // false}</li>
         * <li>{@code StrUtil.isNotBlank(" \t\n")  // false}</li>
         * <li>{@code StrUtil.isNotBlank("abc")    // true}</li>
         */
        if(StrUtil.isNotBlank(cacheShopJson))
        {
            // 存在直接返回
            return Result.ok(JSONUtil.toBean(cacheShopJson,Shop.class));
        }

        // 上面的 isNotBlank 判断 null 是 false ,所以这里还要在判断一次
        if (cacheShopJson != null)
        {
            return Result.fail("店铺信息不存在");
        }

        // 2.缓存没有的话从数据库查询
        Shop shop = super.getById(id);

        // 缓存穿透 : 如果从数据库查询也是没有,缓存 null 值
        if (shop == null)
        {
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            return Result.fail("店铺不存在");
        }

        // 3.设置到 redis 里给后面做缓存用
        stringRedisTemplate.opsForValue().
                set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);

        return Result.ok(shop);
    }

1.4缓存雪崩

同一时间大量的key同时失效,或者redis服务器宕机,客户端大量请求到数据库

方案

  • 给不同的key添加随机时间

  • redis集群提高服务的可用性

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

1.5 缓存击穿

热点key失效了,大量的请求到达数据库

方法

  • 互斥锁

优点 : 保持一致性

缺点 : 线程等待,有死锁的风险

  • 设置逻辑过期时间

优点 : 线程无需等待

缺点 : 实现复杂,不保证一致性

1.5.1 实现互斥锁

  1. 使用SETNX命令创建锁key(lock:shop:id)作为锁的表示,这个命令标识该key不存在时才会创建

  1. 判断是否获取到锁,没有的话休眠0.05秒,然后递归(注意!return,是递归的出口)

  1. 如果获取到锁,从缓存中查询,从数据库查询

  1. 最后释放锁

/**
     * 判断是否获得锁
     * @param lockKey
     * @return
     */
    private boolean tryLock(String lockKey) {
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(lockKey,"1",10,TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 解锁
     * @param lockKey
     */
    private void unLock(String lockKey) {
        stringRedisTemplate.delete(lockKey);
    }


    /**
     * 互斥锁
     * @param id 店铺ID
     * @return
     */
    public Shop queryWithMutex(Long id) {

        String key = CACHE_SHOP_KEY + id;

        // 1.从 redis 中查询
        String cacheShopJson = stringRedisTemplate.opsForValue().get(key);
        /**
         * <li>{@code StrUtil.isNotBlank(null)     // false}</li>
         * <li>{@code StrUtil.isNotBlank("")       // false}</li>
         * <li>{@code StrUtil.isNotBlank(" \t\n")  // false}</li>
         * <li>{@code StrUtil.isNotBlank("abc")    // true}</li>
         */
        if(StrUtil.isNotBlank(cacheShopJson))
        {
            // 存在直接返回
            return JSONUtil.toBean(cacheShopJson,Shop.class);
        }

        // 上面的 isNotBlank 判断 null 是 false ,所以这里还要在判断一次
        if (cacheShopJson != null)
        {
            return null;
        }

        // 互斥锁
        String lockKey = "lock:shop:" + id;
        Shop shop = null;
        try {
            // 获取互斥锁
            boolean flag = tryLock(lockKey);
            // 判断是否获取成功
            if (!flag) {
                // 失败则休眠 0.05秒
                Thread.sleep(50);
                // 递归 记得 return !
                // return 是递归出口
                return queryWithMutex(id);
            }

            // 2.缓存没有的话从数据库查询
            shop = super.getById(id);
            // 模拟重建的延时
            Thread.sleep(200);

            // 缓存穿透 : 如果从数据库查询也是没有,缓存 null 值
            if (shop == null)
            {
                stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
                return null;
            }

            // 3.设置到 redis 里给后面做缓存用
            stringRedisTemplate.opsForValue().
                    set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 释放锁
            unLock(lockKey);
        }

        return shop;
    }

1.5.2 测试

使用jmeter压力测试高并发的情况下只查询了一次数据库

1.5.3 实现逻辑过期时间

逻辑

  1. 去redis查询,如果没有就返回null

  1. 命中就判断逻辑时间是否已经过期

  1. 已过期尝试获取互斥锁

  1. 判断是否成功获取到互斥锁

  1. 是,开启独立线程查询数据库,缓存到redis,释放互斥锁

  1. 否,返回旧数据

/**
     * 缓存逻辑过期时间
     * @param id 商铺ID
     * @param expireSeconds 过期时间
     */
    @Override
    public void saveShop2Redis(Long id, Long expireSeconds) {
        // 查询数据库
        Shop shop = super.getById(id);

        // 存入缓存
        RedisData redisData = new RedisData();
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        redisData.setData(shop);

        // 并没有添加TTL时间,所以过期时间是我们自己定义
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id, JSON.toJSONString(redisData));
    }
@Data
public class RedisData {
    // 逻辑时间
    private LocalDateTime expireTime;
    // 缓存数据
    private Object data;
}
/**
     * 逻辑过期时间
     * @param id 店铺ID
     * @return
     */
    public Shop queryWithLogicalExpire(Long id) {

        String key = CACHE_SHOP_KEY + id;

        // 从 redis 中查询
        String cacheShopJson = stringRedisTemplate.opsForValue().get(key);
        // 未命中
        if(StrUtil.isBlank(cacheShopJson)) return null;

        // 命中
        RedisData data = JSONUtil.toBean(cacheShopJson, RedisData.class);
        // 将 Object转换为 Shop
        Shop shop = JSONUtil.toBean((JSONObject) data.getData(),Shop.class);
        LocalDateTime expireTime = data.getExpireTime();
        // 判断逻辑时间是否已经过期
        if (expireTime.isAfter(LocalDateTime.now())) return shop;// 未过期直接返回

        // 已过期
        String lockKey = 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);
                }
            });
        }
        // 失败,返回过期的商铺信息
        return shop;
    }

1.5.4 测试

  1. 如果缓存里已经是过期,还没有删除

  1. 测试高并发场景在缓存重建完成之前是否得到的是旧数据

1.6 缓存工具类封装

互斥锁,设置逻辑过期时间,这种我们可以封装成一个方法,后续调用即可

  1. 缓存到 redis

  1. 设置逻辑过期时间

  1. 缓存穿透 (返回 null 对象)

  1. 缓存击穿 (设置逻辑过期时间,缓存重建,互斥锁)

1.6.1 缓存到 reids

/**
     * 存入 redis
     * @param key
     * @param value
     * @param time
     * @param unit
     */
    public void set(String key, Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }

1.6.2 缓存逻辑过期时间

/**
     * 设置逻辑过期
     * @param key
     * @param value
     * @param time
     * @param unit
     */
    public void setWithLogicExpire(String key, Object value, Long time, TimeUnit unit){
        RedisData data = new RedisData();
        // 设置逻辑过期时间
        data.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        data.setData(value);

        // 存入 redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(data));
    }

1.6.3 缓存穿透 (缓存空对象)

/**
     * 缓存穿透
     * @param keyPrefix key
     * @param id 实体类ID
     * @param type 返回的实体类类型
     * @param dbFallback 具体的调用哪个类的凡是规范
     * @param <R> 实体类
     * @param <ID> 什么类型的ID,可能是Long,可能是Integer
     * @return
     */
    public <R,ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,Long time, TimeUnit unit)
    {
        String key = keyPrefix + id;

        // 从 redis 中查询
        String cacheShopJson = stringRedisTemplate.opsForValue().get(key);
        if(StrUtil.isNotBlank(cacheShopJson)) return JSONUtil.toBean(cacheShopJson, type);// 存在直接返回// 存在直接返回
        if (cacheShopJson != null) return null; // 上面的 isNotBlank 判断 null 是 false ,所以这里还要在判断一次

        // 缓存没有的话从数据库查询,根据传递进来的类型来查询,因为你不知道调用什么接口的getByID()
        R r = dbFallback.apply(id);

        // 缓存穿透 : 如果从数据库查询也是没有,缓存 null 值
        if (r == null)
        {
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            return null;
        }

        // 设置到 redis 里给后面做缓存用
        this.set(key,r,time,unit);
        return r;
    }

1.6.4 缓存击穿 (互斥锁,缓存重建,设置逻辑过期时间)

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

    /**
     * 逻辑过期时间
     * @param id 店铺ID
     * @return
     */
    public <R,ID> R queryWithLogicalExpire(
            String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback, Long time, TimeUnit unit)
    {
        String key = keyPrefix + id;

        // 从 redis 中查询
        String cacheShopJson = stringRedisTemplate.opsForValue().get(key);
        // 未命中
        if(StrUtil.isBlank(cacheShopJson)) return null;

        // 命中
        RedisData data = JSONUtil.toBean(cacheShopJson, RedisData.class);
        // 将 Object转换为 Shop
        R r = JSONUtil.toBean((JSONObject) data.getData(),type);
        LocalDateTime expireTime = data.getExpireTime();
        // 判断逻辑时间是否已经过期
        if (expireTime.isAfter(LocalDateTime.now())) return r;// 未过期直接返回

        // 已过期
        String lockKey = LOCK_SHOP_KEY + id;
        // 获取互斥锁
        boolean isLock = tryLock(lockKey);

        // 判断是否获取锁
        if (isLock) {
            // 成功,创建独立线程
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 重建缓存
                    // 先查询数据库
                    R r1 = dbFallback.apply(id);
                    // 写入缓存
                    this.setWithLogicExpire(key,r1,time,unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKey);
                }
            });
        }
        // 失败,返回过期的商铺信息
        return r;
    }

    /**
     * 判断是否获得锁
     * @param lockKey
     * @return
     */
    private boolean tryLock(String lockKey) {
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(lockKey,"1",10,TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 解锁
     * @param lockKey
     */
    private void unLock(String lockKey) {
        stringRedisTemplate.delete(lockKey);
    }
南瓜战士
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1_P35-1.zip
10-10
很抱歉，根据您提供的信息，标题"1_P35-1.zip"和描述"1_P35-1.zip"并没有明确指出任何特定的IT知识点。标签为空，也无法提供额外的线索。压缩包子文件的文件名称列表看起来是一些图片文件（可能是用于教程、演示或...
p21 - p35 存储器金字塔结构
05-15
p21-p35 存储器金字塔结构 p21-p35 存储器金字塔结构是计算机系统中的一种重要组件，负责存储和管理数据。CPU Cache 是 CPU 访问内存的缓存层次结构，旨在弥补 CPU 与内存之间的性能差异。 CPU Cache 的主要组件...
【黑马点评缓存练习】
m0_55517651的博客
11-08 184
黑马点评实现商铺类型查询缓存练习
(全网最全(求挑战))黑马点评 商户查询缓存练习； “P37 实战篇-商户查询缓存-03.缓存练习题分析”的String、List、ZSet(SortedSet)、Hash四种实现方法
m0_71473660的博客
06-09 464
黑马点评 “P37 实战篇-商户查询缓存-03.缓存练习题分析”的String、List、ZSet(SortedSet)三种实现方法（实现ShopTypeList那个视频的）
黑马点评商户缓存查询作业——Redis中查询商户类型
weixin_45791946的博客
07-08 330
一共分为几个步骤要注意一下的就是查询数据库的过程用到了Mapper，记得用@Autowired自动注入一下ShopTypeMapper。
黑马点评缓存练习题shop-type缓存,附带详细解析
代码的尽头都是数学
04-09 739
黑马点评缓存练习题shop-type缓存,附带详细解析
[Redis]黑马点评-商铺类型缓存使用List（练习题）
DevanHyans的博客
05-07 206
使用List数据类型实现商铺类型缓存。
[redis]黑马点评-商铺类型缓存（练习题）
shgzzd的博客
10-27 1518
黑马点评P37集，给商铺类型业务添加缓存。可以看出缓存之后，刷新的时间变少了。
居家养老信息化解决方案P35-郑州大象通信.ppt
04-19
居家养老信息化解决方案P35-郑州大象通信.ppt
P35-LQ0LQ035Q1DG04.rar_mini2440_P35
07-15
mini2440,P35屏幕数据手册..........
居家养老信息化解决方案P35-郑州大象通信
06-29
居家养老信息化解决方案P35-郑州大象通信
redis项目——黑马点评（店铺缓存作业）
wu_jihong的博客
07-10 239
这里是关于店铺缓存中黑马老师留下的作业。这里我用了列表和哈希存储来完成。
Redis实战—黑马点评（二）缓存篇
yangsf_的博客
02-16 1018
缓存的基本使用，缓存更新策略，缓存穿透、击穿、雪崩常见解决方案，还有一些编码小技巧
黑马redis中商品查询中店铺类型进缓存课后练习实现
weixin_62365177的博客
10-24 51
【代码】黑马redis中商品查询中店铺类型进缓存课后练习实现。
【黑马店铺】shopType 黑马点评商铺类型缓存作业
m0_62090480的博客
03-25 315
【代码】【黑马店铺】shopType 黑马点评商铺类型缓存作业。
黑马Redis实战篇—给商铺类型缓存（练习）
java小豪的博客
10-28 725
黑马Redis实战篇——第37集练习题给商铺类型添加缓存。 商铺类型是list类型，较36集需要一些改动。黑马点评P37集，给商铺类型业务添加缓存。
【Redis | 黑马点评 + 思维导图】商户查询缓存以及热门生产问题解决
十八岁讨厌编程的博客
01-30 1128
本文涉及缓存概述、添加商户缓存的实现、缓存更新策略、缓存穿透问题及解决思路、缓存雪崩问题及解决思路、缓存击穿问题及解决思路、封装redis工具类等内容。
黑马点评给店铺类型查询业务添加缓存（List实现)
Blocking The Sky
06-28 254
【代码】黑马点评给店铺类型查询业务添加缓存（List实现)
LSD4WNB-6P35WGW1
最新发布
09-01
抱歉，您提到的"LSD4WNB-6P35WGW1"似乎不是一个常见的编程术语、技术概念或者广泛认知的代码片段。它可能是一个特定领域内的缩写、产品型号、项目代号或者是某种专有技术的标识。由于缺乏具体上下文，我无法给出一个准确的解释或介绍。 为了更好地帮助您，如果您能提供更多关于"LSD4WNB-6P35WGW1"的背景信息或者具体使用场景，我或许能够提供更加相关和有用的信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值