Redis实战篇（二）查询缓存

一、什么是缓存

缓存就是数据交换的缓冲区，是存贮数据的临时地方，一般读写性能较高。

1、 缓存的作用：

• 降低后端负载
• 提高读写效率，降低响应时间

2、缓存的成本：

• 数据一致性成本
• 代码维护成本
• 运维成本

二、添加Redis缓存

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        String key = "code:shop:" + id;
        //1、从redis中获取缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2、判断是否存在
        if (StringUtil.isNotBlank(shopJson)) {
            //3、存在直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //4、不存在，查询数据库
        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);
    }

三、缓存更新策略

1、三种更新策略

	内存淘汰	超时剔除	主动更新
说明	不用自己维护，利用Redis的内存淘汰机制，当内存不足时自动淘汰部分数据。下次查询时更新缓存	给缓存数据添加TTL时间，到期后自动删除缓存。下次查询时更新缓存。	编写业务逻辑，在修改数据库的同时，更新缓存。
一致性	差	一般	好
维护成本	无	低	高

如何选择：
根据业务场景，当低一致性需求时，使用内存淘汰机制。例如店铺类型的查询缓存。
当高一致性需求时，使用主动更新，并以超时剔除作为辅助。例如商铺详情查询。

2、主动更新策略

策略	说明
Cache Aside Pattern	由缓存的调用者，在更新数据库的同时更新缓存
Read/Write Through Pattern	缓存和数据库整合成一个服务，由服务来维护一致性。
Write Behind Caching Pattern	调用者只操作缓存，由其他线程异步的将缓存数据持久化到数据库

3、总结

缓存更新策略的最佳实践方案：

1. 低一致性需求：使用Reids自带的内存淘汰机制
2. 高一致性需求：主动更新，并以超时剔除作为辅助方案
   读操作：缓存命中直接返回；缓存未命中查询数据库，并写入缓存，设定超时时间
   写操作：先写数据库，再删除缓存；要确保数据库和缓存操作的原子性

四、缓存穿透

1、定义

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

2、解决方案

（1）缓存空对象

优点	缺点
实现简单，维护方便	额外的内存消耗；可能造成短期的不一致

（2）布隆过滤器

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

五、缓存雪崩

1、定义

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

2、解决方案

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

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

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

（4）给业务添加多级缓存

六、缓存击穿

1、定义

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

2、解决方案

3、基于互斥锁方式解决缓存击穿问题

    public <R, ID> R queryWithMutex(
            String keyPrefix, ID id, Class<R> type, 
            Function<ID, R> dbFallback, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 3.存在，直接返回
            return JSONUtil.toBean(shopJson, type);
        }
        // 判断命中的是否是空值
        if (shopJson != null) {
            // 返回一个错误信息
            return null;
        }

        // 4.实现缓存重建
        // 4.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        R r = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2.判断是否获取成功
            if (!isLock) {
                // 4.3.获取锁失败，休眠并重试
                Thread.sleep(50);
                return queryWithMutex(keyPrefix, id, type, 
                		dbFallback, time, unit);
            }
            // 4.4.获取锁成功，根据id查询数据库
            r = dbFallback.apply(id);
            // 5.不存在，返回错误
            if (r == null) {
                // 将空值写入redis
                stringRedisTemplate.opsForValue()
                		.set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                // 返回错误信息
                return null;
            }
            // 6.存在，写入redis
            this.set(key, r, time, unit);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            // 7.释放锁
            unlock(lockKey);
        }
        // 8.返回
        return r;
    }

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

线程 存数据到redis

    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.存在，直接返回
            return null;
        }
        // 4.命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
        LocalDateTime expireTime = redisData.getExpireTime();
        // 5.判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())) {
            // 5.1.未过期，直接返回店铺信息
            return r;
        }
        // 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 {
                    // 查询数据库
                    R newR = dbFallback.apply(id);
                    // 重建缓存
                    this.setWithLogicalExpire(key, newR, time, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    // 释放锁
                    unlock(lockKey);
                }
            });
        }
        // 6.4.返回过期的商铺信息
        return r;
    }

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

七、缓存工具封装

八、总结