实现一个基于 Redis 的缓存管理器

我们实现一个简易版的缓存管理器：软过期 + 硬过期 + 双重检测。

其核心为实现接口：com.github.chengyuxing.sql.plugins.QueryCacheManager

设置到 BakiDao 配置完成后根据规则即可达到 BakiDao 中的查询接口就能无感查询缓存，业务代码无需任何更改。

为了方便，我使用 springboot 项目来进行配置，首先 Maven 引入依赖：

我这里使用默认单数据源自动配置。

@Component
public class RedisCacheManager implements QueryCacheManager {
  ...
}

创建一个缓存对象类，也是序列化到 redis 的数据结构：

public static class CacheEntry implements Serializable {
    private static final long serialVersionUID = 1L;
    public List<DataRow> value;
    public long softExpireAt;
    public long hardExpireAt;
}

依赖注入 RedisTemplate<Object, Object> redisTemplate;

构建缓存 Key

其次，既然要进行缓存，就要考虑到缓存 key 的生成。

为了保证缓存的命中率，那么 key 的生成就要尽可能唯一，这是一个 key 生成的小例子，通过 SQL 和参数来进行 MD5 处理：

@NotNull String uniqueKey(@NotNull String sql, Map<String, ?> args) {
    String argsStr = "";
    if (args != null && !args.isEmpty()) {
        StringBuilder sb = new StringBuilder();
        args.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .forEach(e -> {
                    sb.append(e.getKey()).append("=").append(e.getValue());
                });
        argsStr = "@" + StringUtil.hash(sb.toString(), "MD5");
    }
    if (sql.startsWith("&")) {
        return sql + argsStr;
    }
    return StringUtil.hash(sql, "MD5") + argsStr;
}

这里假设 Map 参数值都是基本类型，没有嵌套 Map 或 Set 等其他类型，否则，需要考虑的更加全面，避免缓存击穿。

异步刷新

最关键的一步就是异步刷新，在缓存过期时，为了保证合理的更新缓存，并且不造成主线程阻塞，需要使用异步的方式来更新缓存，需要实现：

private final ExecutorService refreshPool = Executors.newSingleThreadExecutor(r -> {
    Thread thread = new Thread(r, "Rabbit-SQL Refresh Thread");
    thread.setDaemon(true);
    return thread;
});

void asyncRefresh(@NotNull String sql, Map<String, ?> args, @NotNull RawQueryProvider provider) {
    String key = uniqueKey(sql, args);
    String lockKey = "lock:" + key;
    // 这里设置一个锁的过期时间，避免长时间占用，导致其他线程获取不到数据
    Boolean ok = redisTemplate.opsForValue().setIfAbsent(lockKey, 1, 30, TimeUnit.SECONDS);
    if (ok == null || !ok) {
        return;
    }
    refreshPool.execute(() -> {
        // 双重检测，避免击穿
        CacheEntry entry = (CacheEntry) redisTemplate.opsForValue().get(key);
        // 如果缓存还没有软过期，那就取消查库刷新
        if (entry != null && System.currentTimeMillis() < entry.softExpireAt) {
            return;
        }
        try (Stream<DataRow> s = provider.query()) {
            List<DataRow> result = s.collect(Collectors.toList());
            saveEntry(key, result);
        } finally {
          	// 释放锁
            redisTemplate.delete(lockKey);
        }
    });
}

重写核心接口

本例子缓存策略的具体逻辑为：

  1. 第一次请求或缓存已硬过期，直接通过流式查询数据库，并在关闭时将结果写进缓存；
  2. 如果请求缓存存在并且没有软过期，直接返回缓存；
  3. 如果缓存超过软过期，执行异步刷新缓存，并返回缓存数据；
@Override
public @NotNull Stream<DataRow> get(@NotNull String sql, Map<String, ?> args, @NotNull RawQueryProvider provider) {
    String key = uniqueKey(sql, args);
    long now = System.currentTimeMillis();
    CacheEntry entry = (CacheEntry) redisTemplate.opsForValue().get(key);
    if (entry == null || now >= entry.hardExpireAt) {
        List<DataRow> result = new ArrayList<>();
        return provider.query()
                .peek(result::add)
                .onClose(() -> saveEntry(key, result));
    }
    if (now < entry.softExpireAt) {
        return entry.value.stream();
    }
    asyncRefresh(sql, args, provider);
    return entry.value.stream();
}

整个过程使用异步刷新机制，避免使用同步块导致阻塞。

缓存写入策略软/硬过期时间其实最好还可以加一个随机数 10 - 50 左右，避免一些情况下缓存同时过期的问题，硬过期时间写入 redis 的缓存过期时间：

void saveEntry(@NotNull String key, List<DataRow> value) {
    long now = System.currentTimeMillis();
    CacheEntry entry = new CacheEntry();
    entry.value = value;
    entry.softExpireAt = now + 5000;
    entry.hardExpireAt = now + 60000;
    redisTemplate.opsForValue().set(key, entry, 60000, TimeUnit.MILLISECONDS);
}

激活缓存

如果仅仅只想对某些满足条件的 sql 才启用缓存，根据 SQL 名字或者参数包含某个键值来过滤，通过实现 isAvailable 方法：

@Override
public boolean isAvailable(@NotNull String sql, Map<String, ?> args) {
  	if(ALLOWS.containsKey(sql)){
      return true;
    }
    return false;
}

最后，一个强大且高性能的缓存管理器肯定不止于此！