Redis框架（八）：大众点评项目 逻辑过期时间处理缓存击穿

SpringCloud章节复习已经过去，新的章节Redis开始了，这个章节中将会回顾Redis实战项目 大众点评
主要依照以下几个原则

1. 基础+实战的Demo和Coding上传到我的代码仓库
2. 在原有基础上加入一些设计模式，stream+lamdba等新的糖
3. 通过DeBug调试，进入组件源码去分析底层运行的规则和设计模式

代码会同步在我的gitee中去，觉得不错的同学记得一键三连求关注，感谢：
Redis优化-链接: RedisThreeStrategiesProject

需求：逻辑过期时间处理缓存击穿

上一节已经讲了下互斥锁
互斥锁本身是ok的，但是将当前资源锁住，后面的用户 只能查询等待
有没有更好的解决方式那？
这里可以设计逻辑过期时间

我们定义一个逻辑过期时间

1. 当用户A过来，发现过期，通过互斥锁去更新Redis
2. 这个期间，其他用户过来，可以异步去获得旧数据，而不是一直等待
3. 这里就需要我们手动设置一个过期时间，定义相应的RedisData类，封装过期时间信息

业务实现

1. 更新RedisData，获取过期时间，这里的时间是手动设置的

@Data
public class RedisData {

    private LocalDateTime expireTime;
    private Object object;
}

1
2
3
4
5
6
7

2. 去单元测试中测试，向Redis注入热点信息

    public void saveShop2Redis(Long id, Long expireSeconds){
        Shop shop = getById(id);

        RedisData data = new RedisData();

        data.setObject(shop);
        data.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));

        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(data));

    }
1
2
3
4
5
6
7
8
9
10
11

@SpringBootTest
class HmDianPingApplicationTests {

    @Resource
    private ShopServiceImpl shopService;

    @Test
    void testSaveShop(){

        for (int i = 1; i < 15; i++) {
            Long value = Long.valueOf(i);
            shopService.saveShop2Redis(value, 10L);
        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3. 业务逻辑代码，个人写的，没有使用异步，本质上还是互斥锁

    //逻辑过期  个人写  并不能实现异步 还是阻塞
    public Result queryById2(Long id) {

        String key = RedisConstants.CACHE_SHOP_KEY + id;
        String shopStr = stringRedisTemplate.opsForValue().get(key);
        if(StrUtil.isBlank(shopStr)){
            return Result.fail("NULL");
        }


        RedisData data = JSONUtil.toBean(shopStr, RedisData.class);
        Shop shop = JSONUtil.toBean((JSONObject) data.getObject(), Shop.class);


        if(data.getExpireTime().isAfter(LocalDateTime.now())){
            return Result.ok(shop);
        }


        //过期了，就通过独立线程 -> 互斥锁处理缓存击穿
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        try {
            if (!tryLock(lockKey)) {
                Thread.sleep(50);
                return queryById(id);
            }

            shop = getById(id);
            log.debug("lockKey: " + lockKey + " shopByDB " + shop);

            if (shop == null) {
                return Result.fail("店铺类型不存在！");
            }
            data.setExpireTime(LocalDateTime.now().plusSeconds(3600));
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(data),   RedisConstants.CACHE_NULL_TTL, TimeUnit.HOURS);


        } catch (InterruptedException e) {
            throw new RuntimeException(e);
            /*e.printStackTrace();*/
        }finally {
            //删除暂时的key, 释放互斥锁
            stringRedisTemplate.delete(lockKey);
        }
        return Result.ok(shop);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

4. 业务逻辑，已经更新，线程池引入，异步处理

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

    @Override //逻辑过期时间 通过线程池进行处理
    public Result queryById(Long id) {
        //这里就是所有的热点数据保存到了Redis，直接去拿，热点数据没有TTL，只有过期时间这一字段
        String key = RedisConstants.CACHE_SHOP_KEY + id;
        String shopStr = stringRedisTemplate.opsForValue().get(key);
        if(StrUtil.isBlank(shopStr)){
            return Result.fail("店铺资格过期");
        }

        RedisData data = JSONUtil.toBean(shopStr, RedisData.class);
        Shop shop = JSONUtil.toBean((JSONObject) data.getObject(), Shop.class);

        if(data.getExpireTime().isAfter(LocalDateTime.now())){
            return Result.ok(shop);
        }

        //过期了，就通过独立线程 -> 互斥锁处理缓存击穿
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        if (!tryLock(lockKey)) {
            log.debug("lockKey: " + lockKey + " shopByDB " + shop);
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    this.saveShop2Redis(id, 10L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                    /*e.printStackTrace();*/
                }finally {
                    //删除暂时的key, 释放互斥锁
                    stringRedisTemplate.delete(lockKey);
                }
            });
        }

        if(shop==null){
            return Result.fail("店铺不存在");
        }

        return Result.ok(shop);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

总结