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

最新推荐文章于 2024-10-10 13:55:01 发布
最新推荐文章于 2024-10-10 13:55:01 发布
阅读量828 收藏 19
点赞数 8
文章标签： 缓存 java redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74240566/article/details/142500886
版权

一、添加商户缓存

/**
     * 根据id查询商铺信息
     * @param id
     * @return
     */
    public Result queryById(Long id) {
        String key = RedisConstants.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); //将json转为对象
            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);
    }

二、缓存更新策略

 三、主动更新策略

    缓存更新的最佳实践方案：采取主动更新，先操作数据库，再删除缓存

 实例：更新商铺信息

/**
     * 更新商铺信息
     * @param shop
     * @return
     */
    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();
    }

 四、缓存穿透的解决思路

缓存穿透概念

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

常见解决方案

缓存空对象：优点：实现简单 缺点：额外的内存消耗、可能造成短期的不一致

布隆过滤（布隆过滤器）：在客户端和Redis中添加一个布隆过滤器，如果存在数据，则放行到redis查询，不存在，则直接拒绝

增加id复杂性

五、编码解决商铺查询缓存穿透问题

解决商铺缓存穿透在于不让线程无限次地查询数据库，所以要在redis中存储空值

/**
     * 根据id查询商铺信息
     * @param id
     * @return
     */
    public Result queryById(Long id) {
        String key = RedisConstants.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); //将json转为对象
            return Result.ok(shop);
        }

        //判断命中的是否是空值(!!!!解决缓存穿透的精髓) 关键点1
        if (shopJson != null){
            //返回错误信息
            return Result.fail("店铺信息不存在");
        }

        //4. 不存在，根据id查询数据库
        Shop shop = getById(id);
        //5. 不存在，返回错误
        if (shop == null){
            // 将空值写入redis (关键点2！！！)
            stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
            return Result.fail("店铺不存在！");
        }
        //6. 存在，写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        //7. 返回
        return Result.ok(shop);
    }

五、缓存雪崩问题及解决思路

缓存雪崩的概念

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

缓存雪崩解决方案

1.给不同的key的TTL添加随机值

2.利用Redis集群提高服务的可用性

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

4.给业务添加多级缓存

六、缓存击穿问题及解决方案

缓存击穿概念

缓存击穿（也叫热点Key问题）：一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击（无数个线程查询缓存未命中后，都会查询数据库重建缓存数据，这个过程带来巨大冲击）

常见解决方案：互斥锁、逻辑过期

互斥锁：优点：没有额外的内存消耗、数据一致性、实现简单 缺点：线程需要等待，性能受影响、可能有死锁风险

逻辑过期：优点：线程无需等待，性能较好 缺点：不保证一致性、有额外内存消耗、实现复杂

互斥锁解决缓存击穿问题

Redis模拟锁
/**
     * 获取锁
     * @param key
     * @return
     */
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10L, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }
/**
     * 释放锁
     * @param key
     */
    private void unlock(String key){
        stringRedisTemplate.delete(key);
    }
/**
     * 互斥锁解决缓存击穿
     * @param id
     * @return
     */
    public Shop queryWithMutex(Long id) {
        String key = RedisConstants.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); //将json转为对象
            return shop;
        }

        //判断命中的是否是空值(!!!!解决缓存穿透的精髓)
        if (shopJson != null){
            //返回错误信息
            return null;
        }

        //4. 实现缓存重建
        //4.1 获取互斥锁
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        Shop shop = null;
        try{
            boolean isLock = tryLock(lockKey);
            //4.2 判断是否获取成功
            if (!isLock){
                //4.3 失败，则休眠并重试
                Thread.sleep(50);
                return queryWithMutex(id);
            }
            //4.4 成功，根据id查询数据库
            shop = getById(id);
            //5. 不存在，返回错误
            if (shop == null){
                // 将空值写入redis
                stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
                return null;
            }
            //6. 存在，写入redis
            stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);

        }catch (Exception e){
            throw new RuntimeException();
        }finally {
            //7. 释放互斥锁
            unlock(lockKey);
        }
        //8. 返回
        return shop;
    }

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

/**
     * 逻辑过期解决缓存击穿
     * @param id
     * @return
     */
    public Shop queryWithLogicalExpire(Long id) {
        String key = RedisConstants.CACHE_SHOP_KEY + id;
        //1. 从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);

        //2. 判断是否存在
        if (StrUtil.isBlank(shopJson)){
            //3. 为空，直接返回null
            return null;
        }
        //4. 命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        JSONObject data = (JSONObject)redisData.getData();
        Shop shop = JSONUtil.toBean(data, Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        //5. 判断是否过期
        if (expireTime.isAfter(LocalDateTime.now())){
            //5.1 未过期，直接返回店铺信息
            return shop;
        }
        //5.2 已过期，需要缓存重建
        //6. 缓存重建
        //6.1 获取互斥锁
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        //6.2 判断是否获取锁成功
        boolean isLock = tryLock(lockKey);
        if (isLock){
            //6.3 成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() ->{
                this.saveShop2Redis(id,20L);
                //释放锁
                unlock(lockKey);
            });
        }
        //6.4 返回过期的商铺信息
        //7. 返回
        return shop;
    }
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(RedisConstants.CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(redisData));
    }

七、封装Redis工具类

 方法一、将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间

public void set(String key, Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }

方法二、将任意Java对象序列化为json存储在redis中，并且设置逻辑过期时间，用于解决缓存击穿问题

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)));
        //写入redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

方法三、根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题

/**
     * 缓存穿透代码封装
     * @param id
     * @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;
        //1. 从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);

        //2. 判断是否存在
        if (StrUtil.isNotBlank(json)){
            //3. 存在直接返回
            R r = JSONUtil.toBean(json, type); //将json转为对象
            return r;
        }

        //判断命中的是否是空值(!!!!解决缓存穿透的精髓)
        if (json != null){
            //返回错误信息
            return null;
        }

        //4. 不存在，根据id查询数据库
        R r = dbFallback.apply(id);
        //5. 不存在，返回错误
        if (r == null){
            // 将空值写入redis
            stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
            return null;
        }
        //6. 存在，写入redis
        this.set(key,r,time,unit);
        //7. 返回
        return r;
    }

方法四、根据指定key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

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

    /**
     * 逻辑过期解决缓存击穿封装
     * @param 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;
        //1. 从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);

        //2. 判断是否存在
        if (StrUtil.isBlank(json)){
            //3. 为空，直接返回null
            return null;
        }
        //4. 命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        JSONObject data = (JSONObject)redisData.getData();
        R r = JSONUtil.toBean(data, type);
        LocalDateTime expireTime = redisData.getExpireTime();
        //5. 判断是否过期
        if (expireTime.isAfter(LocalDateTime.now())){
            //5.1 未过期，直接返回信息
            return r;
        }
        //5.2 已过期，需要缓存重建
        //6. 缓存重建
        //6.1 获取互斥锁
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        //6.2 判断是否获取锁成功
        boolean isLock = tryLock(lockKey);
        if (isLock){
            //6.3 成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() ->{
                //重建缓存
                //查询数据库
                R r1 = dbFallback.apply(id);
                //写入redis
                this.setWithLogicalExpire(key,r1,time,unit);
                //释放锁
                unlock(lockKey);
            });
        }
        //6.4 返回过期的商铺信息
        //7. 返回
        return r;
    }

 

 

 

 

 

 

 

爱学习的小女孩椰椰
关注
redis-黑马点评-商户查询缓存
m0_71894372的博客
03-18 1061
Spring中bean的注入方式:在Spring框架中，注入Bean（对象）的方式有多种，以下是一些常见的方法：1. 构造器注入（Constructor Injection）：通过构造器注入依赖，可以确保在创建对象时，它所依赖的其他对象也被创建。```@Autowired```2. Setter方法注入（Setter Injection）：通过setter方法注入依赖，可以在对象创建后，再设置依赖的对象。```java。
黑马点评--商户查询缓存功能总结
qq_42194397的博客
04-11 318
黑马点评--商户查询缓存功能总结
黑马点评part2 -- 商户查询缓存
ros275229的博客
04-05 1236
黑马点评part2 -- 商户查询缓存
黑马点评-商户查询缓存
weixin_57393590的博客
10-11 551
redis缓存
黑马点评第二个模块---商户查询缓存
weixin_53050118的博客
11-13 609
线程1查询缓存未命中，查询数据库之后要写入缓存时，有一个线程2插入进来更新数据库，由于缓存本来就没有所以删除缓存也没有。缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务比较复杂的key突然失效，无数的请求访问会在瞬间给数据库带来巨大的冲击。方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题。线程1删除缓存之后要更新数据库，同时线程2查询缓存未命中，然后查询数据库，写入缓存。代码改变ShopServiceImpl。
黑马点评day02-商户查询缓存
weixin_54161951的博客
06-27 197
提高redis高可用：使用redis集群，借助redis哨兵机制**内存淘汰：**redis自动进行，当redis内存达到咱们设定的max-memery的时候，会自动触发淘汰机制，淘汰掉一些不重要的数据(可以自己设置策略方式)**超时剔除：**当我们给redis设置了过期时间ttl之后，redis会将超时的数据进行删除，方便咱们继续使用缓存**主动更新：**我们可以手动调用方法把缓存删掉，通常用于解决缓存和数据库不一致问题。
黑马点评(二)--商户查询缓存
weixin_51930617的博客
04-30 1121
从缓存中查到数据首先判断是否为空，如果为空则返回数据为空，如果不为空，判断缓存中的数据是否过期，如果没过期直接返回缓存中的数据，如果过期了则去获取锁，获取到锁，新开一个线程重建缓存，（主线程）然后返回过期的数据，如果没有获取到锁，则直接返回过期的数据。查询的时候，先从缓存中查询，如果有值直接返回，如果没有值则去数据库中查询，没有值则返回数据为空，有值则将查到的值存入redis中，并设置过期时间，最后返回查到的数据。在编写业务逻辑的时候，修改了数据库中的数据后，同时更新缓存中的数据。提前缓存好热点key吗，
黑马点评2——商户查询缓存篇
做一个善良的人，做好自己的事，如果愿意，再发一份光。
05-23 1011
redis作为缓存的使用、双写一致（缓存数据库先后顺序）、缓存击穿（返回NULL、布隆过滤解决方案）、缓存穿透（互斥锁、逻辑过期处理方案）、缓存雪崩的解决方案
【黑马点评Redis——002商户查询缓存】
qq_45467608的博客
04-22 1813
缓存是数据交换的缓冲区，是存贮数据的临时地方，一般读写性能较高。
(全网最全(求挑战))黑马点评 商户查询缓存练习； “P37 实战篇-商户查询缓存-03.缓存练习题分析”的String、List、ZSet(SortedSet)、Hash四种实现方法
m0_71473660的博客
06-09 537
黑马点评 “P37 实战篇-商户查询缓存-03.缓存练习题分析”的String、List、ZSet(SortedSet)三种实现方法（实现ShopTypeList那个视频的）
【Redis】Redis实战：黑马点评之商户查询缓存
qq_50675319的博客
09-17 1247
在原来的业务逻辑中，如果用户查询缓存未命中，会去直接查询数据库，在这种情况下，如果用户查询的是热点数据且缓存重建比较复杂，就容易出现缓存击穿问题，这里我们可以假设商铺查询就是热点数据，需要针对缓存击穿问题设计相应的解决方案 相较于原来从缓存中查询不到数据后直接查询数据库而言，现在的方案是进行查询之后，如果从缓存未命中，则进行互斥锁的获取，获取互斥锁后，判断是否获得到了锁，如果没有获得锁，则休眠，过一段时间再对上述业务逻辑进行重试，获取到锁的线程可以需要去查询数据库并将数
黑马点评：缓存商户类型shopType的List和String实现方式
2302_77582380的博客
07-30 343
【代码】黑马点评：缓存商户类型shopType的List和String实现方式。
java的Maven项目的ehcache缓存学习记录
橙-极纪元-cplvfx-JJY.Cheng
10-10 785
java的Maven项目的ehcache缓存学习记录
tp8自带的文件缓存如何配置
最新发布
m0_69254007的博客
10-10 365
用户可以根据实际需求选择合适的缓存驱动。文件缓存是默认的缓存方式，但用户可以通过修改配置文件来切换到其他缓存方式，例如Redis或Memcache‌12。文件缓存适用于单机环境下的应用，对于数据量较小且读写频率较低的应用场景，是一种简单有效的缓存方案‌12。‌ ThinkPHP6默认的缓存驱动是文件缓存，它将缓存数据存储在应用的。ThinkPHP6支持多种缓存驱动，包括文件缓存、
什么是 ARP 欺骗和缓存中毒攻击？
网络研究观
10-05 1645
为了防御 ARP 欺骗和 ARP 缓存中毒攻击，组织可以结合使用最佳实践和技术。
Caffeine+Redis两级缓存架构
qq_22772699的博客
10-07 1188
/支持springEl表达式l2TimeOut 为可以设置的二级缓存 Redis 的过期时间CacheType 是一个枚举类型的变量，表示操作缓存的类型FULL, //存取PUT, //只存DELETE //删除//创建表达式解析器//通过evaluationContext.setVariable可以在上下文中设定变量。//解析表达式//使用Expression.getValue()获取表达式的值，这里传入了Evaluation上下文。
深入理解 Spring Cache 的工作原理及集成其它第三方缓存
sco5282的博客
10-07 777
Spring 从 3.1 开始定义了和接口来统一不同的缓存技术Cache：缓存接口，定义缓存操作。RedisCache等: 缓存管理器，管理各种缓存（Cache）组件: 缓存数据时 key 生成策略serialize: 缓存数据时 value 序列化策略@Cacheable【创建、查询缓存】：触发缓存入口（一般放在创建和获取的方法上，@Cacheable注解会先查询是否已经有缓存。如果有，则直接从缓存中返回；如果没有，则会执行方法并返回结果缓存【返回方法返回 NULL，则不进行缓存】）
linux中缓存，在kafka上应用总结
m0_72363694的博客
10-04 424
零拷贝：如上kafka读取文件会由操作系统读到页缓存，在读到kafaka的输入缓存，在同步到输出缓存用于写入其他设备，数据写操作会调用系统的块缓存写入，然后再把块缓存数据写到网卡中，这个过程比较耗时，从系统到kafka应用完成多次数据转译，称为多次拷贝，这个过程线程会跨用户态和核心态的代码存在切换额外保存数据的额外消耗。特权指令和非特权指令要求cpu切换状态，内核态和用户态的指令不能跨状体工作 ，切换效率低而且这是一次操作数据量大的时候性能就越低。
黑马element-ui
09-05
你想了解关于黑马前端的Element-UI吗？Element-UI 是一套基于 Vue.js 的桌面端组件库，由饿了么团队开发和维护。它提供了一系列易于使用且高效的组件，可以帮助开发者快速搭建现代化的网页应用程序。Element-UI 具有丰富的组件和主题定制能力，可以满足不同项目的需求，并且具有良好的用户体验和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值