Redis缓存工具封装实现

Redis缓存工具封装 Redis缓存 2023-01-15 12:01:06 165人浏览独家记忆

摘要

目录1. 方法要求1.1 方法一1.2 方法二1.3 方法三1.4 方法四2. 完整工具类代码将 StringRedisTemplate 封装成一个缓存工具类，方便以后重复使用。 1. 方法要求在这个工具类中我们完成四

1. 方法要求

在这个工具类中我们完成四个方法：

方法①：将任意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;
  }

  //方法一
  public void set(String key, Object value, Long time, TimeUnit unit) {
  }

  //方法二
  public void setWithLogicExpire(String key, Object value, Long time, TimeUnit unit) {
  }

  //方法三
  public <R, ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type,
                     Long time, TimeUnit unit, Function<ID, R> dbFallback) {
  }

  //方法四
  public <R, ID> R queryWithLogicalExpire(String prefix, ID id, String lockPre, Class<R> type,
                      Long time, TimeUnit unit, Function<ID, R> dbFallback) {
  }

  //线程池
  private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

  //获取锁
  private boolean tryLock(String key) {
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
    return BooleanUtil.isTrue(flag);
  }

  //释放锁
  private void unLock(String key) {
    stringRedisTemplate.delete(key);
  }
}

接下来我们可以不断完善这些方法。

1.1 方法一

public void set(String key, Object value, Long time, TimeUnit unit) {
  stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
}

1.2 方法二

public void setWithLogicExpire(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));
}

1.3 方法三

public <R, ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type,
                                          Long time, TimeUnit unit, Function<ID, R> dbFallback) {
    String key = keyPrefix + id;
    //1.从redis中查询商铺缓存
    String json = stringRedisTemplate.opsForValue().get(key);
    //2.判断是否存在
    if (StrUtil.isNotBlank(json)) {
        //2.1.存在
        return JSONUtil.toBean(json, type);
    }
    //2.2.不存在
    //判断是否为空值
    if (json != null) {
        //不为null，则必为空
        return null;
    }
    //3.查询数据库
    R r = dbFallback.apply(id);
    if (r == null) {
        //3.1.不存在，缓存空值
        stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
    } else {
        //3.2.存在，缓存数据
        this.set(key, r, time, unit);
    }
    return r;
}

方法三用到了函数式编程，这里非常巧妙，顺便再贴一下调用方法是怎样调用的：

Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY,id,Shop.class,CACHE_SHOP_TTL,TimeUnit.MINUTES,this::getById);

1.4 方法四

public <R, ID> R queryWithLogicalExpire(String prefix, ID id, String lockPre, Class<R> type,
                                            Long time, TimeUnit unit, Function<ID, R> dbFallback) {
    //1.从redis查询商铺缓存
    String key = prefix + id;
    String json = stringRedisTemplate.opsForValue().get(key);
    //2.判断是否存在
    if (StrUtil.isBlank(json)) {
        //未命中，直接返回空
        return null;
    }
    //3.命中，判断是否过期
    RedisData redisData = JSONUtil.toBean(json, RedisData.class);
    R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
    if (redisData.getExpireTime().isAfter(LocalDateTime.now())) {
        //3.1未过期,直接返回店铺信息
        return r;
    }
    //3.2.已过期，缓存重建
    //3.3.获取锁
    String lockKey = lockPre + id;
    boolean flag = tryLock(lockKey);
    if (flag) {
        //3.4.获取成功
        //4再次检查redis缓存是否过期，做double check
        json = stringRedisTemplate.opsForValue().get(key);
        //4.1.判断是否存在
        if (StrUtil.isBlank(json)) {
            //未命中，直接返回空
            return null;
        }
        //4.2.命中，判断是否过期
        redisData = JSONUtil.toBean(json, RedisData.class);
        r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
        if (redisData.getExpireTime().isAfter(LocalDateTime.now())) {
            //4.3.未过期,直接返回店铺信息
            return r;
        }
        //4.4过期，返回旧数据
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            //5.重建缓存
            try {
                R r1 = dbFallback.apply(id);
                this.setWithLogicExpire(key, r1, time, unit);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                //释放锁
                unLock(lockKey);
            }
        });
    }
    //7.获取失败,返回旧数据
    return r;
}

2. 完整工具类代码

@Component
@Slf4j
public class CacheClient {

  private final StringRedisTemplate stringRedisTemplate;

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

  public void set(String key, Object value, Long time, TimeUnit unit) {
    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
  }

  public void setWithLogicExpire(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));
  }

  public <R, ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type,
                     Long time, TimeUnit unit, Function<ID, R> dbFallback) {
    String key = keyPrefix + id;
    //1.从redis中查询商铺缓存
    String json = stringRedisTemplate.opsForValue().get(key);
    //2.判断是否存在
    if (StrUtil.isNotBlank(json)) {
      //2.1.存在
      return JSONUtil.toBean(json, type);
    }
    //2.2.不存在
    //判断是否为空值
    if (json != null) {
      //不为null，则必为空
      return null;
    }
    //3.查询数据库
    R r = dbFallback.apply(id);
    if (r == null) {
      //3.1.不存在，缓存空值
      stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
    } else {
      //3.2.存在，缓存数据
      this.set(key, r, time, unit);
    }
    return r;
  }

  public <R, ID> R queryWithLogicalExpire(String prefix, ID id, String lockPre, Class<R> type,
                      Long time, TimeUnit unit, Function<ID, R> dbFallback) {
    //1.从redis查询商铺缓存
    String key = prefix + id;
    String json = stringRedisTemplate.opsForValue().get(key);
    //2.判断是否存在
    if (StrUtil.isBlank(json)) {
      //未命中，直接返回空
      return null;
    }
    //3.命中，判断是否过期
    RedisData redisData = JSONUtil.toBean(json, RedisData.class);
    R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
    if (redisData.getExpireTime().isAfter(LocalDateTime.now())) {
      //3.1未过期,直接返回店铺信息
      return r;
    }
    //3.2.已过期，缓存重建
    //3.3.获取锁
    String lockKey = lockPre + id;
    boolean flag = tryLock(lockKey);
    if (flag) {
      //3.4.获取成功
      //4再次检查redis缓存是否过期，做double check
      json = stringRedisTemplate.opsForValue().get(key);
      //4.1.判断是否存在
      if (StrUtil.isBlank(json)) {
        //未命中，直接返回空
        return null;
      }
      //4.2.命中，判断是否过期
      redisData = JSONUtil.toBean(json, RedisData.class);
      r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
      if (redisData.getExpireTime().isAfter(LocalDateTime.now())) {
        //4.3.未过期,直接返回店铺信息
        return r;
      }
      //4.4过期，返回旧数据
      CACHE_REBUILD_EXECUTOR.submit(() -> {
        //5.重建缓存
        try {
          R r1 = dbFallback.apply(id);
          this.setWithLogicExpire(key, r1, time, unit);
        } catch (Exception e) {
          throw new RuntimeException(e);
        } finally {
          //释放锁
          unLock(lockKey);
        }
      });
    }
    //7.获取失败,返回旧数据
    return r;
  }

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

  //获取锁
  private boolean tryLock(String key) {
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
    return BooleanUtil.isTrue(flag);
  }

  //释放锁
  private void unLock(String key) {
    stringRedisTemplate.delete(key);
  }
}

到此这篇关于Redis缓存工具封装实现的文章就介绍到这了,更多相关Redis缓存工具封装内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Redis缓存工具封装实现

本文链接: https://www.lsjlt.com/news/177766.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341