Redis实战常用二、缓存的使用

一、什么是缓存

在实际开发中,系统需要"避震器"，防止过高的数据访问猛冲系统,导致其操作线程无法及时处理信息而瘫痪.
- 这在实际开发中对企业讲,对产品口碑,用户评价都是致命的。所以企业非常重视缓存技术;
缓存(Cache)：就是数据交换的缓冲区，俗称的缓存就是缓冲区内的数据，一般从数据库中获取，存储于本地代码中。
- 缓冲区：是存储数据的临时地方，一般读写性能较高。

例子：

// 例1:
static final ConcurrentHashMap<K,V> map = new ConcurrentHashMap<>(); //本地用于高并发缓存

// 例2:
static final Cache<K,V> USER_CACHE = CacheBuilder.newBuilder().build(); // 用于redis等缓存

// 例3:
Static final Map<K,V> map =  new HashMap(); // 本地缓存

由于其被Static修饰,所以随着类的加载而被加载到内存之中，作为本地缓存，由于其又被final修饰，所以其引用(例3:map)和对象(例3:new HashMap())之间的关系是固定的，不能改变，因此不用担心赋值(=)导致缓存失效。

二、为什么使用缓存

优点：访问速度快，好用

缓存数据存储于代码中，而代码运行在内存中，内存的读写性能远高于磁盘，缓存可以大大降低用户访问并发量带来的服务器读写压力。
- 实际开发过程中,企业的数据量,少则几十万,多则几千万,这么大数据量,如果没有缓存来作为"避震器",系统是几乎撑不住的,所以企业会大量运用到缓存技术。

缓存也会增加代码复杂度和运营的成本。

三、使用缓存的缺点与优点

在这里插入图片描述

四、如何使用缓存

实际开发中,会构建多级缓存来使系统运行速度进一步提升，例如：本地缓存与redis中的缓存并发使用等等。
- 浏览器缓存：主要是存在于浏览器端的缓存
- 应用层缓存：可以分为tomcat本地缓存，比如之前提到的map，或者是使用redis作为缓存
- 数据库缓存：在数据库中有一片空间是 buffer pool，增改查数据都会先加载到mysql的缓存中
- CPU缓存：当代计算机最大的问题是 cpu性能提升了，但内存读写速度没有跟上，所以为了适应当下的情况，增加了cpu的L1，L2，L3级的缓存

四、1、添加缓存的思路

标准的操作方式就是查询数据库之前先查询缓存：
- 如果缓存数据存在，则直接从缓存中返回。
- 如果缓存数据不存在，再查询数据库，然后将查询到的数据存入redis，再把数据库的数据返回。
不使用缓存
使用缓存
举例：根据id查询商铺的信息

四、2、缓存的更新策略

缓存更新是redis为了节约内存而设计出来的一个东西，主要是因为内存数据宝贵，当我们向redis插入太多数据，此时就可能会导致缓存中的数据过多，所以redis会对部分数据进行更新，或者把它叫为淘汰更合适。主要有一下三种策略：
- 内存淘汰：redis自动进行，当redis内存达到咱们设定的max-memery的时候，会自动触发淘汰机制，淘汰掉一些不重要的数据(可以自己设置策略方式)
- 超时剔除：当我们给redis设置了过期时间ttl之后，redis会将超时的数据进行删除，方便后面继续使用缓存
- 主动更新：我们可以手动调用方法把缓存删掉，通常用于解决缓存和数据库不一致问题

在这里插入图片描述

四、2.1、数据库和缓存不一致的问题解决：

由于我们的缓存的数据源来自于数据库,而数据库的数据是会发生变化的,因此,如果当数据库中数据发生变化,而缓存却没有同步,此时就会有一致性问题存在,其后果是:
- 用户使用缓存中的过时数据,就会产生类似多线程数据安全问题，从而影响业务，产品口碑等。怎么解决呢？有如下几种方案：
  - 1、Cache Aside Pattern 人工编码方式：缓存调用者在更新完数据库后再去更新缓存，也称之为双写方案
  - 2、Read/Write Through Pattern : 由系统本身完成，数据库与缓存的问题交由系统本身去处理
  - 3、Write Behind Caching Pattern ：调用者只操作缓存，其他线程去异步处理数据库，实现最终一致

数据库和缓存不一致采用Cache Aside Pattern 人工编码方式

数据库和缓存不一致采用方法为：Cache Aside Pattern 人工编码方式：缓存调用者在更新完数据库后再去更新缓存，也称之为双写方案

操作缓存和数据库时有三个问题需要考虑：

假设我们每次操作数据库后，都操作缓存，但是中间如果没有人查询，那么这个更新动作实际上只有最后一次生效，中间的更新动作意义并不大，我们可以把缓存删除，等待再次查询时，将缓存中的数据加载出来.
问题一：选择删除缓存还是更新缓存？ （删除缓存）
- 更新缓存：每次更新数据库都更新缓存，无效写操作较多
- 删除缓存：更新数据库时让缓存失效，查询时再更新缓存
为什么不更新缓存儿选择直接删除缓存呢？
- 因为缓存的更新成本比删除成本更高。（因为你写入数据库的值在很多情况下并不是直接写入缓存的，而是要经过一系列复杂的计算再写入缓存。那么每次写入数据库后都再次计算写入缓存的值，无疑是浪费性能的，所以删除缓存更为适合。

问题二：如何保证缓存与数据库的操作的同时成功或失败？
- 单体系统，将缓存与数据库操作放在一个事务
- 分布式系统，利用TCC等分布式事务方案
问题三：选择先操作缓存还是先操作数据库？（先操作数据库，再删除缓存 ）
- 先删除缓存，再操作数据库
- 先操作数据库，再删除缓存

具体操作缓存还是操作数据库，我们应当是先操作数据库，再删除缓存
- 原因：如果你选择第一种方案（Cache Aside Pattern 人工编码方式），在两个线程并发来访问时，假设线程1先来，他先把缓存删了，此时线程2过来查询缓存数据并不存在，此时线程2查询数据库并把查询出来的数据写入缓存，当线程2把数据写入缓存后，线程1再执行更新动作时，实际上写入的就是旧的数据，新的数据被旧数据覆盖了。

先删除缓存还是先执行数据库操作的选择分析

写缓存的时间是很快的（几毫秒），而操作数据库的时间是很长的。（操作缓存和操作数据库效率差别大）

1、先删除缓存，再操作数据

先删除缓存，再操作数据的正常情况：
先删除缓存，再操作数据的异常情况（出现数据库和缓存数据不一致的问题）：
- 解决办法一：延迟双删：最终一致性的方法，即使用双删的办法。（就是每次修改完数据之后再把缓存删除了（使用延迟删除，避免删除缓存操作在旧数据的写入缓存操作之前）），这样就保证了数据的一致性了，但还是会出现一次数据不一致的问题，如果想避免一次数据一致性都不出现就得使用强一致性的方法了）（推荐使用这个方法）
  - 这方法感觉就相当于先操作数据库再删除缓存一样了，由此看来还是选择先操作再删除缓存
- 解决办法二：使用强一致性的办法（就是保证redis的操作和数据库的操作的原子性），可以使用加锁的方法（使用这种方法会影响性能，我们使用redis的意义就是为了提高性能，所以加锁就得不偿失了，所以不太推荐了）

2、先操作数据，再删除缓存

先操作数据，再删除缓存的正常情况：
先操作数据，再删除缓存的异常情况1（出现数据库和缓存数据不一致的问题）：因为缓存操作是很快的，所以这种异常情况几乎不可能发生。
先操作数据，再删除缓存的异常情况2：删除缓存失败的情况，就是线程2执行删除缓存操作时出现删除失败的问题，导致最终的缓存数据还是旧数据。
- 解决方案一：使用异步删除重试的办法（结合mq）
- 解决方案二：cannal解耦（使用cannal提供的java客户端）

最终选择：先操作数据库再删除缓存

在这里插入图片描述

缓存穿透

缓存雪崩

缓存击穿（热点key）

最后可以把缓存击穿和缓存穿透的解决方法封装成一个工具类

基于StringRedisTemplate封装一个缓存工具类，满足下列需求：

方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓

存击穿问题

方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

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

//使用构造器注入第三方beanStringRedisTemplate
    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

// 添加缓存，设置key的过期时间
    public void set(String key, Object value, Long time, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    }

// 添加缓存，设置逻辑过期时间
    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));
    }

// 获取缓存，解决缓存穿透
    public <R,ID> R queryWithPassThrough(
            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.isNotBlank(json)) {
            // 3.存在，直接返回
            return JSONUtil.toBean(json, type);
        }
        // 判断命中的是否是空值
        if (json != null) {
            // 返回一个错误信息
            return null;
        }

        // 4.不存在，根据id查询数据库
        R 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);
        return r;
    }
    
// 使用逻辑过期时间，解决缓存击穿
    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;
    }

// 使用互斥锁解决缓存穿透
    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;
    }

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