Redis缓存更新策略与缓存穿透、雪崩等问题的解决

private final RedisTemplate<String, String> redisTemplate;
private static final ExecutorService CACHE_REBUILD_EXECUTOR = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(20), r -> new Thread(r, "cache_rebuild"));
public CacheClient(RedisTemplate<String, String> redisTemplate) {
    this.redisTemplate = redisTemplate;
}
public void setWithLogicalExpire(String key, Object value, Long expireTime, TimeUnit unit) {
    // 设置逻辑过期时间
    RedisData redisData = new RedisData();
    redisData.setValue(value);
    redisData.setExpireTime(LocalDateTime.now().plusNanos(unit.toNanos(expireTime)));
    redisTemplate.opsForValue().set(key, JSON.toJSONString(redisData));
}
/**
 * 逻辑过期，互斥锁获取值，用于避免热点数据出现缓存击穿
 */
public <R, V> R getMutex(String keyPrefix, V id, Class<R> clazz, Function<V, R> dbFallback, Long expireTime, TimeUnit unit) {
    String key = keyPrefix + id;
    String value = redisTemplate.opsForValue().get(key);
    if (StringUtils.isBlank(value)) {
        return null;
    }
    RedisData redisData = JSON.parseObject(value, RedisData.class);
    R result = JSONUtil.toBean((JSONObject) redisData.getValue(), clazz);
    if (redisData.getExpireTime().isAfter(LocalDateTime.now())) {
        return result;
    }
    // 如果缓存已过期，则尝试更新
    String localKey = RedisConstant.LOCK + id;
    // 获取锁成功
    if (getLock(localKey)) {
        // 异步更新缓存
        CACHE_REBUILD_EXECUTOR.submit(
            () -> {
                try {
                    R res = dbFallback.apply(id);
                    this.setWithLogicalExpire(key, res, expireTime, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    unLock(localKey);
                }
            }
        );
    }
    return result;
}
private boolean getLock(String key) {
    // 直接返回会进行自动拆箱，可能会出现空指针异常
    return Boolean.TRUE.equals(redisTemplate.opsForValue().setIfAbsent(key, "1"));
}
private void unLock(String key) {
    redisTemplate.delete(key);
}

/**
 * <pre>
 * 简易实现的Redis分布式锁
 * </pre>
 *
 * @author <a href="https://github.com/Ken-Chy129">Ken-Chy129</a>
 * @date 2023/2/26 21:18
 */
public class SimpleRedisLock {
    private final RedisTemplate<String, String> redisTemplate;
    /**
    锁的名字，根据业务设置
     */
    private final String lockName;
    /**
     * key前缀
     */
    private static final String KEY_PREFIX = "lock:";
    /**
     * value中线程标识的前缀（为每个节点提供一个随机的前缀，避免集群部署下线程id出现重复而导致value出现相同的情况）
     */
    private static final String ID_PREFIX = UUID.fastUUID().toString(true);
    /**
     * 释放锁逻辑的lua脚本
     */
    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
    static {
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
        UNLOCK_SCRIPT.setResultType(Long.class);
    }
    public SimpleRedisLock(String lockName, RedisTemplate<String, String> redisTemplate) {
        this.lockName = lockName;
        this.redisTemplate = redisTemplate;
    }
    public boolean tryLock(long timeoutSec) {
        long threadId = Thread.currentThread().getId();
        // 返回的是Boolean类型，直接return会进行自动拆箱，可能会出现空指针异常
        // 需要为锁设置过期时间，防止因服务宕机而导致锁无法释放
        return Boolean.TRUE.equals(redisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + lockName, ID_PREFIX + threadId, timeoutSec, TimeUnit.SECONDS));
    }
    public void unlock() {
        redisTemplate.execute(
                UNLOCK_SCRIPT,
                Collections.singletonList(KEY_PREFIX + lockName),
                ID_PREFIX + Thread.currentThread().getId()
        );
    }
}

--- 比较线程标识与锁中的标识是否一致
if(redis.call('get', KEYS[1]) == ARGS[1]) then
    --- 释放锁
    return redis.call('del', KEYS[1])
end
return 0

/**
 * 避免缓存穿透的获取
 */
public <R, V> R get(String keyPrefix, V id, Class<R> clazz, Function<V, R> dbFallback, Long expireTime, TimeUnit unit) {
    String key = keyPrefix + id;
    // 查询缓存
    String value = redisTemplate.opsForValue().get(key);
    // 缓存存在则直接返回
    if (StringUtils.isNotBlank(value)) {
        return JSON.parseObject(value, clazz);
    }
    // 缓存不存在(到此处说明value要么是空，要么是null)
    if (value != null) {
        // 不为null则说明为“”，代表数据不存在，直接返回null，不用查询数据库(解决缓存穿透问题)
        return null;
    }
    // value为null则查询数据库获取数据进行更新
    R result = dbFallback.apply(id);
    if (result == null) {
        // 数据库查询不到结果，则存入空串避免缓存穿透
        redisTemplate.opsForValue().set(key, "", RedisConstant.CACHE_NULL_TTL, TimeUnit.MINUTES);
        return null;
    }
    // 查询到结果，写回缓存
    this.set(key, result, expireTime, unit);
    return result;
}

/**
 * 逻辑过期，互斥锁获取值，用于避免热点数据出现缓存击穿
 */
public <R, V> R getMutex(String keyPrefix, V id, Class<R> clazz, Function<V, R> dbFallback, Long expireTime, TimeUnit unit) {
    String key = keyPrefix + id;
    String value = redisTemplate.opsForValue().get(key);
    if (StringUtils.isBlank(value)) {
        return null;
    }
    RedisData redisData = JSON.parseObject(value, RedisData.class);
    R result = JSONUtil.toBean((JSONObject) redisData.getValue(), clazz);
    if (redisData.getExpireTime().isAfter(LocalDateTime.now())) {
        return result;
    }
    // 如果缓存已过期，则获取锁尝试更新
    SimpleRedisLock lock = new SimpleRedisLock(key, redisTemplate);
    // 获取锁成功
    if (lock.tryLock(5)) {
        // 异步更新缓存
        CACHE_REBUILD_EXECUTOR.submit(
                () -> {
                    try {
                        R res = dbFallback.apply(id);
                        this.setWithLogicalExpire(key, res, expireTime, unit);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    } finally {
                        lock.unlock();
                    }
                }
        );
    }
    return result;
}