11.29_黑马Redis实战篇商户查询缓存

已于 2024-01-15 21:07:24 修改
阅读量1.2k 收藏 22
点赞数 42
分类专栏： redis 文章标签： 缓存 redis 笔记 java
于 2023-11-29 13:25:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80185446/article/details/134636887
版权

实战篇1

实战篇2

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    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);
            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 null;
    }

实战篇4

操作缓存用时较短，操作数据库用时较长

实战篇5

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    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);
            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),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        //7，返回
        return null;
    }

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

做了以下改进：

1，在查询操作的时候，设置了过期时间。

2，在更新操作的时候，先更新数据库，后删除缓存。

实战篇6

危害：对数据库造成巨大压力

细节：

针对缓存空对象方案：

1，针对额外的内存消耗多现象，解决方案：定时清理缓存，设置ttl

2，针对短期不一致现象，解决方案：设置更精细的ttl

实战篇7

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    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);
            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) ;
    }

上一篇这里的 return 忘记改回Result.ok(shop)了

实战篇8

实战篇9

前者选择了一致性 

后者选择了可用性

实战篇10

bug1：redis和我的idea连接不上。

天啊，我竟然以最短的时间解决了一个bug！！！！！！！！！

具体问题如下：

怀疑问题所在：之前做苍穹的时候，和我的redis的连接池连接了，因为我发现我的db01有苍穹的数据，然后没有办法连接我的黑马点评，但是我不知道该怎么取消那个连接。于是我删除了redis的软件，以及快捷软件。

这个不需要太多的操作，不需要配置环境变量。

如果不把红色软件重新下载，有可能出现以上bug 

具体解决步骤：

1，直接按删除卸载完，在黑马JAVAWEB2023day5重新下载这两个东西。

2，在下面这个文件下打开cmd

3，输入以下代码

先打开一个cmd输入： redis-ser 用tab补充完整  redis.wind 用tab补充完整

再打开另一个cmd输入：redis-cli 用tab补充完整

注意：两个cmd都要在，不可以删除其中一个。

 4（可能不需要），打开服务，启动

就算不启动也可以，但是我上一次处理redis的bug的时候需要启动的，反正都试试。

5（上次bug试过，可以的）如果还不行试试开启全部权限。

6，最后检查host有没有写错，port有没有写错  要一一对应

是可以不设置密码的，也可以不指定database

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

 public Result queryById(Long id) {
        //缓存穿透
        //Shop shop = queryWithPassThrough(id);
        //互斥锁解决缓存穿透
        Shop shop =queryWithMutex(id);
        if(shop == null){
            return Result.fail("店铺不存在！");
        }
        //7，返回
        return Result.ok(shop);
    }

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

    public Shop queryWithPassThrough(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 shop;
        }
        //判断命中的是否是空值
        if (shopJson != null) {
            //返回一个错误信息
            return null;
        }

        //4，不存在，根据id查询数据库
        Shop shop = getById(id);
        //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);
        //7，返回
        return 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，存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }
        //判断命中的是否是空值
        if (shopJson != null) {
            //返回一个错误信息
            return null;
        }
        //4，实现缓存重建
        //4.1 获取互斥锁
        String lockkey = "lock:shop:" + id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockkey);
            //4.2 判断是否获取成功
            if (!isLock) {
                //4.3 失败，则休眠并重试
                Thread.sleep(50);
                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) {
            //这个打断的异常，直接抛出即可以，不用处理
            throw new RuntimeException (e);
        }
        //7，释放互斥锁
            unlock(lockkey);
            //8，返回
            return shop;


    }

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

实战篇11

thinking：Json Bean这些到底是什么？有什么用处？

Hutool参考文档

 

 JSON 基本使用_json怎么用-CSDN博客

 

thinking：JSON序列化和反序列化?

JSON序列化和反序列化_json反序列化_好奇的mao的博客-CSDN博客

 thinking：JSONOBJECT是什么？

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

    @Override
    public Result queryById(Long id) {
        //缓存穿透
        //Shop shop = queryWithPassThrough(id);
        //互斥锁解决缓存穿透
        //Shop shop =queryWithMutex(id);
        //逻辑过期解决缓存穿透
        Shop shop = queryWithLoginExpire(id);
        if (shop == null) {
            return Result.fail("店铺不存在！");
        }
        //7，返回
        return Result.ok(shop);
    }

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

    public Shop queryWithPassThrough(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 shop;
        }
        //判断命中的是否是空值
        if (shopJson != null) {
            //返回一个错误信息
            return null;
        }

        //4，不存在，根据id查询数据库
        Shop shop = getById(id);
        //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);
        //7，返回
        return 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，存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }
        //判断命中的是否是空值
        if (shopJson != null) {
            //返回一个错误信息
            return null;
        }
        //4，实现缓存重建
        //4.1 获取互斥锁
        String lockkey = "lock:shop:" + id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockkey);
            //4.2 判断是否获取成功
            if (!isLock) {
                //4.3 失败，则休眠并重试
                Thread.sleep(50);
                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) {
            //这个打断的异常，直接抛出即可以，不用处理
            throw new RuntimeException(e);
        }
        //7，释放互斥锁
        unlock(lockkey);
        //8，返回
        return shop;


    }


    public Shop queryWithLoginExpire(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);
        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 = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        //6.2，判断是否获取锁成功
        if (isLock) {
            //6.3 成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    //重建缓存
                    //实际上要写30分钟
                    this.saveShop2Redis(id, 20L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                //释放锁
                unlock(lockKey);
            });
        }
            //6.4 返回过期的商铺信息
            //6.5 不存在，根据id查询数据库

            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
            return shop;
        }




    //建立池子
    private  static  final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
        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);
    }

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

实战篇12

方法一和方法三 针对普通的问题

实战篇12的工具封装代码单独发一篇文章

simplesin
关注
  • 42
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis2.分布式锁
Strong_shady的博客
01-21 1815
1.redis的分布式锁 加锁： stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value);//setnx 释放锁： stringRedisTemplate.delete(REDIS_LOCK_KEY);//释放锁 2.强制完成删锁，防止阻塞 也就是把释放锁加入finally{}代码块中 3.加过期时间，处理服务器突发宕机 stringRedisTemplate.expire(REDIS_LOCK_KEY,10L, TimeUn
11.29_BOM.xmind
11-29
11.29_BOM.xmind
redis-黑马点评-商户查询缓存
m0_71894372的博客
03-18 1002
Spring中bean的注入方式:在Spring框架中，注入Bean（对象）的方式有多种，以下是一些常见的方法：1. 构造器注入（Constructor Injection）：通过构造器注入依赖，可以确保在创建对象时，它所依赖的其他对象也被创建。```@Autowired```2. Setter方法注入（Setter Injection）：通过setter方法注入依赖，可以在对象创建后，再设置依赖的对象。```java。
RedisTemplate opsForValue().setIfAbsent()
jieyigeweixiao的博客
05-12 2554
第一次redisKey没有值，则：true。第二次redisKey有值，则：false。
redis缓存击穿如何解决
Charles1616168的博客
10-20 1530
redis缓存击穿如何解决 设置互斥锁。在并发的多个请求中，只有第一个请求线程能拿到锁并执行数据库查询操作，其他的线程拿不到锁就阻塞等着，等到第一个线程将数据写入缓存后，直接走缓存。
11.29_黑马Redis实战篇优惠券秒杀
2301_80185446的博客
11-29 837
这里相当于是this.createVoucherOrder,而this. 是不纳入事务管理的。因此，要继续完善代码。只对createVoucherOrder做了事务管理，而没有对seckillVouch做事务管理，在。方法二：与方法一的思想是一样的，只是省略了version，直接用stock（库存）来判断。但不一定要相等才可以成功执行，只要stock大于零即可以执行。解决方法：要将endTime修改为现在真实时间之后。添加@EnableAspectJAutoProxy。这里有两篇很好的解决bug的文章。
PrinterShare_11.29.0高级版.apk
05-25
PrinterShare高级版是一款手机移动文件打印机APP，利用它可以直接打印出手机中的文件，比如PDF文件、办公文档(Word、Excel、PowerPoint)、账单、发票和其它材料等等，可以通过WiFi、蓝牙和USB或互联网四种形式来直接...
Maix-DualCamera_11.29(Schematic).pdf
04-21
ov2640双摄像头原理图
建筑单体11.29(修改5）_t7.dwg..bin
03-05
建筑单体11.29(修改5）_t7.dwg..bin
hbcms内容管理系统11.29
03-26
HBcms如何升级到新版本 您可以在不丢失任何数据的情况升级到最新的HBcms 升级一般步骤：1.上传最新版本压缩包，2.通过浏览器访问升级程序3....升级最快只要2分钟就可以完成！！ 为了避免异常，请在升级前先备份数据库、...
自制一个指定容量缓存，并实现最近使用的最后删除
ZHUSHANGLIN的博客
07-17 546
【代码】自制一个指定容量缓存，并实现最近使用的最后删除。
Caffeine缓存
辰兮
07-17 278
示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。提示：这里对文章进行总结：例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
ubuntu虚拟机安装ssh时报错 正在等待缓存锁
shiyq的技术小白博客
07-15 231
连接vm ubuntu虚拟机安装ssh时报错 正在等待缓存锁。
HTTP缓存/强缓存/协商缓存
qingdouxiaohua的博客
07-16 442
HTTP缓存是指当客户端（如浏览器）向服务器请求资源时，如果资源已经缓存在本地（如浏览器缓存或代理服务器缓存），则可以直接从缓存中获取资源，而无需再次从原始服务器下载。这样可以减少网络延迟和带宽消耗，提高页面加载速度。HTTP缓存的工作原理主要依赖于HTTP请求和响应报文头中的特定字段，这些字段用于控制缓存的策略和有效性。
MyBatis框架学习笔记（四）：动态SQL语句、映射关系和缓存
2301_76144723的博客
07-15 789
在一个实际的项目中，sql语句往往是比较复杂的为了满足更加复杂的业务需求，MyBatis的设计者，提供了动态生成SQL的功能。
arcgis紧凑型切片缓存(解决大范围切片，文件数量大的问题)
最新发布
GIS工具
07-19 432
ArcGIS 切片缓存的紧凑型存储格式是一种优化的存储方式，用于提高切片缓存的存储效率和访问速度。紧凑型存储格式将多个切片文件合并为一个单一的 .bundle 文件，从而减少文件系统的开销和切片的加载时间。这类格式已经应用很久了，我记得2013我项目中就采用过此类格式!最重要的是这是一种公开开放的格式有很多代码和库可以读写此类格式。而我们在日常使用软件中应尽量使用公开和开放的格式，以保证系统数据的可兼容性和可迁移性!
【算法】LRU缓存
时清云的博客
07-16 822
难度：中等。
Redis⑥ —— 缓存设计
qq_51148151的博客
07-16 725
redis八股之缓存设计机制介绍
import numpy as np import matplotlib.pyplot as plt # 数据点 x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]) y = np.array( [9.01, 8.96, 7.96, 7.96, 8.02, 9.05, 10.13, 11.18, 12.26, 13.28, 13.32, 12.61, 11.29, 10.22, 9.15, 7.95, 7.95, 8.86, 9.81, 10.80, 10.93])将这串代码用Java语言改写
06-03
抱歉，我作为一个语言模型AI，不会Java语言，但是我可以为您提供一个类似Java语言的伪代码示例，供您参考： double[] x = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; double[] y = {9.01, 8.96, 7.96, 7.96, 8.02, 9.05, 10.13, 11.18, 12.26, 13.28, 13.32, 12.61, 11.29, 10.22, 9.15, 7.95, 7.95, 8.86, 9.81, 10.80, 10.93}; // 绘制数据点 for (int i = 0; i < x.length; i++) { System.out.println("(" + x[i] + ", " + y[i] + ")"); } // 使用Matplotlib库进行可视化 // TODO: Java中可以使用JavaFX或其他可视化库进行实现 这段伪代码使用了Java语言中的数组和for循环，模拟了Python代码中的数据点的定义方式，并且使用了System.out.println打印了每个数据点的坐标。由于Java语言中没有Matplotlib库，因此我在伪代码中使用了TODO标记，表示您需要使用其他可视化库进行实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值