Redis在Java项目中的常见应用与踩坑实践

大量请求
  -> 重复查询相同数据
  -> 数据库连接池被占满
  -> cpu、磁盘和锁竞争升高
  -> 接口延迟增加

第一次请求
  -> 查询数据库
  -> 写入 redis
  -> 返回结果

后续请求
  -> 直接读取 redis
  -> 减少数据库访问

数据库：权威数据
redis：加速副本

查询缓存
  -> 命中：直接返回
  -> 未命中：查询数据库
  -> 写入缓存
  -> 返回结果

更新数据库
  -> 删除缓存

实际 ttl = 基础 ttl + 随机时间

先更新数据库
再删除缓存

先删除缓存
再更新数据库

请求不存在的 id
  -> redis 未命中
  -> 数据库也没有
  -> 不写缓存
  -> 下次请求重复打数据库

热点 key 过期
  -> 大量请求同时查询数据库
  -> 数据库瞬间承受高并发

大量 key 同时失效
  -> 请求集中访问数据库

redis 故障
  -> 所有缓存请求失败
  -> 流量直接压向数据库

set lock:order:100 unique-token nx ex 30

多个请求发现缓存失效
  -> 尝试获取 rebuild-lock
  -> 只有一个请求获得锁
  -> 获得锁的请求查询数据库并写缓存
  -> 其他请求等待、重试或读取旧值

读取 lock key 的 value
  -> 判断 value 是否等于自己的 unique-token
  -> 相等才删除
  -> 不相等则不能删除

客户端 a 读取到自己的 token
锁刚好过期
客户端 b 获取了新锁
客户端 a 执行 del
客户端 b 的锁被误删

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-data-redis</artifactid>
</dependency>

@configuration
public class redisconfig {
    @bean
    public redistemplate<string, object> redistemplate(
            redisconnectionfactory factory) {
        redistemplate<string, object> template =
                new redistemplate<>();
        template.setconnectionfactory(factory);
        stringredisserializer keyserializer =
                new stringredisserializer();
        genericjackson2jsonredisserializer valueserializer =
                new genericjackson2jsonredisserializer();
        template.setkeyserializer(keyserializer);
        template.sethashkeyserializer(keyserializer);
        template.setvalueserializer(valueserializer);
        template.sethashvalueserializer(valueserializer);
        template.afterpropertiesset();
        return template;
    }
}

public final class rediskeys {
    private rediskeys() {
    }
    public static string product(long productid) {
        return "cache:product:" + productid;
    }
    public static string productrebuildlock(long productid) {
        return "lock:product:rebuild:" + productid;
    }
    public static string ratelimit(
            string userid,
            string api) {
        return "ratelimit:" + userid + ":" + api;
    }
}

@service
public class productcacheservice {
    private static final duration cache_ttl =
            duration.ofminutes(10);
    private final stringredistemplate redistemplate;
    private final productrepository productrepository;
    private final objectmapper objectmapper;
    public productcacheservice(
            stringredistemplate redistemplate,
            productrepository productrepository,
            objectmapper objectmapper) {
        this.redistemplate = redistemplate;
        this.productrepository = productrepository;
        this.objectmapper = objectmapper;
    }
    public productview findbyid(long productid) {
        string key = rediskeys.product(productid);
        string cached = redistemplate.opsforvalue().get(key);
        if (cached != null) {
            if (cached.isempty()) {
                return null;
            }
            return readproduct(cached);
        }
        productview product = productrepository.findviewbyid(productid);
        if (product == null) {
            redistemplate.opsforvalue().set(
                    key,
                    "",
                    duration.ofseconds(30)
            );
            return null;
        }
        redistemplate.opsforvalue().set(
                key,
                writeproduct(product),
                withjitter(cache_ttl)
        );
        return product;
    }
    private duration withjitter(duration base) {
        long jitter = threadlocalrandom.current()
                .nextlong(0, 60);
        return base.plusseconds(jitter);
    }
    private productview readproduct(string value) {
        try {
            return objectmapper.readvalue(
                    value,
                    productview.class
            );
        } catch (jsonprocessingexception exception) {
            throw new cacheserializationexception(
                    "缓存数据格式错误",
                    exception
            );
        }
    }
    private string writeproduct(productview product) {
        try {
            return objectmapper.writevalueasstring(product);
        } catch (jsonprocessingexception exception) {
            throw new cacheserializationexception(
                    "缓存数据序列化失败",
                    exception
            );
        }
    }
}

redis 读取失败
  -> 是否允许直接查询数据库
  -> 是否需要限流
  -> 是否返回降级数据
  -> 是否记录 redis 故障指标

@transactional
public void updateproduct(
        long productid,
        updateproductcommand command) {
    productrepository.update(
            productid,
            command.name(),
            command.price()
    );
    string key = rediskeys.product(productid);
    redistemplate.delete(key);
}

更新业务数据
  -> 写入本地消息表
  -> 事务提交
  -> 异步发送缓存失效事件
  -> redis 删除
  -> 失败重试

@component
public class redislockservice {
    private static final defaultredisscript<long>
            unlock_script = new defaultredisscript<>(
                    "if redis.call('get', keys[1]) == argv[1] "
                    + "then "
                    + "return redis.call('del', keys[1]) "
                    + "else "
                    + "return 0 "
                    + "end",
                    long.class
            );
    private final stringredistemplate redistemplate;
    public redislockservice(
            stringredistemplate redistemplate) {
        this.redistemplate = redistemplate;
    }
    public boolean trylock(
            string key,
            string token,
            duration ttl) {
        boolean success = redistemplate.opsforvalue().setifabsent(
                key,
                token,
                ttl
        );
        return boolean.true.equals(success);
    }
    public boolean unlock(
            string key,
            string token) {
        long result = redistemplate.execute(
                unlock_script,
                list.of(key),
                token
        );
        return long.valueof(1).equals(result);
    }
}

public productview findwithrebuildlock(long productid) {
    productview product = findfromcache(productid);
    if (product != null) {
        return product;
    }
    string key = rediskeys.productrebuildlock(productid);
    string token = uuid.randomuuid().tostring();
    if (lockservice.trylock(
            key,
            token,
            duration.ofseconds(10))) {
        try {
            product = findfromcache(productid);
            if (product != null) {
                return product;
            }
            product = productrepository.findviewbyid(productid);
            writecache(productid, product);
            return product;
        } finally {
            lockservice.unlock(key, token);
        }
    }
    return waitandretry(productid);
}

@component
public class ratelimiter {
    private final stringredistemplate redistemplate;
    public ratelimiter(
            stringredistemplate redistemplate) {
        this.redistemplate = redistemplate;
    }
    public boolean allow(
            string key,
            int limit,
            duration window) {
        long count = redistemplate.opsforvalue()
                .increment(key);
        if (long.valueof(1).equals(count)) {
            redistemplate.expire(key, window);
        }
        return count != null && count <= limit;
    }
}

private static final defaultredisscript<long>
        rate_limit_script = new defaultredisscript<>(
                "local current = redis.call('incr', keys[1]) "
                + "if current == 1 then "
                + "redis.call('expire', keys[1], argv[1]) "
                + "end "
                + "if current <= tonumber(argv[2]) then "
                + "return 1 "
                + "else "
                + "return 0 "
                + "end",
                long.class
        );
public boolean allow(
        string key,
        int limit,
        duration window) {
    long result = redistemplate.execute(
            rate_limit_script,
            list.of(key),
            string.valueof(window.toseconds()),
            string.valueof(limit)
    );
    return long.valueof(1).equals(result);
}

public void addscore(
        long userid,
        double score) {
    redistemplate.opsforzset().add(
            "ranking:weekly",
            userid.tostring(),
            score
    );
}
public set<zsetoperations.typedtuple<string>> top(
        int limit) {
    return redistemplate.opsforzset()
            .reverserangewithscores(
                    "ranking:weekly",
                    0,
                    limit - 1
            );
}

环境:业务域:资源类型:租户:资源id

prod:order:detail:tenant-a:10001

09:00 大量缓存写入，ttl 都是 10 分钟
09:10 大量缓存同时过期
09:10 大量请求回源数据库

线程 a：读取数据库旧值
线程 b：更新数据库并删除缓存
线程 a：把旧值写入缓存

redistemplate.delete(lockkey);

缓存故障
  -> 是否允许直读数据库
  -> 是否对回源限流
  -> 是否返回静态兜底
  -> 是否暂时关闭非核心功能
  -> 是否告警并自动恢复

redis 响应变慢
  -> 应用超时重试
  -> redis 收到更多请求
  -> 响应更慢
  -> 更多请求重试

本地缓存
  -> redis
      -> 数据库
          -> 下游服务

order:{10001}:detail
order:{10001}:items

redis 中的数据是否允许丢失
redis 重启后是否能恢复
恢复需要多长时间
主从切换会不会丢数据
消息是否需要重新消费
数据库是否仍然保存权威数据

识别热点 key
  -> 分批加载
  -> 控制并发
  -> 设置随机 ttl
  -> 校验缓存内容
  -> 开放流量

是否明确 redis 中数据的权威来源
是否为缓存设置 ttl
是否处理空值和热点 key
是否控制 key 长度和大对象
是否避免生产使用 keys
是否设置连接和命令超时
是否配置合理重试和熔断
是否验证序列化兼容
是否隔离租户和环境
是否保护敏感信息
是否监控命中率、回源和内存
是否演练 redis 故障和恢复