当前位置： 首页 > news >正文

黑马点评2 商户查询缓存

news 来源：原创 2025/5/17 21:14:42

一、缓存的引入

1.什么是缓存？

        缓存(Cache),就是数据交换的缓冲区,俗称的缓存就是缓冲区内的数据,一般从数据库中获取,存储于本地代码。

2.缓存的优缺点

        缓存数据存储于代码中,而代码运行在内存中,内存的读写性能远高于磁盘,缓存可以大大降低用户访问并发量带来的服务器读写压力。但是缓存也会增加代码复杂度和运营的成本。

  • 降低后端负载
  • 提高读写效率，降低响应时间
  • 数据一致性、代码维护、运维等成本较高

3.缓存的执行思路

        遇事不决，加一层！为了降低对数据库的信息获取，增加redis介于客户端和数据库之间，如果redis中有相应的数据，则直接返回给客户端；否则再去数据库进行查询，返回数据库的数据。同时也把数据存入redis中。

二、商铺缓存策略

1.流程图

2.代码

   @Autowired
    private StringRedisTemplate stringRedisTemplate;

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

 

三、商铺类型缓存

1.需求

        主页的店铺类型是经常触发的，为了避免经常调用数据库导致的效率降低，所以要将信息存储到redis缓存中。

2.代码

① 使用redis的String类型

@RestController
@RequestMapping("/shop-type")
public class ShopTypeController {
    @Resource
    private IShopTypeService typeService;

    @GetMapping("list")
    public Result queryTypeList() {
        //使用mybatisPlus
        /*List<ShopType> typeList = typeService
                .query().orderByAsc("sort").list();*/
        /*return Result.ok(typeList);*/

        //使用缓存
        return typeService.queryTypeShop();

    }
}
@Override
    public Result queryTypeShop() {
        String key = RedisConstants.CACHE_SHOPLIST_KEY;
        //1.先查询缓存中是否有相应数据
        String shopList = stringRedisTemplate.opsForValue().get(key);
        //2.若缓存不为空，则直接返回数据
        if(StrUtil.isNotBlank(shopList)){
            List<ShopType> shopTypes = JSONUtil.toList(shopList, ShopType.class);
            return Result.ok(shopTypes);
        }
        //3.若缓存为空，则上数据库查询
        List<ShopType> typeListDB = query().orderByAsc("sort").list();
        //4.若数据库为空，返回错误状态
        if(typeListDB == null){
            return Result.fail("商家分类不存在");
        }
        //5.将数据库查到的数据存到redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(typeListDB));

        return Result.ok(typeListDB);
    }

四、缓存更新策略

1.三种更新策略

        由于内存宝贵，所以当数据存入过多时，redis会自动更新 / 删除信息，从而达到节省空间的目的。

  • ① 内存淘汰：这是redis的内存淘汰机制，当内存过多时，redis会自动淘汰部分数据。
  • ② 超时剔除：在编写程序时，为缓存数据添加TTL过期时间，到期后自动删除。之后查询时重新加入缓存。
  • ③ 主动更新：在编写代码时，若对数据库进行修改，同时也对缓存进行修改。

 2.主动更新策略——数据不一致解决方案

  • ① 人工处理：在编写代码时，将数据库和缓存的修改操作放在一起
  • ② 系统处理：将数据库和缓存整合为一个服务，编写时只需要调用这个服务即可。成本高
  • ③ 异步处理：编写时，只操作缓存，其他的线程异步处理数据库。当缓存短时多次处理时，对资源消耗较大。

3.删除还是更新缓存？

  • 更新：当数据改写过多时，对缓存的插入读写的数据量非常庞大。
  • 删除：更新数据库时让缓存失效，查询时再更新缓存。

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

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

5.应该先操作缓存还是先操作数据库？

  • ① 先删除缓存，在查询数据库：数据库的操作相对毫秒级的缓存较慢，当缓存调取数据库的数据时，数据库还未进行更新数据，那么缓存就获取到了一个旧数据。（概率高）
  • ② 先操作数据库，后删除缓存：当数据库还未操作时，缓存删除完获取到了数据库的旧数据后，数据库进行了操作，操作之后将缓存的旧数据发给了缓存。（概率低）
  • 所以操作时，要确保数据库与缓存操作的原子性。                

6.实现商铺和缓存与数据库双写一致

① 思路

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

② 代码

  • 设置redis缓存时添加过期时间
@Override
    public Result queryById(Long id) {
        //1.从redis中查询商铺缓存
        String key = CACHE_SHOP_KEY + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.判断缓存是否命中
        if(StrUtil.isNotBlank(shopJson)){
            //3.存在，返回商铺信息，使用JSON！！！！！
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //4.若redis中不存在，则在数据库中查询
        Shop shopDB = getById(id);
        //5.商户不存在，返回错误
        if(shopDB == null){
            return Result.fail("店铺不存在");

        }
        //6.若存在，写入redis中缓存,有效期三十分钟
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shopDB),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        //7.返回
        return Result.ok(shopDB);
    }
  • 删除缓存
    @Override
    @Transactional
    public Result update(Shop shop) {
        //先检查店铺是否存在
        Long id = shop.getId();
        if(id == null){
            return Result.fail("店铺不存在");
        }
        //更新数据库
        updateById(shop);
        //删除缓存,缓存的插入在查询时更新
        stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
        return Result.ok();
    }

五、缓存穿透问题

1.概念及解决方案

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

常见的解决方案有两种：

  • 缓存空对象：在redis和数据库都未命中后，向缓存插入一个带TTL的null值
    • 优点：实现简单，维护方便
    • 缺点：额外的内存消耗、可能造成短期的不一致

  • 布隆过滤：在客户端和redis之间放一个过滤器，采用的是哈希思想来解决这个问题，通过一个庞大的二进制数组，走哈希思想去判断当前这个要查询的这个数据是否存在

    • 优点：内存占用较少，没有多余key
    • 缺点：实现复杂、存在误判可能

  • 增强id的复杂度，避免被猜测id规律

  • 做好数据的基础格式校验

  • 加强用户权限校验

  • 做好热点参数的限流

 2.利用缓存空对象解决商品查询的缓存穿透问题

① 流程图

② 解决代码

@Override
    public Result queryById(Long id) {
        //1.从redis中查询商铺缓存
        String key = CACHE_SHOP_KEY + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.判断缓存是否命中
        if(StrUtil.isNotBlank(shopJson)){
            //3.存在，返回商铺信息，使用JSON！！！！！
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //检测redis中是否防止缓存穿透设置的空值
        if(shopJson != null){
            return Result.fail("商铺不存在");
        }
        //4.若redis中不存在，则在数据库中查询
        Shop shopDB = getById(id);
        //5.商户不存在，返回错误
        if(shopDB == null){
            //避免缓存穿透，设立带有效期的一个空值
            stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
            return Result.fail("店铺不存在");

        }
        //6.若存在，写入redis中缓存,有效期三十分钟
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shopDB),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        //7.返回
        return Result.ok(shopDB);
    }

 

六、缓存雪崩问题

1.定义

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

2.解决方案

  • 将不同key的TTL设置为随机值，防止同时过期
  • 利用Reids集群提高服务的可用性
  • 给缓存业务添加降级限流策略
  • 给业务添加多级缓存

七、缓存击穿问题

1.什么是缓存击穿

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

2.如何解决缓存击穿

① 互斥锁：

        锁可以实现互斥性，当一个线程访问缓存未命中时，将获得互斥锁。接着往下进行查询数据库以及缓存重构。当写入缓存之后，在进行释放互斥锁。在此同时，若有第二个线程进行访问缓存数据，而且也未命中时，他将不会获得互斥锁，而且进行休眠后重新访问缓存数据，在第一个线程设置结束后，他将缓存命中。

public Shop queryWithMutex(Long id) {
        //1.从redis中查询商铺缓存
        String key = CACHE_SHOP_KEY + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.判断缓存是否命中
        if (StrUtil.isNotBlank(shopJson)) {
            //3.存在，返回商铺信息，使用JSON！！！！！
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }
        //检测redis中是否防止缓存穿透设置的空值
        if (shopJson != null) {
            return null;
        }
        //4.实现缓存重建
        //4.1 获取互斥锁
        String lockKey = "lock:shop" + id;
        Shop shopDB;
        try {
            Boolean isLock = tryLock(lockKey);
            //4.2 判断是否获取成功
            if (!isLock) {
                //4.3 如果失败，则休眠并重试
                Thread.sleep(50);
                return queryWithMutex(id);
            }


            //4.4 成功，则在数据库中查询
            shopDB = getById(id);
            //模拟重建延迟
            Thread.sleep(200);
            //5.商户不存在，返回错误
            if (shopDB == null) {
                //避免缓存穿透，设立带有效期的一个空值
                stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;

            }
            //6.若存在，写入redis中缓存,有效期三十分钟
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shopDB), CACHE_SHOP_TTL, TimeUnit.MINUTES);

        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            //7.释放互斥锁
            unlock(lockKey);
        }
        //7.返回
        return shopDB;
    }
    private Boolean tryLock(String key){
        //用互斥锁的方法，新建一个key代表锁
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

    private void unlock(String key){
        //删除key
        stringRedisTemplate.delete(key);
    }

②设置逻辑过期时间：

        程序员设置逻辑过期时间而并非物理上的过期时间，也就是意味着redis的数据时永久缓存的而并非有过期失效。这个过期时间并不会直接作用于redis，而是我们后续通过逻辑去处理。假设线程1去查询缓存，然后从value中判断出来当前的数据已经过期了，此时线程1去获得互斥锁，那么其他线程会进行阻塞，获得了锁的线程他会开启一个 线程去进行 以前的重构数据的逻辑，直到新开的线程完成这个逻辑后，才释放锁， 而线程1直接进行返回，假设现在线程3过来访问，由于线程线程2持有着锁，所以线程3无法获得锁，线程3也直接返回数据，只有等到新开的线程2把重建数据构建完后，其他线程才能走返回正确的数据。这种方案巧妙在于，异步的构建缓存，缺点在于在构建完缓存之前，返回的都是脏数据。

private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public Shop queryWithLogicalExpire( Long id ) {
    String key = CACHE_SHOP_KEY + id;
    // 1.从redis查询商铺缓存
    String json = stringRedisTemplate.opsForValue().get(key);
    // 2.判断是否存在
    if (StrUtil.isBlank(json)) {
        // 3.存在，直接返回
        return null;
    }
    // 4.命中，需要先把json反序列化为对象
    RedisData redisData = JSONUtil.toBean(json, 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){
        CACHE_REBUILD_EXECUTOR.submit( ()->{

            try{
                //重建缓存
                this.saveShop2Redis(id,20L);
            }catch (Exception e){
                throw new RuntimeException(e);
            }finally {
                unlock(lockKey);
            }
        });
    }
    // 6.4.返回过期的商铺信息
    return shop;
}

    /**
     * 保存数据并设计逻辑时间的方法
     * @param id
     * @param expireSeconds
     */
    public void savaShop2Redis(Long id,Long expireSeconds){
        //1.先从数据库中获取shop数据
        Shop shop = getById(id);
        //2.封装数据到RedisData，并设置“逻辑”过期时间
        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));

    }

相关文章：

  • 十、Redis 主从复制：原理解析、配置实践与优化策略
  • PCA（主成分分析）核心原理
  • ［QT］开发全解析：从概念到实战
  • 【渗透测试】反弹 Shell 技术详解（一）
  • 苍雾世界新手玩法介绍 苍雾世界什么角色比较强
  • 从开源大模型工具Ollama存在安全隐患思考企业级大模型应用如何严守安全红线
  • SQL刷题：自连接（Self-Join）--通过将 同一张表连接两次，比较不同行之间的数据关系
  • 在Ubuntu上搭建Samba服务，实现与windows之间的文件共享
  • 如何评价字节发布的集成了AI的IDE trae？和cursor相比，有什么优势和劣势？
  • kan pinn
  • ArcGIS Pro建库中常用公式的应用与技巧
  • 【web前端开发】CSS--CSS简介及其编写位置（上）
  • 【数据结构】堆和priority_queue
  • Python Flask框架学习汇编
  • Android中的Fragment是什么以及它有哪些生命周期方法
  • MySQL : 数据库和表操作
  • 蓝桥与力扣刷题（蓝桥 最大化手工艺品销售利润）
  • 大模型部署TensorRT-LLM保姆级教程（三）- 使用Triton推理服务框架部署模型
  • Js：交换两个变量的值
  • Spring源码分析のAOP
  • 雅安市纪委监委回应黄杨钿甜耳环事件：相关政府部门正在处理
  • 淮安市车桥中学党总支书记王习元逝世，终年51岁
  • 国际金价下跌，中概股多数上涨，穆迪下调美国主权信用评级
  • 国家防汛抗旱总指挥部对15个重点省份开展汛前实地督导检查
  • 梅花奖在上海｜话剧《主角》：艺术与人生的交错
  • 清雪车司机未拉手刹下车导致溜车被撞亡，事故调查报告发布