redis-缓存

0 目录

1 什么是缓存

缓存就是数据交换的缓冲区（称作Cache），是存储数据的临时地方，一般读写性能较高

1.1 作用

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

1.2 成本

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

2 添加Redis缓存

即：在客户端和数据库之间加一层redis，这样就可以减轻数据库的压力。

3 缓存更新策略

3.1 具体业务场景

低一致性需求：使用内存淘汰机制。例如店铺类型的查询缓存
高一致性需求：主动更新，并以超时剔除作为兜底方案。例如店铺详情查询的缓存

3.2 主动更新策略

即：由缓存调用者在更新数据库的同时更新缓存。

3.2.1 注意点

删除还是更新缓存？
- 更新缓存：每次更新都更新缓存，无效写操作较多
- 删除缓存：更新数据库时让缓存失效，查询时再更新缓存（胜出）
如何保证缓存和数据库的操作的同时成功或失败？
- 更新缓存：每次更新都更新缓存，无效写操作较多
- 删除缓存：更新数据库时让缓存失效，查询时再更新缓存（胜出）
先操作缓存还是先操作数据库？
- 先操作数据库再删缓存，因为出现数据不一致的前提：1. 刚好缓存失效；2. 另一个线程写入时间在前一个线程查询数据库到写入缓存的几短时间内进行了更新操作

读操作：

缓存命中就返回

缓存没有命中查数据库，写入缓存同时设定超时时间

写操作：

先写数据库再删缓存

确保数据库和缓存操作的原子性

3.3 实现缓存和数据库的双写一致

在单体系统中，更新方法使用@Transactional对方法进行标记

4 缓存穿透

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

4.1 解决

缓存null值
布隆过滤
增强id的复杂度，避免被猜测id规律
做好数据的基础格式校验
加强用户权限校验
做好热点参数的限流

4.1.1 空值解决

步骤

当缓存没有命中的时候，查询数据库
判断数据库的数据是否存在
1. 存在：将数据写入缓存同时返回
2. 不存在：写入空值到缓存

@Override
public Result queryById(Long id) {
    String key=CACHE_SHOP_KEY+id;
    //1.从redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    //2.判断是否存在
    if(StrUtil.isNotBlank(shopJson)) {
        //3.存在，直接返回
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }
    //命中的是否为空值
    if(''.equals(shopJson)){
        return Result.fail("店铺信息不存在！");
    }
    //4.不存在，根据id查询数据库
    Shop shop = getById(id);
    //5.不存在，返回错误
    if(shop==null){
        //将空值写入redis
        stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
        return Result.fail("店铺信息不存在！");
    }
    //6.存在，写入redis
    stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
    //7.返回
    return Result.ok(shop);
}

5 缓存雪崩

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

5.1 解决

给不同的Key的TTL添加随机值

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

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

给业务添加多级缓存

6 缓存击穿

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

6.1 解决

前言：涉及到互斥锁，使用redis的一个命令：setnx

6.1.1 互斥锁解决

即：当第一个线程查询缓存的时候，没有实现命中，此时第一个线程开始获取互斥锁，当锁获取成功之后，开始查询数据库进行缓存的重建，查询完成之后写入缓存，最后释放锁

public Shop queryWithMutex(Long id){
    String key = CACHE_SHOP_KEY+id;
    //从redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    //判断缓存是否命中
    if(StrUtil.isNotBlank(shopJson)){
        //命中则直接返回数据
        return JSONUtil.toBean(shopJson, Shop.class);
    }
    //判断是否是缓存穿透
    if(''.equals(shopJson)){
        return null;
    }
    //实现缓存重建
    //1.获取互斥锁
    String lockKey=LOCK_SHOP_KEY+id;
   try{
       boolean isLock = tryLock(lockKey);
       //2.判断是否获取成功
       if(!isLock) {
           //3.失败，则休眠并重试
           Thread.sleep(50);
           queryWithMutex(id);
       }
     	 //TODO: 此时锁获取成功之后，应该再查询一下缓存，实现双重检查
       //4.成功，根据id查询数据库
       Shop shop = getById(id);
       //5.不存在，返回错误
       if(shop==null){
           stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
           return null;
       }
       //6.存在，写入redis
       stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL,TimeUnit.MINUTES);
       return shop;
   }catch(InterruptedException e){
       throw new RuntimeException(e);
   }finally{
       unlock(lockKey);
   }
}

private boolean tryLock(String key){
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.MINUTES);
    return BooleanUtil.isTrue(flag); //为防止程序在拆箱的时候出现空指针，要手动拆箱
}

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

6.1.2 逻辑过期解决

热点key需要先进行预热，将相关数据先放入缓存中，设定的过期时间不是redis的TTL，而是一个逻辑上认定会过期的时间

即：当缓存命中的时候，判断设定的缓存逻辑时间是否过期，如果没有，那么就直接返回数据信息；如果过期了，先尝试获取互斥锁，当获取到锁，如果获取锁失败了，将旧数据返回即可；如果获取锁成功，那么开启一个独立的线程进行查询数据库，写入缓存，以及设定逻辑过期时间，最后释放互斥锁。

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

public Shop queryWithLogicalExpire(Long id){
    String key=CACHE_SHOP_KEY+id;
    String shopJson = stringRedisTemplate.opsForValue().get(key);
    //缓存未命中
    if(StrUtil.isBlank(shopJson)){
        return null;
    }
    //命中，需要先把json反序列化为对象
    RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
    Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();
    //判断是否过期
    if(expireTime.isAfter(LocalDateTime.now())) {
        //未过期,直接返回店铺信息
        return shop;
    }
    //已过期，需要缓存重建
    String lockKey=LOCK_SHOP_KEY+id;
    //获取互斥锁
    boolean isLock = tryLock(lockKey);
    //判断是否获取锁成功
    if(isLock) {
        // TODO: 获取锁成功之后，再尝试获取一下缓存数据，没有就开启独立线程实现缓存重建
        //成功，开启独立线程，实现缓存重建
        CACHE_REBUILD_EXECUTOR.submit(()->{
            try {
                saveShop2Redis(id, CACHE_SHOP_TTL);
            }catch(Exception e){
                throw new RuntimeException(e);
            }finally{
                unlock(lockKey);
            }
        });
    }
    //返过期的商铺信息
}

private boolean tryLock(String key){
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.MINUTES);
    return BooleanUtil.isTrue(flag); //为防止程序在拆箱的时候出现空指针，要手动拆箱
}

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

public void saveShop2Redis(Long id,Long expireSeconds){
    //1.查询店铺数据
    Shop shop = getById(id);
    //2.封装逻辑过期时间
    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));
}

7 缓存工具类

需要满足以下4个要求：

任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

@Component
public class CacheClient {
  private final StringRedisTemplate stringRedisTemplate;

  public CacheClient(StringRedisTemplate stringRedisTemplate){
      this.stringRedisTemplate=stringRedisTemplate;
  }

  // 任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
  public void set(String key, Object value, Long time, TimeUnit unit){
      stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
  }
  

  // 将任意Java对象序列化为json并存储在string类型的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)));
      stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
  }

  // 根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
  public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID,R>dbFallback,Long time,TimeUnit unit){
      String key=keyPrefix+id;
      String json = stringRedisTemplate.opsForValue().get(key);
      if(StrUtil.isNotBlank(json)){
          return JSONUtil.toBean(json,type);
      }
      //判断命中的是否为空值
      if(json!=null){
          return null;
      }
      R r = dbFallback.apply(id);
      if(r==null){
          stringRedisTemplate.opsForValue().set(key,"",time,unit);
          return null;
      }
      this.set(key,r,time,unit);
      return r;
  }

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

  // 根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
  public <R,ID> R queryWithLogicalExpire(String keyPrefix,ID id,Class<R> type,Function<ID,R>dbFallback,Long time,TimeUnit unit){
      String key=keyPrefix+id;
      String json = stringRedisTemplate.opsForValue().get(key);
      if(StrUtil.isBlank(json)){
          return null;
      }
      RedisData redisData = JSONUtil.toBean(json, RedisData.class);
      R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
      LocalDateTime expireTime = redisData.getExpireTime();
      //判断是否过期
      if(expireTime.isAfter(LocalDateTime.now())){
          //未过期，直接返回店铺信息
          return r;
      }
      //已过期，需要缓存重建
      String lockKey=LOCK_SHOP_KEY+id;
      boolean isLock = tryLock(lockKey);
      if(isLock){
          CACHE_REBUILD_EXECUTOR.submit(()->{
              try{
                  //重建缓存
                  //1.查询数据库
                  R apply = dbFallback.apply(id);
                  //2.存入redis
                  this.setWithLogicalExpire(key,apply,time,unit);
              }catch (Exception e){
                  throw new RuntimeException(e);
              }finally{
                  unlock(key);
              }
          });
      }
      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);
  }
}

redis

#redis

redis-缓存

https://baijianglai.cn/redis-缓存/22e726666a0f/

作者

Lai Baijiang

发布于

2024年2月18日

许可协议

mybatis-环境搭建上一篇

redis-短信验证登录下一篇