Redis Key 没有设置过期时间,为什么数据还是丢了?
前言
最近遇到一个问题:系统里缓存了公众号菜单数据,Redis key 没有设置过期时间,但某一天菜单缓存却不见了。
第一反应很容易是:
没有设置过期时间,Redis 怎么会把数据删掉?
但这个理解其实不完整。
Redis 的过期时间只代表这个 key 不会因为 TTL 到期而被自动删除。它不代表这个 key 永久可靠,也不代表 Redis 重启、内存不足、主从切换、磁盘异常、容器重建、业务覆盖等情况下数据一定还在。
这次问题也提醒我们:Redis 更适合作为缓存,而不是业务数据的唯一存储。
一、业务背景
系统中有一个公众号菜单管理功能。
用户创建公众号菜单后,系统会调用微信接口创建菜单,然后把菜单 JSON 缓存在 Redis 中。后续页面展示菜单列表时,直接从 Redis 读取。
原来的代码如下。
java
@Override
public String menuCreate(String json, String appid) throws WxErrorException {
String mid = ContextHolder.getMid();
String msg = getWxMpService().switchoverTo(appid).getMenuService().menuCreate(json);
RMap<Object, Object> mapMenu = redissonClient.getMap(KeysHelper.createKVSKey(mid, RedisConst.WX, RedisConst.MENUS));
WxMenuDto menuListDto = WxMenuDto.builder().appid(appid).content(json).build();
mapMenu.put(appid, JSONObject.toJSONString(menuListDto));
log.info(GlobalLogMarker.get(), "公众号菜单保存成功{}", JSONObject.toJSONString(menuListDto));
if (msg == null) {
return "保存成功";
}
// 个性化菜单返回menuId
return msg;
}
@Override
public List<WxMenuDto> menuList() {
// 获取所有的APPID 遍历获取缓存menu
String mid = ContextHolder.getMid();
String appid = getAppIdByMpType(SystemConfigKeyEnum.CFG_APPID_STORE);
Collection<Object> menuList =
redissonClient.getMap(KeysHelper.createKVSKey(mid, RedisConst.WX, RedisConst.MENUS)).values();
ArrayList<WxMenuDto> list = new ArrayList<>(4);
if (!menuList.isEmpty()) {
menuList.forEach(m -> {
if ("".equals(m)) {
return;
}
list.add(JSON.parseObject((String) m, WxMenuDto.class));
});
}
return list;
}
@Override
public void menuDelete(String appid) throws WxErrorException {
String mid = ContextHolder.getMid();
getWxMpService().switchoverTo(appid).getMenuService().menuDelete();
RMap<Object, Object> map = redissonClient.getMap(KeysHelper.createKVSKey(mid, RedisConst.WX, RedisConst.MENUS));
map.put(appid, "");
}
@Override
public WxMpMenu menuGet(String appid) throws WxErrorException {
return getWxMpService().switchoverTo(appid).getMenuService().menuGet();
}
从代码看,Redis 中保存的数据结构大致是:
text
key = KeysHelper.createKVSKey(mid, RedisConst.WX, RedisConst.MENUS)
type = Hash,也就是 Redisson 的 RMap
field = appid
value = {"appid":"xxx","content":"菜单 JSON"}
也就是说,系统并不是给每个公众号菜单单独创建一个 Redis key,而是在一个 Redis Hash 中,以 appid 作为 field 存储菜单内容。
二、问题现象
问题表现为:
text
1. 公众号菜单之前创建成功;
2. Redis key 没有设置过期时间;
3. 过了一段时间后,页面查询菜单列表为空;
4. 业务侧认为 Redis 中的公众号菜单缓存丢失。
这类问题很容易被误判成:
text
Redis 没有 TTL,理论上不应该丢。
但 Redis 的真实机制并不是这样。
三、缓存丢失链路示意图
下面流程可以更直观地说明:公众号菜单从创建、写入 Redis,到后续查询异常为空,中间可能受到哪些因素影响。
四、Redis key 没有过期时间,为什么还可能丢?
1. 没有 TTL,只是不走过期删除机制
Redis 中的 key 可以设置 TTL。
例如:
bash
SET menu_cache xxx EX 3600
表示这个 key 3600 秒后过期。
如果一个 key 没有设置过期时间:
bash
TTL your_key
返回:
text
-1
表示这个 key 永不过期。
但这里的“永不过期”只表示:
text
Redis 不会因为时间到了而自动删除它。
它并不表示:
text
Redis 永远不会因为其他原因失去它。
Redis 数据仍然可能因为内存淘汰、重启恢复、磁盘异常、主从切换、容器重建、业务覆盖等原因消失。
五、Redis 的过期删除机制
Redis 对设置了 TTL 的 key,主要有两种删除方式。
1. 惰性删除
当客户端访问某个 key 时,Redis 会检查这个 key 是否过期。
如果过期,就删除它,并返回不存在。
例如:
bash
GET expired_key
Redis 发现这个 key 已经过期,于是删除。
这种方式的优点是简单,缺点是如果一个过期 key 一直没人访问,它可能会继续占用内存。
2. 定期删除
Redis 会周期性随机抽取一部分设置了过期时间的 key,检查它们是否过期。
如果过期,就删除。
这种方式不会一次性扫描所有 key,因为全量扫描成本太高,会影响 Redis 性能。
所以 Redis 的过期删除机制可以理解为:
text
惰性删除 + 定期抽样删除
注意,这套机制只针对设置了 TTL 的 key。
如果 key 没有 TTL,它不会因为过期机制被删除。
六、Redis 的内存淘汰机制
除了过期删除,Redis 还有一个非常重要的机制:内存淘汰机制。
当 Redis 使用的内存达到 maxmemory 限制后,Redis 会根据 maxmemory-policy 决定怎么处理。
查看配置:
bash
redis-cli CONFIG GET maxmemory
redis-cli CONFIG GET maxmemory-policy
如果配置了内存上限:
conf
maxmemory 2gb
当 Redis 内存超过 2GB 后,就会触发淘汰策略。
这时候,即使 key 没有 TTL,也可能被删除,具体取决于淘汰策略。
七、Redis 常见淘汰策略说明
Redis 的淘汰策略由 maxmemory-policy 控制。
常见策略如下。
1. noeviction
conf
maxmemory-policy noeviction
这是比较保守的策略。
当内存达到上限时,Redis 不会主动删除 key。
后续写入命令会失败,并返回错误。
特点:
text
不会因为内存不足删除已有数据;
但新写入可能失败;
适合不希望 Redis 自动淘汰数据的场景。
如果你的 Redis 是作为重要业务缓存,并且不希望无 TTL 的 key 被删,至少要确认是不是这个策略。
2. volatile-lru
conf
maxmemory-policy volatile-lru
只从设置了过期时间的 key 中,按照 LRU 算法淘汰。
LRU 是 Least Recently Used,意思是最近最少使用。
特点:
text
只淘汰有 TTL 的 key;
没有 TTL 的 key 不参与淘汰;
优先淘汰最近最少访问的 key。
如果公众号菜单 key 没有 TTL,在这个策略下一般不会因为内存淘汰被删除。
3. allkeys-lru
conf
maxmemory-policy allkeys-lru
从所有 key 中,按照 LRU 算法淘汰。
特点:
text
所有 key 都可能被淘汰;
包括没有 TTL 的 key;
优先淘汰最近最少访问的 key。
如果生产 Redis 使用这个策略,那么公众号菜单 key 即使没有过期时间,也可能被 Redis 淘汰。
这是非常常见的“无 TTL key 丢失”原因。
4. volatile-lfu
conf
maxmemory-policy volatile-lfu
只从设置了过期时间的 key 中,按照 LFU 算法淘汰。
LFU 是 Least Frequently Used,意思是最不经常使用。
特点:
text
只淘汰有 TTL 的 key;
根据访问频率判断;
访问频率越低,越容易被淘汰。
5. allkeys-lfu
conf
maxmemory-policy allkeys-lfu
从所有 key 中,按照 LFU 算法淘汰。
特点:
text
所有 key 都可能被淘汰;
包括没有 TTL 的 key;
访问频率低的 key 更容易被淘汰。
如果公众号菜单不经常访问,就可能在内存压力下被淘汰。
6. volatile-random
conf
maxmemory-policy volatile-random
只从设置了过期时间的 key 中随机淘汰。
特点:
text
只淘汰有 TTL 的 key;
随机删除;
没有 TTL 的 key 一般不会被淘汰。
7. allkeys-random
conf
maxmemory-policy allkeys-random
从所有 key 中随机淘汰。
特点:
text
所有 key 都可能被淘汰;
包括没有 TTL 的 key;
删除对象随机。
如果 Redis 使用这个策略,无 TTL 的公众号菜单 key 也可能被随机删除。
8. volatile-ttl
conf
maxmemory-policy volatile-ttl
只从设置了过期时间的 key 中淘汰,并优先淘汰剩余 TTL 较短的 key。
特点:
text
只淘汰有 TTL 的 key;
越快过期的 key 越容易被淘汰;
没有 TTL 的 key 一般不会被淘汰。
八、简单总结淘汰策略
可以粗略分成三类。
text
1. 不淘汰
noeviction
2. 只淘汰设置了过期时间的 key
volatile-lru
volatile-lfu
volatile-random
volatile-ttl
3. 所有 key 都可能被淘汰
allkeys-lru
allkeys-lfu
allkeys-random
所以判断一个没有 TTL 的 key 会不会因为内存不足被删,重点看是不是 allkeys-* 策略。
如果是:
text
allkeys-lru
allkeys-lfu
allkeys-random
那么无过期时间的 key 也可能被淘汰。
排查命令:
bash
redis-cli INFO stats | grep evicted_keys
如果 evicted_keys 大于 0,并且还在增长,说明 Redis 发生过内存淘汰。
九、除了淘汰,还有哪些原因会导致 Redis 数据丢失?
1. Redis 没有开启持久化
Redis 是内存数据库。
如果没有开启 RDB 或 AOF:
conf
save ""
appendonly no
那么 Redis 重启后,内存数据就会丢失。
这时候 key 有没有 TTL 都不重要,因为 Redis 重启后根本没有可恢复的数据文件。
2. RDB 快照没有覆盖最近写入
RDB 是快照机制。
例如:
conf
save 900 1
save 300 10
save 60 10000
意思是 Redis 满足一定写入条件后,才会生成快照。
如果公众号菜单刚写入 Redis,还没来得及生成下一次 RDB 快照,Redis 就宕机了,那么重启后这次写入可能丢失。
RDB 的特点是:
text
性能好;
恢复速度快;
但可能丢失最近一次快照后的数据。
3. AOF 刷盘策略导致少量数据丢失
AOF 会记录 Redis 写命令,恢复时重放这些命令。
常见配置:
conf
appendonly yes
appendfsync everysec
appendfsync everysec 表示大约每秒刷盘一次。
这种配置性能和可靠性比较均衡,但极端情况下,Redis 宕机时可能丢失最近 1 秒左右的数据。
如果是:
conf
appendfsync no
则刷盘时机交给操作系统,丢失窗口可能更大。
如果是:
conf
appendfsync always
每次写入都刷盘,可靠性更高,但性能损耗更大。
4. 磁盘空间不足导致 RDB/AOF 失败
如果磁盘满了,Redis 的持久化可能失败。
例如:
text
RDB 保存失败;
AOF 写入失败;
AOF rewrite 失败;
Redis 重启后只能恢复旧数据。
排查命令:
bash
df -h
redis-cli INFO persistence
重点关注:
text
rdb_last_bgsave_status
aof_last_write_status
aof_last_bgrewrite_status
如果看到失败,就需要检查 Redis 日志和磁盘空间。
5. 主从复制或哨兵切换导致数据回退
Redis 主从复制默认是异步的。
可能出现这种情况:
text
1. 菜单写入 Redis 主节点;
2. 主节点返回写入成功;
3. 数据还没同步到从节点;
4. 主节点宕机;
5. 哨兵把从节点提升为新主;
6. 新主没有刚才那条菜单数据。
这时候业务看到的现象就是:
text
刚刚还在的数据,切换后没了。
这不是 TTL 过期,也不是 Redis 主动删除,而是异步复制和故障切换带来的数据回退。
6. Docker 容器重建导致数据文件丢失
如果 Redis 跑在 Docker 中,但没有正确挂载 /data 目录:
yaml
volumes:
- ./redis-data:/data
那么容器删除重建后,容器内部的数据文件可能也被删除。
这会导致 Redis 重启后没有历史数据。
排查方向:
bash
docker inspect redis容器名
docker logs redis容器名
重点看 Redis 数据目录有没有挂载到宿主机。
7. 业务代码主动写入了空字符串
这次代码中还有一个容易忽略的点。
删除菜单时,代码不是删除 Redis Hash 的 field,而是写入了空字符串。
java
map.put(appid, "");
然后查询时又跳过空字符串:
java
if ("".equals(m)) {
return;
}
所以如果有人调用过 menuDelete,Redis 里并不是没有这个 field,而是:
text
field = appid
value = ""
页面展示时会过滤掉它,于是看起来就像菜单数据丢失了。
这类问题不属于 Redis 丢数据,而是业务逻辑把数据覆盖成空值。
更清晰的写法是:
java
map.remove(appid);
或者保存明确的删除状态:
json
{
"appid": "xxx",
"deleted": true,
"content": ""
}
8. mid 或 Redis key 变化导致读错位置
这段代码中的 Redis key 依赖 mid。
java
String mid = ContextHolder.getMid();
KeysHelper.createKVSKey(mid, RedisConst.WX, RedisConst.MENUS)
如果 mid 发生变化,读写的 key 就不是同一个。
例如保存时:
text
kvs:10001:wx:menus
查询时:
text
kvs:null:wx:menus
或者:
text
kvs:10002:wx:menus
业务上就会表现为:
text
菜单缓存不见了。
但实际上可能是读错了 Redis key。
建议日志中打印:
java
String key = KeysHelper.createKVSKey(mid, RedisConst.WX, RedisConst.MENUS);
log.info("公众号菜单缓存 key={}, mid={}, appid={}", key, mid, appid);
9. Redis DB 或环境配置切换
还有一种常见情况是应用连接到了另一个 Redis。
例如:
text
Nacos 配置变更;
Redis 地址变更;
Redis database 从 db0 切到 db1;
测试环境和生产环境混用;
Redisson 配置发生变化;
key 前缀发生变化。
这种情况下,原 Redis 里可能还有数据,但应用已经读另一个 Redis 了。
十、本次代码设计导致的问题
从这段代码看,最大的问题是:
text
公众号菜单数据只保存在 Redis 中。
Redis 一旦异常,系统本地就没有可靠数据源可以恢复。
也就是说,Redis 在这里不是普通缓存,而是被当成了事实数据源。
这会带来几个问题:
text
1. Redis 数据被淘汰后,菜单列表无法恢复;
2. Redis 重启恢复不完整后,菜单列表为空;
3. 业务删除写入空字符串,容易误判为数据丢失;
4. 查询时没有回源逻辑;
5. 缺少 Redis key、mid、appid 等关键日志,排查困难。
十一、改进方案一:菜单配置落库
更稳妥的方式是把公众号菜单作为业务配置落到 MySQL 中。
推荐链路:
text
创建菜单
-> 保存菜单配置到 MySQL
-> 调用微信 menuCreate
-> 成功后更新 Redis
-> 返回结果
查询链路:
text
查询菜单列表
-> 优先读 Redis
-> Redis 没有数据
-> 查询 MySQL
-> MySQL 有数据则回填 Redis
-> 返回菜单列表
这样 Redis 只是缓存。
即使 Redis 数据丢了,也可以通过 MySQL 回填。
十二、改进方案二:增加“同步公众号当前菜单”按钮
除了落库,还可以增加一个功能:
text
同步公众号当前菜单
这个按钮的作用是:
text
调用微信 menuGet 接口;
获取公众号当前线上菜单;
转换成系统需要的 WxMenuDto;
重新写入 Redis;
必要时同时更新 MySQL。
也就是说,当 Redis 菜单缓存丢失时,可以从微信侧重新拉取一份当前菜单。
这个方案是有价值的。
因为公众号菜单真实生效的位置其实在微信平台。
如果 Redis 丢失,但微信侧菜单还在,那么系统可以通过 menuGet 重新同步回来。
可以理解成:
text
MySQL 是系统侧事实数据源;
微信平台是线上生效数据源;
Redis 是缓存层。
增加同步按钮后,系统具备了从微信侧修复缓存的能力。
十三、这个“同步按钮”是不是就能完全避免数据丢失?
不能完全避免,但能显著提升恢复能力。
它解决的是:
text
Redis 缓存丢失后,可以从微信侧重新拉取当前菜单。
但它不等于完整的数据可靠性方案。
原因是:
text
1. 微信 menuGet 获取的是当前线上菜单,不一定包含系统编辑时的完整配置状态;
2. 如果系统有草稿菜单、历史版本、审核状态、个性化菜单规则,只靠微信接口可能恢复不完整;
3. 如果微信侧菜单也被删除了,Redis 也丢了,那就没有来源可以恢复;
4. 如果菜单 JSON 中有系统内部扩展字段,微信侧不一定能返回。
所以更推荐的最终方案是:
text
MySQL 落库 + Redis 缓存 + 微信侧同步按钮
三者职责分别是:
text
MySQL:保存系统自己的菜单配置,作为可靠数据源;
Redis:提高查询速度,作为缓存;
微信接口:同步线上真实生效菜单,用于校验和修复。
这不是简单“双向同步”就万无一失,而是建立了多个恢复来源。
十四、建议调整后的业务流程
创建菜单:
text
1. 校验菜单 JSON;
2. 写入 MySQL,状态为待同步;
3. 调用微信 menuCreate;
4. 微信创建成功;
5. 更新 MySQL 状态为已同步;
6. 写入 Redis;
7. 返回成功。
查询菜单:
text
1. 优先查询 Redis;
2. Redis 命中,直接返回;
3. Redis 未命中,查询 MySQL;
4. MySQL 命中,回填 Redis;
5. MySQL 未命中,可以提示未配置,或提供从微信同步按钮。
删除菜单:
text
1. 调用微信 menuDelete;
2. 更新 MySQL 菜单状态为已删除;
3. 删除 Redis 中对应 appid 的 field。
同步公众号当前菜单:
text
1. 用户点击同步按钮;
2. 调用微信 menuGet;
3. 获取当前线上菜单;
4. 转换成系统菜单 DTO;
5. 写入 MySQL;
6. 回填 Redis;
7. 返回同步成功。
十五、删除逻辑建议调整
原来的代码:
java
map.put(appid, "");
建议改成:
java
map.remove(appid);
如果需要记录删除状态,应该放到数据库里,而不是在 Redis 中写空字符串。
例如数据库中记录:
text
appid
menu_content
status: NORMAL / DELETED
update_time
sync_time
这样语义更清晰,也方便排查。
十六、建议增加关键日志
当前日志只打印了保存成功:
java
log.info(GlobalLogMarker.get(), "公众号菜单保存成功{}", JSONObject.toJSONString(menuListDto));
建议补充 Redis key、mid、appid:
java
String key = KeysHelper.createKVSKey(mid, RedisConst.WX, RedisConst.MENUS);
log.info(GlobalLogMarker.get(), "公众号菜单保存成功 key={}, mid={}, appid={}, content={}",
key, mid, appid, JSONObject.toJSONString(menuListDto));
查询时也建议打印:
java
log.info(GlobalLogMarker.get(), "查询公众号菜单缓存 key={}, mid={}", key, mid);
删除时打印:
java
log.info(GlobalLogMarker.get(), "删除公众号菜单缓存 key={}, mid={}, appid={}", key, mid, appid);
这样后续排查时,可以快速判断:
text
是不是读写同一个 key;
是不是 mid 变化;
是不是 appid 不一致;
是不是 Redis 环境切换。
十七、排查命令清单
查看 key 是否存在:
bash
redis-cli EXISTS your_key
查看 key 类型:
bash
redis-cli TYPE your_key
查看 Hash 内容:
bash
redis-cli HGETALL your_key
查看 TTL:
bash
redis-cli TTL your_key
返回值含义:
text
-2:key 不存在
-1:key 存在,但没有过期时间
>=0:剩余过期时间,单位秒
查看内存配置:
bash
redis-cli CONFIG GET maxmemory
redis-cli CONFIG GET maxmemory-policy
查看是否发生过淘汰:
bash
redis-cli INFO stats | grep evicted_keys
查看内存使用:
bash
redis-cli INFO memory
查看持久化状态:
bash
redis-cli INFO persistence
查看主从状态:
bash
redis-cli INFO replication
查看 Redis 服务信息:
bash
redis-cli INFO server
查看磁盘空间:
bash
df -h
Docker 环境查看容器挂载:
bash
docker inspect redis容器名
十八、总结
Redis key 没有设置过期时间,并不代表数据永远不会丢。
更准确的说法是:
text
没有 TTL 的 key 不会因为过期机制被删除;
但仍可能因为内存淘汰、Redis 重启、持久化失败、磁盘空间不足、主从切换、容器重建、配置变化、业务覆盖等原因消失。
对于公众号菜单这种业务配置数据,不能只依赖 Redis。
更合理的方案是:
text
MySQL 作为可靠数据源;
Redis 作为缓存;
微信接口作为线上菜单同步来源;
提供“同步公众号当前菜单”按钮,用于从微信侧恢复当前生效菜单。
最终目标不是保证 Redis 永远不丢数据,而是做到:
text
Redis 丢了,可以恢复;
缓存没了,可以回源;
线上菜单和系统菜单不一致时,可以重新同步;
排查问题时,有日志和命令可以快速定位。
这才是比较稳妥的缓存设计方式。