1. 项目背景
1.1 业务场景
商城有两个实时通知需求:
第一,配置中心。运营团队管理着首页活动开关、优惠券文案、风控阈值和缓存清理策略。原来的做法是每台应用服务器每 30 秒轮询一次数据库的配置表——60 台服务器 × 每分钟 2 次轮询 = 120 次/分钟的数据库查询,而这些配置一天才改 3-5 次。99.9% 的查询是浪费。而且 30 秒的轮询间隔意味着配置变更后最长需要 30 秒才能生效——运营在活动开始前改完配置,焦急等待半分钟才能验证效果。
第二,订单过期提醒。订单创建后 15 分钟未支付需自动关闭。原本用定时任务每分钟扫描 WHERE status='WAIT_PAY' AND created_at < NOW()-15min——扫描频率太低则关闭不及时(用户多等 1 分钟),太高则数据库压力大。
这两个需求本质都是"有人发布事件,多个服务需要感知"。引入 Kafka 显得重(需要额外运维),用数据库轮询显得笨(低效且延迟大)。Redis Pub/Sub 正好处于中间——轻量、低延迟、适合实时通知。但它有明确的边界:消息不持久、不重放、无消费确认、订阅者离线即丢失。
1.2 Pub/Sub vs Stream vs List
| 特性 | Pub/Sub | Stream | List |
|---|---|---|---|
| 消息持久化 | 不持久 | 持久 | 取走即删 |
| 离线消息 | 丢失 | 保留 | 堆积 |
| 消费确认 | 无 | XACK | 无 |
| 广播能力 | 原生广播 | 多消费组 | 需多消费者 |
| 延迟 | 极低 | 低 | 低 |
| 适合场景 | 实时通知、配置刷新 | 可靠事件流 | 轻量任务队列 |
1.3 本章目标
- 掌握
PUBLISH/SUBSCRIBE/PSUBSCRIBE实现多服务广播。 - 使用 Keyspace Notification 监听 Redis key 过期事件。
- 理解 Pub/Sub 的可靠性边界——消息丢了怎么办。
- 建立"通知与事实分离"的架构原则。
2. 项目设计
2.1 第一幕:Pub/Sub 像现场广播,不像快递签收
小胖:"这不就是微信群通知吗?运营一改配置,往 Redis 频道里喊一声,所有服务都刷新缓存,多省事!"
小白:"微信群有历史消息——你离线后再上线能看到之前的消息。Pub/Sub 有吗?假如某个服务刚好重启了 10 秒,运营在这 10 秒内发了配置变更消息——服务恢复后能收到吗?"
大师:"不能。Pub/Sub 是'现场广播'——消息只推送给发布瞬间在线的订阅者。它不是快递签收,没有签收记录、没有补发机制。所以配置中心不能只依赖 Pub/Sub——它只能做'通知管道',真正的配置数据必须存在数据库、Redis key 或配置中心里,服务收到通知后再去拉取最新值。"
Pub/Sub 的可靠性模型:
PUBLISH 发布
│
▼
Redis 遍历当前在线订阅者列表
│
├── 订阅者 A 在线 → 收到消息 ✓
├── 订阅者 B 在线 → 收到消息 ✓
└── 订阅者 C 离线 → 消息消失 ✗(不会补发)
关键约束:
消息 == 不持久、不重放、不补发
可靠性 == 需要业务侧补偿
技术映射:PUBLISH channel message 返回收到消息的订阅者数量。这个数字只表示"多少在线订阅连接收到了",不表示"多少业务处理成功了"。
2.2 第二幕:过期事件是门铃,不是闹钟
小胖:"那订单超时提醒——我给 order:timeout:1001 设 15 分钟 TTL,到期 Redis 自动通知我,我不就不用轮询了?"
小白:"Redis 的过期删除不是精确闹钟。惰性删除只在 key 被访问时触发,定期删除每次只抽样检查少量 key。一个 key 过期后可能还要好几秒甚至更久才被真正删除并触发事件。而且 Keyspace Notification 默认是关闭的。"
大师:"过期事件适合提醒,不适合当唯一事实来源。把它理解成'门铃'——响了就去看门,没响也不能假设没人来。订单关闭必须以订单表状态为准。过期事件可以触发一次检查(省去轮询),但一定要配合定时任务做兜底扫描。"
过期事件的不可靠因素:
1. Redis 过期删除策略: 惰性删除 + 定期抽样 → 不保证立即删除
2. Keyspace Notification: 默认关闭 → 需主动开启
3. Pub/Sub 传输: 订阅者离线 → 事件丢失
4. 主从/集群: 事件可能在不同节点触发
5. 可靠性保障: 必须以数据库状态为最终事实 + 定时补扫
技术映射:开启 notify-keyspace-events Ex 后,Redis 会向 __keyevent@<db>__:expired 频道发布过期事件。但事件可靠性受限于上述五个因素。
2.3 第三幕:通知与事实分离
小白:"那到底怎么设计才能既享受 Pub/Sub 的低延迟,又不担心消息丢失?"
大师:"核心原则是'通知与事实分离'——Pub/Sub 只负责说'可能有变化了',事实永远存放在可查询的地方。具体模式有三:
模式 1: 配置变更通知
PUBLISH config:changed {"key":"coupon.switch", "version":12}
→ 服务收到后: GET config:coupon.switch (主动拉取最新值)
→ 即使没收到消息: 每 5 分钟定时 GET config:* (兜底校验)
→ 即使 Redis 重启: 配置数据在数据库中有完整备份
模式 2: 缓存失效通知
PUBLISH cache:invalidated "product:1001"
→ 服务收到后: DEL product:1001 (删除本地/Redis缓存)
→ 即使没收到: 缓存有 TTL,到期自然失效
→ 损失: 最多 TTL 时间内读到旧数据
模式 3: 订单过期提醒
SET order:timeout:1001 "pending" EX 900 + 订阅 __keyevent@0__:expired
→ 收到事件后: 检查订单表状态 → 决定是否关闭
→ 即使没收到: 定时任务每分钟扫描超时订单
→ 双重保障: 事件触发 + 定时扫表
技术映射:Pub/Sub 做"最佳努力的即时通知",数据库/Redis key 做"可查询的事实来源",定时任务做"最终的兜底保障"。三层各自独立,互不依赖。
3. 项目实战
3.1 环境准备
docker exec -it redis-lab redis-cli -a redis123
开启 Keyspace Notification(学习环境):
127.0.0.1:6379> CONFIG SET notify-keyspace-events Ex
OK
127.0.0.1:6379> CONFIG GET notify-keyspace-events
1) "notify-keyspace-events"
2) "Ex"
参数含义:E=启用过期事件,x=过期事件。更多选项:K(keyspace)、E(keyevent)、g(通用)、$(字符串)、l(列表)、s(集合)、h(哈希)、z(有序集合)、t(流)、e(淘汰)、A(全部)。生产通常设 "Ex" 只开启过期事件。
3.2 实战一:配置变更广播
步骤 1:订阅频道
打开两个终端订阅同一频道:
# 终端 A:
127.0.0.1:6379> SUBSCRIBE config:changed
1) "subscribe"
2) "config:changed"
3) (integer) 1
# 终端 B:
127.0.0.1:6379> SUBSCRIBE config:changed
1) "subscribe"
2) "config:changed"
3) (integer) 1
步骤 2:发布消息
# 终端 C: 模拟运营后台发布配置变更
127.0.0.1:6379> SET config:coupon.switch "{\"enabled\":true,\"version\":12}"
OK
127.0.0.1:6379> PUBLISH config:changed "{\"key\":\"coupon.switch\",\"version\":12}"
(integer) 2 # 2 个订阅者在线
步骤 3:观察订阅端收到消息
终端 A 和 B 都会收到:
1) "message"
2) "config:changed"
3) "{\"key\":\"coupon.switch\",\"version\":12}"
步骤 4:Java 配置中心订阅实现
@Component
public class ConfigSubscriber {
// 订阅连接(不能和普通命令共用)
private final RedisConnection subscriberConn;
@PostConstruct
public void init() {
// 为订阅单独创建连接
RedisConnectionFactory factory = new LettuceConnectionFactory();
factory.afterPropertiesSet();
subscriberConn = factory.getConnection();
// 订阅频道
subscriberConn.subscribe((message, pattern) -> {
String body = new String(message.getBody());
ConfigChangeEvent event = parseEvent(body);
// 1. 检查版本号(防旧消息覆盖新配置)
int currentVersion = getCurrentVersion(event.getKey());
if (event.getVersion() <= currentVersion) {
return; // 忽略旧消息
}
// 2. 主动从 Redis/数据库拉取最新配置(不依赖消息体!)
String latestConfig = redis.get("config:" + event.getKey());
if (latestConfig == null) {
latestConfig = database.getConfig(event.getKey());
}
// 3. 应用新配置
applyConfig(latestConfig);
}, "config:changed".getBytes());
}
}
3.3 实战二:过期订单提醒
步骤 1:订阅过期事件
# 用 PSUBSCRIBE 匹配模式订阅
127.0.0.1:6379> PSUBSCRIBE __keyevent@0__:expired
1) "psubscribe"
2) "__keyevent@0__:expired"
3) (integer) 1
步骤 2:创建带 TTL 的订单提醒 key
# 另一个终端:
127.0.0.1:6379> SET order:timeout:1001 "pending" EX 10
OK
步骤 3:观察过期事件
约 10 秒后,订阅端收到:
1) "pmessage"
2) "__keyevent@0__:expired"
3) "__keyevent@0__:expired" # pattern
4) "order:timeout:1001" # 过期的 key 名
步骤 4:Java 过期事件处理
@Component
public class OrderTimeoutListener {
@PostConstruct
public void init() {
// 开启过期事件监听(单独连接)
RedisConnection conn = createSubscriberConnection();
conn.subscribe((message, pattern) -> {
String expiredKey = new String(message.getBody()); // "order:timeout:1001"
String orderId = extractOrderId(expiredKey); // "1001"
// 1. 先查数据库确认订单状态
Order order = orderRepository.findById(orderId);
if (order == null || !"WAIT_PAY".equals(order.getStatus())) {
return; // 已处理或不存在,忽略
}
// 2. 执行关闭操作
closeOrder(orderId);
}, "__keyevent@0__:expired".getBytes());
}
// 兜底:定时任务补扫(不管是否收到过期事件)
@Scheduled(fixedDelay = 60000)
public void scanTimeoutOrders() {
List<String> timeoutOrders = orderRepository.findTimeoutOrders(15);
for (String orderId : timeoutOrders) {
closeOrder(orderId);
}
}
}
3.4 实战三:缓存失效广播
# 订阅
127.0.0.1:6379> SUBSCRIBE cache:invalidated
# 运营后台/管理端发布
127.0.0.1:6379> PUBLISH cache:invalidated "product:1001"
(integer) 1
# 服务收到后删除本地缓存和 Redis 缓存
# 1. redis.DEL mall:cache:product:1001
# 2. localCache.invalidate("product:1001")
缓存失效的多级通知:
public class CacheInvalidationService {
// 发送失效通知
public void invalidateCache(String key) {
// 1. 删除 Redis 缓存(L2)
redis.del(key);
// 2. 发布广播(通知所有服务删除 L1 本地缓存)
redis.convertAndSend("cache:invalidated", key);
}
// 接收失效通知
@PostConstruct
public void listen() {
subscriberConn.subscribe((message, pattern) -> {
String key = new String(message.getBody());
localCache.invalidate(key); // 删除本地缓存
}, "cache:invalidated".getBytes());
}
// 兜底:本地缓存有 TTL,即使没收到通知也会到期自动失效
// → 这就是"通知与事实分离"——事实在 TTL 中
}
3.5 实战四:Pub/Sub 的集群表现
在 Redis Cluster 中,Pub/Sub 的行为和单机不同:
# Cluster 中: 任何节点都可以 SUBSCRIBE
# PUBLISH 的消息会传播到集群中所有节点的所有订阅者
# → 这意味着订阅者连接任意节点都能收到消息
# 验证: 在不同节点上 SUBSCRIBE,在第三个节点上 PUBLISH
# 所有订阅者都能收到
# 注意: 集群模式下频道消息会在节点间传播
# → 大规模频道(>1000个)可能消耗集群内部带宽
3.6 实战五:Pub/Sub 连接管理
# SUBSCRIBE 后连接进入订阅模式
# 不能执行普通命令(GET/SET等)
# 只能执行: SUBSCRIBE, PSUBSCRIBE, UNSUBSCRIBE, PUNSUBSCRIBE, PING, RESET, QUIT
# 查看订阅状态
127.0.0.1:6379> CLIENT LIST
# ... flags=P ... ← P 表示订阅状态
# 查看各频道的订阅者数
127.0.0.1:6379> PUBSUB CHANNELS
1) "config:changed"
2) "cache:invalidated"
# 查看某频道的订阅者数
127.0.0.1:6379> PUBSUB NUMSUB config:changed
1) "config:changed"
2) (integer) 2
# 查看模式订阅数
127.0.0.1:6379> PUBSUB NUMPAT
(integer) 1
3.7 实战六:Pub/Sub vs Stream 决策流程
需求分析决策树:
你的消息通知需求是?
├── 实时广播给所有在线的服务
│ ├── 消息丢了影响不大 → Pub/Sub ✓
│ └── 每条消息都必须被处理 → Stream ✗
├── 需要离线消息也能收到
│ └── Stream ✓ (有消息持久化)
├── 需要消费确认和重试
│ └── Stream ✓ (XACK + XAUTOCLAIM)
├── 只是通知"有变化了",数据从别处取
│ └── Pub/Sub ✓
└── 配置变更 + 缓存失效 + 在线提醒
└── Pub/Sub + Redis key 作为事实来源
3.8 实战七:Pub/Sub 性能与容量评估
# Pub/Sub 的发布延迟非常低——通常 < 1ms
# 但需要注意两点:
# 1. 输出缓冲区: 如果订阅者消费慢,消息会堆积在输出缓冲区
# 查看输出缓冲区状态
127.0.0.1:6379> CLIENT LIST | grep "omem="
# 如果 omem 值很大 → 订阅者处理速度跟不上
# 2. 频道数量: 不建议创建数千个不同的频道
# 频道的订阅信息虽然很小,但极多频道会占用内存
127.0.0.1:6379> PUBSUB CHANNELS
# 检查活跃频道数量
// Pub/Sub 性能监控
@Component
public class PubSubMonitor {
// 监控发布延迟
public void recordPublishMetrics(String channel, long latencyMs) {
metricsCollector.recordTimer("pubsub.publish.latency", latencyMs);
}
// 监控订阅者积压
@Scheduled(fixedDelay = 10000)
public void checkSubscriberBacklog() {
// 检查是否有订阅者输出缓冲区过大
List<String> clients = redis.execute((RedisCallback<List<String>>) conn -> {
// 获取 client list 并解析 omem
return parseClientList(conn.execute("CLIENT", "LIST".getBytes()));
});
for (String client : clients) {
if (extractOmem(client) > 1024 * 1024) { // > 1MB
alerts.send("Pub/Sub 订阅者输出缓冲区过大: " + client);
}
}
}
}
3.9 实战八:生产环境 Pub/Sub 部署清单
Pub/Sub 生产部署检查:
□ 订阅连接和普通命令连接是否分离?
□ 是否有消息丢失的兜底机制?(定时校验/补偿)
□ 配置变更消息是否带版本号?
□ notify-keyspace-events 配置是否写入配置文件?
□ 客户端是否处理了订阅连接断开重连?
□ 过期事件监听是否有定时任务补扫兜底?
□ 是否限制了频道数量上限?
□ 集群环境中是否验证了跨节点 Pub/Sub?
3.10 常见坑及解决方案
| 坑 | 表现 | 解法 |
|---|---|---|
| 订阅连接混用 | SUBSCRIBE 后执行 GET 报错 |
为订阅单独建连接 |
| 消息体过大 | 50KB 的消息体导致输出缓冲区爆炸 | 消息体 ≤ 1KB,大数据放 key 中引用 |
| 订阅者处理慢 | 输出缓冲区 omem 持续增长 |
消息处理异步化,主线程只接收 |
| 集群模式频道泛滥 | 1000+ 频道导致节点间心跳消息膨胀 | 限制频道数,使用通配符模式订阅 |
| 客户端重连漏订 | 重连后忘记重新 SUBSCRIBE | 在连接建立回调中重新订阅 |
3.11 Pub/Sub 在微服务中的实际落地模式
模式:配置热更新
运营后台 → 写入 MySQL + Redis key + PUBLISH config:updated
各微服务 → SUBSCRIBE 收到通知 → 重新加载配置
兜底 → 每 5 分钟定时对比配置版本号
模式:分布式缓存失效
商品编辑 → 更新 MySQL → DEL Redis key → PUBLISH cache:invalidated
各节点 → 收到通知 → 删除本地 Caffeine 缓存
兜底 → 本地缓存 30s TTL 自动过期
模式:实时用户通知
订单状态变更 → PUBLISH user:1001:notifications
用户 WebSocket 服务 → SUBSCRIBE 用户专属频道
兜底 → 用户刷新页面时主动拉取未读通知列表
3.12 Pub/Sub 客户端实现最佳实践(完整 Java 示例)
@Configuration
public class PubSubConfig {
@Bean
public RedisMessageListenerContainer container(
RedisConnectionFactory connectionFactory,
MessageListenerAdapter configListener,
MessageListenerAdapter cacheListener) {
RedisMessageListenerContainer container = new RedisMessageListenerContainer();
container.setConnectionFactory(connectionFactory);
// 使用线程池处理消息,避免阻塞订阅连接
container.setTaskExecutor(Executors.newFixedThreadPool(4));
// 订阅频道
container.addMessageListener(configListener, new ChannelTopic("config:changed"));
container.addMessageListener(cacheListener, new ChannelTopic("cache:invalidated"));
// 模式订阅过期事件
container.addMessageListener(new OrderTimeoutListener(),
new PatternTopic("__keyevent@0__:expired"));
return container;
}
}
@Component
public class ConfigChangeListener implements MessageListener {
@Override
public void onMessage(Message message, byte[] pattern) {
String body = new String(message.getBody());
ConfigChangeEvent event = parseEvent(body);
// 1. 版本号检查(防旧消息覆盖)
if (event.getVersion() <= getLocalVersion(event.getKey())) return;
// 2. 主动拉取最新值(不依赖消息体)
String latest = redis.get("config:" + event.getKey());
if (latest != null) applyConfig(latest);
}
}
3.13 调试与排查
# 确认频道是否有人在订阅
127.0.0.1:6379> PUBSUB NUMSUB config:changed
# 确认消息是否发出(查看发布返回的订阅者数)
127.0.0.1:6379> PUBLISH test:channel "hello"
(integer) 0 # 0 = 无人在线!
# 排查订阅连接是否正常
127.0.0.1:6379> CLIENT LIST | grep "flags=P"
# flags=P 表示订阅连接
# 检查有无异常客户端: 输出缓冲区(omem)异常大、长时间idle
4.4 Pub/Sub 常见误解澄清
| 误解 | 真相 |
|---|---|
| "PUBLISH 返回 3 说明 3 个服务处理成功" | 只说明 3 个订阅连接在线收到,不代表业务处理成功 |
| "订阅者离线消息会补发" | Pub/Sub 不存储消息,离线即丢失 |
| "Pub/Sub 可以做消息队列" | 不能——无持久化、无 ACK、无重试 |
| "Cluster 中 Pub/Sub 和单机一样" | 消息会在节点间传播,频道过多消耗集群带宽 |
| "PSUBSCRIBE 可以替代 SUBSCRIBE" | PSUBSCRIBE 是模式匹配,性能略低于精确 SUBSCRIBE |
4. 项目总结
4.1 核心命令速查
| 命令 | 用途 | 注意事项 |
|---|---|---|
PUBLISH channel msg |
发布消息 | 返回在线订阅者数 |
SUBSCRIBE ch1 ch2... |
订阅频道 | 连接进入订阅模式 |
PSUBSCRIBE pattern |
模式订阅 | 如 __keyevent* |
UNSUBSCRIBE |
退订 | |
PUBSUB CHANNELS |
列出活跃频道 | |
PUBSUB NUMSUB ch |
频道订阅者数 | |
PUBSUB NUMPAT |
模式订阅总数 | |
CONFIG SET notify-keyspace-events Ex |
开启过期通知 | 生产写入配置文件 |
4.2 可靠性保障清单
| 保障项 | 如何实现 |
|---|---|
| 消息丢失 | 通知与事实分离——Pub/Sub 只做通知,数据从 key/数据库取 |
| 订阅者离线 | 定时任务兜底拉取 |
| 旧消息覆盖新配置 | 版本号比较,低版本忽略 |
| Redis 重启 | 配置数据持久在数据库,Redis 重启后恢复 |
| 集群广播 | 客户端连接任意集群节点均可订阅 |
4.3 思考题
-
设计题:配置中心既要低延迟(秒级生效),又要高可靠(不丢失变更)。如果用 Pub/Sub 做通知 + Redis key 做事实存储 + MySQL 做持久备份,请画出完整的配置变更和读取流程。
-
故障题:线上配置变更后,40% 的服务 5 分钟后还没生效。排查发现这些服务订阅了
config:changed但没收到消息。请列出至少 3 种可能的原因。
(答案提示将在下一章末尾给出。)
4.4 Java 客户端深度实战:从连接到优雅关闭
前面展示了 Spring Data Redis 的声明式订阅,但在很多场景下你需要更精细的控制——比如动态订阅/退订、多频道选择性监听、或与 Jedis/Lettuce 直接交互。
Jedis 原生订阅实现:
import redis.clients.jedis.*;
import java.util.concurrent.*;
public class JedisPubSubDemo {
private final JedisPool pool;
private final ExecutorService executor;
public JedisPubSubDemo() {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(20);
config.setMaxIdle(10);
config.setMinIdle(5);
// 关键:订阅连接不能用连接池的普通连接
// 因为 SUBSCRIBE 会让连接进入阻塞模式
this.pool = new JedisPool(config, "localhost", 6379, 2000);
this.executor = Executors.newFixedThreadPool(3);
}
public void startConfigListener() {
executor.submit(() -> {
// 订阅连接必须独立——SUBSCRIBE 会阻塞当前线程
try (Jedis jedis = new Jedis("localhost", 6379)) {
jedis.subscribe(new JedisPubSub() {
@Override
public void onMessage(String channel, String message) {
System.out.printf("[配置变更] channel=%s, body=%s%n",
channel, message);
// 版本号检查
ConfigChangeEvent event = parseEvent(message);
if (event.getVersion() <= getLocalVersion(event.getKey())) {
System.out.println(" 跳过:版本号不大于本地");
return;
}
// 主动拉取最新配置(不信任消息体内容)
try (Jedis readJedis = pool.getResource()) {
String latest = readJedis.get("config:" + event.getKey());
if (latest != null) {
applyConfigSafely(latest);
}
}
}
@Override
public void onSubscribe(String channel, int subscribedChannels) {
System.out.printf("已订阅: %s (当前订阅数: %d)%n",
channel, subscribedChannels);
}
@Override
public void onUnsubscribe(String channel, int subscribedChannels) {
System.out.printf("已退订: %s (剩余: %d)%n",
channel, subscribedChannels);
}
}, "config:changed", "cache:invalidated"); // 多频道
} catch (JedisConnectionException e) {
System.err.println("订阅连接断开: " + e.getMessage());
// 重连逻辑在外面处理
}
});
}
public void startKeyspaceListener() {
executor.submit(() -> {
try (Jedis jedis = new Jedis("localhost", 6379)) {
jedis.subscribe(new JedisPubSub() {
@Override
public void onPMessage(String pattern, String channel, String message) {
// pattern = "__keyevent@0__:expired"
// channel = "__keyevent@0__:expired"
// message = 过期的 key 名称
System.out.printf("[Key过期] pattern=%s, key=%s%n",
pattern, message);
if (message.startsWith("order:timeout:")) {
String orderId = message.replace("order:timeout:", "");
handleOrderTimeout(orderId);
}
}
}, "__keyevent@0__:expired");
}
});
}
public void shutdown() {
executor.shutdown();
try { executor.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ignored) {}
pool.close();
}
}
Lettuce 客户端——集群环境下的 Pub/Sub:
import io.lettuce.core.*;
import io.lettuce.core.cluster.*;
import io.lettuce.core.pubsub.*;
import java.time.Duration;
public class LettucePubSubClusterDemo {
private final RedisClusterClient client;
private final StatefulRedisClusterPubSubConnection<String, String> pubSubConn;
private final StatefulRedisClusterConnection<String, String> cmdConn;
public LettucePubSubClusterDemo() {
this.client = RedisClusterClient.create(
RedisURI.Builder.redis("redis-cluster-node1", 7001).build());
this.client.setOptions(ClusterClientOptions.builder()
.validateClusterNodeMembership(true)
.timeoutOptions(TimeoutOptions.builder()
.timeoutCommands(true)
.fixedTimeout(Duration.ofSeconds(5))
.build())
.build());
// 注意:Pub/Sub 使用独立的专用连接
this.pubSubConn = client.connectPubSub();
this.cmdConn = client.connect();
}
public void startListening() {
RedisPubSubAdapter<String, String> adapter = new RedisPubSubAdapter<>() {
@Override
public void message(String channel, String message) {
System.out.printf("收到频道消息 [%s]: %s%n", channel, message);
// 异步处理,不阻塞 Pub/Sub 线程
CompletableFuture.runAsync(() -> processMessage(channel, message));
}
@Override
public void subscribed(String channel, long count) {
System.out.printf("订阅成功: %s (总数: %d)%n", channel, count);
}
};
pubSubConn.addListener(adapter);
// 订阅具体频道
RedisFuture<Void> future1 = pubSubConn.async()
.subscribe("config:changed", "cache:invalidated");
// 模式匹配订阅
RedisFuture<Void> future2 = pubSubConn.async()
.psubscribe("__keyevent@*__:expired");
// 等待订阅确认
try {
future1.get(5, TimeUnit.SECONDS);
future2.get(5, TimeUnit.SECONDS);
} catch (Exception e) {
System.err.println("订阅失败: " + e.getMessage());
}
}
// 发布示例
public long publishConfigChange(String key, String newValue, int version) {
long subscribers = cmdConn.sync().publish("config:changed",
String.format("{\"key\":\"%s\",\"version\":%d}", key, version));
// 同时写入 Redis key(事实存储)
cmdConn.sync().set("config:" + key, newValue);
return subscribers;
}
}
订阅连接的陷阱与最佳实践:
| 陷阱 | 现象 | 解决方案 |
|---|---|---|
| 订阅连接复用到命令池 | 命令超时或报错 | 订阅连接与命令连接严格分离 |
| 消息处理阻塞订阅线程 | 后续消息堆积 | 消息处理用独立线程池 |
| 连接断开未重连 | 消息静默丢失 | 实现 ConnectionListener 重连 |
| 模式订阅过多频道 | CPU 升高 | PSUBSCRIBE 模式不要用 * 开头 |
| 订阅后不检查返回 | 以为已订阅但实际失败 | 检查 subscribe 方法的返回值 |
4.5 Pub/Sub 监控体系搭建
生产环境中 Pub/Sub 消息丢失是最隐蔽的故障——没有错误日志、没有异常堆栈,只是某些服务的配置没生效。必须建立多层监控:
# 第一层:Redis 内建指标
redis-cli INFO pubsub
# 关键指标解读:
# pubsub_channels: 当前有多少个活跃频道(非模式订阅)
# pubsub_patterns: 当前模式订阅客户端数
# pubsub_commands: 累计 PUBLISH/SUBSCRIBE 命令数
# 第二层:业务级消息监控
# 定期往监控频道发心跳消息,检查是否有消费者
redis-cli PUBLISH monitor:heartbeat "$(date +%s)"
# 返回 0 → 无消费者在线 → 立即告警!
# 第三层:消费者侧指标暴露(Java Micrometer 示例)
import io.micrometer.core.instrument.*;
import java.util.concurrent.atomic.*;
@Component
public class PubSubMetrics {
private final AtomicLong receivedTotal = new AtomicLong(0);
private final AtomicLong processedTotal = new AtomicLong(0);
private final AtomicLong skippedTotal = new AtomicLong(0);
private volatile long lastReceivedTime = System.currentTimeMillis();
@EventListener
public void onMessageReceived(MessageEvent event) {
receivedTotal.incrementAndGet();
lastReceivedTime = System.currentTimeMillis();
}
// 暴露给 Prometheus 的指标
@Scheduled(fixedRate = 60000)
public void reportMetrics() {
log.info("Pub/Sub 指标: received={}, processed={}, skipped={}, idle_ms={}",
receivedTotal.get(), processedTotal.get(), skippedTotal.get(),
System.currentTimeMillis() - lastReceivedTime);
// 告警规则:超过 5 分钟没收到任何消息
if (System.currentTimeMillis() - lastReceivedTime > 300_000) {
alert("Pub/Sub 消费者可能离线: 5分钟无消息");
}
}
}
告警规则设计:
| 告警项 | 阈值 | 严重级别 | 处理动作 |
|---|---|---|---|
| PUBLISH 返回 0 | 任意一次 | P2 | 检查是否有消费者在线 |
| 消费者 5 分钟无消息 | 持续 5 分钟 | P2 | 检查消费者进程/重连逻辑 |
| subscribed_channels 突降 | 1 分钟内降 50% | P1 | 消费者批量离线 |
| 客户端 output buffer 超限 | omem > 10MB | P3 | 消费者处理太慢,即将被踢 |
| 频道数突增 | 1 分钟内增长 200% | P3 | 可能有应用 Bug 疯狂订阅 |
4.6 常见线上故障排查流程
场景一:配置变更不生效
症状:运营修改配置 10 分钟后仍不生效
排查步骤:
1. redis-cli PUBSUB NUMSUB config:changed
→ 返回 0 → 无消费者 → 检查消费者进程状态
→ 返回 >0 → 消息已推送,排查消费者侧逻辑
2. redis-cli CLIENT LIST | grep "flags=P"
→ 检查 flags=P 的连接,查看其 age(连接时长)和 idle(空闲秒数)
→ idle 过大说明消费者可能阻塞/暂停
3. 在消费者侧:
jstack <pid> | grep -A 20 "subscribe\|message"
→ 检查订阅线程是否存活
→ 检查消息处理线程是否有死锁
4. 网络层面:
tcpdump -i eth0 port 6379 -w pubsub.pcap
→ 抓包分析 PUBLISH 是否到达了消费者所在的机器
场景二:Keyspace Notification 不触发
症状:key 过期了但 onMessage 没触发
排查步骤:
1. CONFIG GET notify-keyspace-events
→ 输出必须是 "AKE" 或包含 "Ex" 的字符串
→ 如果是 "" 或空 → 未开启
2. redis-cli --ldb 调试模式:
redis-cli DEBUG OBJECT <key>
→ 检查 key 是否真正存在、TTL 是否正确设置
3. 连接层面:
PSUBSCRIBE __keyevent* → 手动订阅
SET test:expire "value"
EXPIRE test:expire 3
→ 等 3 秒看是否收到消息
→ 没收到 → 确认 notify-keyspace-events 包含 "E"
4. 版本兼容性:
Redis 2.8+ 才支持 Keyspace Notification
→ INFO server → redis_version
场景三:集群环境下 Pub/Sub 带宽飙升
症状:Cluster 节点间网络带宽异常升高
排查步骤:
1. 统计活跃频道数:
redis-cli -c CLUSTER NODES | awk '{print $2}' | cut -d@ -f1 | \
while read addr; do
ip=$(echo $addr | cut -d: -f1); port=$(echo $addr | cut -d: -f2)
echo "$addr: $(redis-cli -h $ip -p $port PUBSUB CHANNELS | wc -l)"
done
2. 如果频道数 > 100 → 排查哪些业务在大量订阅
→ 每个 PUBLISH 都会通过集群总线广播到所有节点
→ 频道越多,广播开销越大
3. 优化方案:
- 合并冗余频道(例如 config:changed 不需要按模块分 20 个)
- 将 Pub/Sub 下沉到单机哨兵模式,Cluster 只做数据分片
- 用 Stream 替代非实时广播场景
4.7 Pub/Sub 架构决策树
是否需要实时通知?
├── 是 → 需要保证可靠投递?
│ ├── 是 → 用 Stream + 消费组(有 ACK 和重试)
│ └── 否 → 需要广播给多个服务?
│ ├── 是 → 用 Pub/Sub(注意通知与事实分离)
│ └── 否 → 用 List BRPOP(简单可靠)
└── 否 → 定时轮询即可
└── 轮询间隔太长?→ 用 Pub/Sub 做"通知管道"
上一章思考题答案提示(第20章):
第1题(三业务消费):应该用三个消费组。同一个消费组内是竞争消费——一条消息只能被一个消费者处理。三个独立业务(落库/积分/短信)需要各自独立消费同一条消息 → 各建一个消费组。如果放在一个组内,消息会被"抢走",其他业务就收不到了。
第2题(Stream 内存估算):1000 条/秒 × 200 字节 × 3600 秒 ≈ 720MB/小时。裁剪策略:
XADD ... MAXLEN ~ 3600000(保留约 1 小时量),或使用XTRIM定期裁剪。注意~表示约等于,Redis 可能保留稍多于指定条数。
延伸阅读与资源
Redis 8 实战精讲:从 CRUD 到源码,构建高可用缓存系统
Java 工程师进阶:从 JVM 生产排障到OpenJDK原理
Nacos 3.x 注册配置中心实战修炼:从入门到源码扩展
Elasticsearch从入门到进阶的实战之旅
MySQL Server 9从入门到进阶的实战之旅
RabbitMQ从入门到进阶的实战之旅:从单机到大促高可用架构
Celery 入门到进阶之路:从异步任务到自研调度平台
LangGraph 生产级实战进阶:从零到生产级Agent工作流开发
Dify 从入门到源码:LLM 应用平台实战修炼
从零到生产级:FastAPI 异步高并发、源码与 SRE 实战
实战SQLAlchemy 2.0: 从 CRUD 到生产级架构
从零打造企业级 AI 助手:LangChain RAG、Agent 与生产实战
后端工程师 AI 转型课:Ollama 私有化大模型从入门到生产
MongoDB 实战进阶与内核修炼
NumPy 从入门到生产落地:全链路实战指南(科学计算/向量化/性能调优)
Milvus向量数据库实战修炼:从 0 到 1 精通向量检索与生产落地
Python 3实战精进:从脚本到高并发订单引擎
python入门:Rquests从菜鸟脚本到企业级SDK的网络实战圣经

微信公众号: 架构师日常笔记 欢迎关注!
浙公网安备 33010602011771号