需求

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

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

代码实现

首先创建CacheClient工具类并且引入StringRedisTemplate

@Slf4j
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

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

加入辅助方法

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

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

要求1

将任意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);
}

要求2

将任意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));
}

要求3

根据指定的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;
    //尝试从redis查询缓存
    String json = stringRedisTemplate.opsForValue().get(key);
    //判断是否存在
    if (StrUtil.isNotBlank(json)){
        //存在，直接返回
        return JSONUtil.toBean(json, type);
    }
    //判断命中的是否是空值（“”）
    if (json != null){
        return null;
    }
    //不存在,根据id查询数据库
    R  r = dbFallback.apply(id);
    //如果不存在，返回错误信息
    if (r == null) {
        stringRedisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
        return null;
    }
    //如果存在，写回redis
    this.set(key,r,time,unit);

    return r;
}

调用示例

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

要求4

根据指定的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;
    //尝试从redis查询缓存
    String json = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
    //判断是否存在
    if (StrUtil.isBlank(json)){
        //不存在，返回null
        return null;
    }
    //命中，需要先把json反序列化为对象
    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 = RedisConstants.LOCK_SHOP_KEY+id;
    //判断是否获取锁成功
    boolean isLock = trylock(lockKey);
    if (isLock){
        //注意获取锁成功之后应该再次检测redis是否过期，做doublecheck，如果存在则无需重建缓存
        //成功，开启独立显存，实现缓存重建
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            try {
                //重建缓存
                //查询数据库
                R r1 = dbFallback.apply(id);
                //写入Redis
                this.setWithLogicalExpire(key,r1,time,unit);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //释放锁
                unlock(lockKey);
            }
        });
    }

    //失败，直接返回过期的商铺信息
    return r;
}

调用示例

Shop shop = cacheClient
        .queryWithLogicalExpire(CACHE_SHOP_KEY, id,Shop.class,this::getById,20L,TimeUnit.SECONDS);
return shop;