Redis Key 没有设置过期时间,为什么数据还是丢了?

2026-07-29后端13 分钟110 次阅读
AI 摘要鱼粮不足,AI 今天先歇着 · 正文在下面

前言

最近遇到一个问题:系统里缓存了公众号菜单数据,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,到后续查询异常为空,中间可能受到哪些因素影响。

flowchart TB A["公众号菜单保存"] --> B["调用微信 menuCreate 成功"] B --> C["写入 Redis Hash"] C --> D["后续查询只读 Redis"] D --> E["Redis 数据异常为空"] E --> F["内存淘汰"] E --> G["Redis 重启"] E --> H["RDB / AOF 持久化失败"] E --> I["主从切换导致数据回退"] E --> J["Docker 容器重建或数据卷丢失"] E --> K["业务代码写入空字符串"] E --> L["mid / Redis DB / 环境配置变化导致读错 key"] F --> F1["allkeys-lru / allkeys-lfu / allkeys-random<br/>无 TTL key 也可能被淘汰"] G --> G1["RDB 快照未覆盖最近写入<br/>或 AOF 未及时刷盘"] H --> H1["磁盘空间不足<br/>AOF rewrite 失败<br/>RDB bgsave 失败"] I --> I1["Redis 主从复制默认异步<br/>故障切换后新主缺少最近写入"] J --> J1["Redis /data 未正确挂载到宿主机"] K --> K1["menuDelete 中 map.put(appid, '\')<br/>查询时过滤空字符串"] L --> L1["ContextHolder.getMid 变化<br/>database / key 前缀 / Redis 地址变化"] E --> M["改进方案"] M --> N["MySQL 落库作为可靠数据源"] M --> O["Redis 只作为缓存"] M --> P["增加同步公众号当前菜单按钮"] P --> Q["调用微信 menuGet<br/>回填 MySQL 和 Redis"] classDef main fill:#e0f2fe,stroke:#0284c7,color:#0f172a,stroke-width:1.5px; classDef problem fill:#fee2e2,stroke:#dc2626,color:#7f1d1d,stroke-width:1.5px; classDef reason fill:#fff7ed,stroke:#f97316,color:#7c2d12,stroke-width:1.5px; classDef fix fill:#dcfce7,stroke:#16a34a,color:#14532d,stroke-width:1.5px; class A,B,C,D main; class E problem; class F,G,H,I,J,K,L,F1,G1,H1,I1,J1,K1,L1 reason; class M,N,O,P,Q fix;

四、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 丢了,可以恢复;
缓存没了,可以回源;
线上菜单和系统菜单不一致时,可以重新同步;
排查问题时,有日志和命令可以快速定位。

这才是比较稳妥的缓存设计方式。

觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句