点评项目-6-缓存更新策略、缓存穿透、雪崩

缓存更新策略

使用 redis 缓存记录的信息，有可能在数据库被信息被修改导致信息不一致，使用缓存更新来解决这个问题

缓存更新策略主要有三种：

1.内存淘汰(redis默认开启)

2.超时剔除(给key添加TTL时间)

3.主动更新(编写业务逻辑)

主动更新策略：在数据库更新时删除缓存，通过事物保证数据库的更新和缓存的删除同时成功或失败。

对于数据库的更新和缓存的删除的执行顺序：

先删后更，在多线程下在数据库完成更新前可能会被另一个线程查询，导致数据不一致；先更后删，可能会在缓存未命中时查询完数据库，在写入缓存之前，另一个线程发生数据库更新操作，导致写入的缓存不是更新后的操作。对于两种情况，第一种发生的概率更高，原因是数据库的读写耗时更长

故我们选择先更新数据库再删缓存，并且给缓存设置超时剔除

给店铺信息查询添加缓存更新策略

第一步，设置缓存时间

//将查询到的数据写入 redis 并且设置有效时间 30 分钟
stringRedisTemplate.opsForValue().set("cache:shop:" + id,JSONUtil.toJsonStr(shop),30, TimeUnit.MINUTES);

第二步，完成店铺更新逻辑

请求路径：/shop 

我们在测试的时候可以把登录校验的拦截器关闭

public class LoginInterceptor implements HandlerInterceptor {

    private boolean isBeenTexting = true;//是否跳过校验登录状态

    //前置拦截
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if(isBeenTexting)return true;//如果在测试中则直接放行，不检验登录
        //判断线程池中是否有登录用户,若没有则拦截，返回 401 状态码
        if(UserHolder.getUser() == null){
//            System.out.println(request.getContextPath()+"请求被拦截");
            response.setStatus(401);
            return false;
        }
        return true;
    }

}

controller: 

    //更新店铺信息
    @PutMapping
    public Result updateShop(@RequestBody Shop shop){
        return shopService.update(shop);
    }

 service:

    @PutMapping
    public Result updateShop(@RequestBody Shop shop){
        return shopService.update(shop);
    }

    @Override
    @Transactional//开启事物
    public Result update(Shop shop) {
        Long id = shop.getId();
        if(id == null){
            return Result.fail("更新店铺信息失败，未查询到该店铺");
        }
        //先更新数据库
        shopMapper.updateById(shop);
        //再删除缓存
        stringRedisTemplate.delete("cache:shop:" + id);
        return null;
    }

测试：

缓存穿透 

缓存穿透是指缓存和数据库都不存在数据的查询，这样的请求都会打到数据库造成资源浪费

解决方式：

1.缓存空对象,直接将空对象放入 redis (常用)

2.布隆过滤，底层使用二进制保存请求是否含有数据的状态，只放行存在的请求，放行的请求有可能仍然出现穿透

改造店铺信息查询

给该查询功能添加空对象的缓存，并设置两分钟的 TTL

    @Override
    public Result getById(Long id) {
        //先在 redis 中查询
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:" + id);
        if(StrUtil.isNotBlank(shopJson)){
            return Result.ok(JSONUtil.toBean(shopJson,Shop.class));
        }
        //redis 中没有，在 mysql 中查询
        //TODO 解决缓存穿透，若 json 为 "" 则直接响应空对象
        if(shopJson != null){
            return Result.fail("未查询到店铺TOT");
        }
        Shop shop = shopMapper.selectById(id);
        if(shop == null){
            //mysql 中也没有，返回未查询到
            //TODO 解决缓存穿透，将空对象加入缓存
            stringRedisTemplate.opsForValue().set("cache:shop:" + id,"",2, TimeUnit.MINUTES);
            return Result.fail("未查询到该店铺ToT");
        }
        //查到了，将查询到的数据写入 redis
        stringRedisTemplate.opsForValue().set("cache:shop:" + id,JSONUtil.toJsonStr(shop),30, TimeUnit.MINUTES);
        return Result.ok(shop);
    }

缓存雪崩

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

解决方案：

1.给不同的 Key 的 TTL 添加指定区间的随机值

2.部署 redis 集群

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

4.添加多级缓存

采用 TTL 方案改造店铺查询请求

    @Override
    public Result getById(Long id) {
        //先在 redis 中查询
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:" + id);
        if(StrUtil.isNotBlank(shopJson)){
            return Result.ok(JSONUtil.toBean(shopJson,Shop.class));
        }
        //redis 中没有，在 mysql 中查询
        //TODO 解决缓存穿透，若 json 为 "" 则直接响应空对象
        if(shopJson != null){
            return Result.fail("未查询到店铺TOT");
        }
        Shop shop = shopMapper.selectById(id);
        if(shop == null){
            //mysql 中也没有，返回未查询到
            //TODO 解决缓存穿透，将空对象加入缓存
            stringRedisTemplate.opsForValue().set("cache:shop:" + id,"",2, TimeUnit.MINUTES);
            return Result.fail("未查询到该店铺ToT");
        }
        //查到了，将查询到的数据写入 redis
        //随机 TTL 0~100
        long ttl = (long)(Math.random() * 100);
        stringRedisTemplate.opsForValue().set("cache:shop:" + id,JSONUtil.toJsonStr(shop),ttl, TimeUnit.MINUTES);
        return Result.ok(shop);
    }

发送查询请求：

查看 redis kye 的缓存时间：

可以看到随机时间设置成功