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 思考题

  1. 设计题:配置中心既要低延迟(秒级生效),又要高可靠(不丢失变更)。如果用 Pub/Sub 做通知 + Redis key 做事实存储 + MySQL 做持久备份,请画出完整的配置变更和读取流程。

  2. 故障题:线上配置变更后,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的网络实战圣经

posted on 2026-11-16 21:50  一天不进步,就是退步  阅读(4)  评论(0)    收藏  举报