RocketMQ 核心原理与实战:事务消息、顺序消息、延迟队列与 CommitLog 存储

本文是消息队列系列的”RocketMQ 补位篇“。不重讲消息队列的通用价值(削峰填谷、异步解耦、系统削峰——kafka-core 已铺开),也不重讲位移提交、ISR 副本、EOS 精确一次等 Kafka 特有机制。本文只聚焦 RocketMQ 自己的设计与机制:NameServer 路由、CommitLog 混合存储、事务消息、顺序消息、延迟消息、死信队列。想看消息队列”为什么要用”的部分,请移步 Kafka 篇;这里默认你已经知道消息队列是干什么的。

一、为什么是 RocketMQ:Kafka 之外的另一条路

同样是消息队列,Kafka 为日志与流式数据而生,追求极致吞吐;RocketMQ 则为业务消息而生,天然带着”事务、顺序、延迟、可靠投递”这些电商/金融场景的基因。这决定了两者在很多设计上分道扬镳:

维度 RocketMQ Kafka
核心定位 业务消息、事务一致性 日志采集、流处理
元数据管理 自研 NameServer(无状态) 早期 ZooKeeper,新版 KRaft
存储模型 CommitLog 混合存储 + 逻辑队列 每个 Partition 独立存储
事务消息 原生两阶段 + 事务回查 需上层自己保证
延迟消息 18 级 / 5.x 任意定时 无原生支持
消费失败重试 内置重试队列 + 死信队列 靠位移控制,需自己实现
顺序消息 分区顺序(MessageQueueSelector) 分区内有序

一句话:要的是”这条业务消息必须不丢、有序、按约定时间送达、和本地事务最终一致”,RocketMQ 是更顺手的那把刀。 下面所有机制,都围绕这把刀怎么打造展开。

二、整体架构:四角色 + 一个无状态的 NameServer

RocketMQ 的拓扑由四个角色组成:NameServer、Broker、Producer、Consumer。理解它,先抓住 NameServer 这个”最特别”的组件。

1
2
3
4
5
6
Producer  ──拉取路由──┐
├──> NameServer 集群(无状态,节点互不通信)
Consumer ──拉取路由──┘ ▲ 心跳注册路由
│
Broker 集群
Master ── 同步/异步复制 ── Slave
角色 职责 关键点
NameServer 保存 Topic→Broker/Queue 路由、Broker 存活 无状态,节点间不通信、不选举
Broker 消息落盘、投递、拉取;主从架构 Master 可读写,Slave 主要承担读与容灾
Producer 发送消息,向 NameServer 拉取路由 按轮询/自定义策略选 MessageQueue
Consumer 拉取消息消费 集群消费 / 广播消费两种模式

2.1 NameServer 为什么”无状态”

NameServer 不像 ZooKeeper 那样做一致性协调,它只保存一份最终一致的路由表:

  1. Broker 启动时,向所有 NameServer 注册自己的信息(地址、端口、Topic 配置)。
  2. Broker 每 30s 发心跳续约;NameServer 每 10s 扫描一次,发现某个 Broker 超过 120s 没心跳就把它从路由表剔除。
  3. Producer/Consumer 每 30s 从任意一台 NameServer 拉取最新路由,本地缓存。

这样设计的好处是极轻、极易横向扩展——多部署几台 NameServer 就能扛住更高的路由查询压力,节点挂掉一台也不影响整体(客户端会轮询其他节点)。代价是路由更新有秒级延迟:Broker 宕后最长约 120s 才被摘除,这期间发往它的消息可能失败,需要靠 Producer 的重试兜底。

对比 Kafka 的 ISR:Kafka 把副本一致性放在控制器 + ISR 里做强一致协调,NameServer 则刻意只做”够用”的路由发现,把一致性下沉给 Broker 主从复制和客户端重试。这是 RocketMQ “轻协调”的典型思路。

三、存储设计:CommitLog 混合存储 + ConsumeQueue 索引

这是 RocketMQ 与 Kafka 最本质的差异,也是它高吞吐的根基。

Kafka 是”一个 Partition 一个日志文件”,Partition 多了就变成大量分散的小文件,随机写增多。RocketMQ 反其道而行:不管有多少 Topic、多少队列,所有消息都按顺序追加到同一个 CommitLog 文件里,再为每个逻辑队列建一份轻量索引。

1
2
3
4
                     ┌─ ConsumeQueue(TopicA-Q0) → 指向 CommitLog 的 offset/size/tagHash
Producer ─顺序追加─> CommitLog ├─ ConsumeQueue(TopicA-Q1)
(所有 Topic 混合) ├─ ConsumeQueue(TopicB-Q0)
└─ IndexFile → 按 messageKey / 时间区间快速检索

三层分工:

文件 作用 特点
CommitLog 真正存消息体 单个默认 1GB,顺序写满滚动到下一个;纯顺序 IO,吞吐极高
ConsumeQueue 逻辑队列索引 每条 20 字节(commitLogOffset 8 + size 4 + tagHashCode 8),消费时先查索引再读 CommitLog
IndexFile 按 key/时间检索 支持 sendMsgWithKey 后按 key 反查消息,用于问题排查

消费一条消息的过程:Consumer 定位到某个 ConsumeQueue,从索引里拿到 offset → 回 CommitLog 按 offset 读出完整消息 → 投给业务。索引文件很小,可以全量放进 PageCache,所以”查索引 + 读消息”整体依然很快。

刷盘与复制决定可靠性,两种策略两两组合:

  • 刷盘:SYNC_FLUSH(消息写入 PageCache 后立即刷盘再返回,慢但断电不丢)/ ASYNC_FLUSH(后台线程批量刷,快但断电可能丢少量)。
  • 复制:SYNC_MASTER(Slave 复制成功才返回 ACK)/ ASYNC_MASTER(Master 写成功即返回)。

要”消息绝不丢”,用 SYNC_FLUSH + SYNC_MASTER;要极致吞吐,用 ASYNC_FLUSH + ASYNC_MASTER。金融场景选前者,日志类场景选后者。

四、事务消息:两阶段提交 + 事务回查

这是 RocketMQ 的招牌能力,解决的是”本地事务执行成功,消息也一定要发出去“这个分布式事务难题。

以电商下单为例:订单库插入订单(本地事务)成功后,必须通知库存系统扣减库存(发消息)。如果先发消息后写库,可能出现”消息发了但订单没建成”;如果先写库后发消息,可能出现”订单成了但消息发失败”。事务消息就是为消除这种不一致。

4.1 两阶段提交流程

1
2
3
4
5
6
7
1. Producer 发送 half 消息(半消息/预处理消息) → Broker
(此时消息对 Consumer 不可见)
2. Broker 落盘成功,回 ACK
3. Producer 执行本地事务(如插入订单)
4. 根据本地事务结果,向 Broker 提交 COMMIT 或 ROLLBACK
- COMMIT:消息对 Consumer 可见,正常投递
- ROLLBACK:删除 half 消息,不投递

代码骨架:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
TransactionMQProducer producer = new TransactionMQProducer("order-producer-group");
producer.setNamesrvAddr("127.0.0.1:9876");
producer.setTransactionListener(new TransactionListener() {
// 阶段二:执行本地事务
@Override
public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
try {
orderService.createOrder((Order) arg); // 本地事务:写订单库
return LocalTransactionState.COMMIT_MESSAGE; // 成功 -> 投递消息
} catch (Exception e) {
return LocalTransactionState.ROLLBACK_MESSAGE; // 失败 -> 丢弃消息
}
}

// 兜底:Broker 回查本地事务状态
@Override
public LocalTransactionState checkLocalTransaction(MessageExt msg) {
String orderId = msg.getKeys();
return orderService.hasOrder(orderId)
? LocalTransactionState.COMMIT_MESSAGE
: LocalTransactionState.ROLLBACK_MESSAGE;
}
});
producer.start();
producer.sendMessageInTransaction(msg, order);

4.2 为什么还需要”事务回查”

上面第 4 步,如果 Producer 在本地事务执行完后、提交 COMMIT 之前宕机了,Broker 就永远不知道这条 half 消息该投递还是该删除。事务回查就是为这个窗口兜底:

  • Broker 会定时扫描长时间处于 half 状态的消息(默认 60s 一次),回调 Producer 的 checkLocalTransaction 询问本地事务到底成没成。
  • 回查超过 15 次仍无结果,默认按回滚处理(可用 transactionCheckMax 调整)。
  • 因此 checkLocalTransaction 里必须能根据消息(一般靠 messageKey 带订单号)幂等地查到本地事务结果——通常做法就是把订单号作为 key 写入消息,回查时查订单库。

事务消息保证的是”本地事务与消息发送的最终一致”,不保证“消息一定能被消费成功”。消费端扣库存失败仍需靠重试 + 幂等兜底。它是分布式事务里”可靠消息最终一致性”方案的一环,不是银弹。

五、顺序消息:把同一业务 ID 的消息钉在同一个队列

Kafka 篇讲过”分区内有序”,RocketMQ 的顺序消息是同一个思路的工程化封装,分两种:

  • 全局顺序:整个 Topic 只有 1 个 MessageQueue,所有消息严格 FIFO。吞吐极低,只适合对顺序要求极高、量很小的场景。
  • 分区顺序(局部顺序):同一个 sharding key(如订单 ID)的消息固定发到同一个 MessageQueue,队列内 FIFO。这是生产环境的主流选择。

发送端用 MessageQueueSelector 实现”按订单 ID 取模选队列”:

1
2
3
4
5
SendResult result = producer.send(msg, (mqs, msg, arg) -> {
Long orderId = (Long) arg;
int index = (int) (orderId % mqs.size());
return mqs.get(index); // 同一 orderId 永远落到同一队列
}, orderId);

光发送端做到还不够,消费端必须用串行监听器 MessageListenerOrderly,RocketMQ 会对每个队列加锁,保证同一个队列同一时刻只被一个线程顺序消费:

1
2
3
4
5
6
7
8
9
10
consumer.registerMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs,
ConsumeOrderlyContext context) {
for (MessageExt msg : msgs) {
processOrder(msg); // 按顺序处理:创建 → 付款 → 发货
}
return ConsumeOrderlyStatus.SUCCESS;
}
});

注意顺序消息的一个代价:一旦某条消息消费失败并进入重试,会阻塞该队列后续消息。所以对顺序消息通常关闭自动重试、在消费者内部自己做好失败处理与告警,避免”一条卡住、全队列停摆”。

六、延迟消息:18 个等级与任意定时

“订单 30 分钟未支付自动关闭”是延迟消息最经典的场景。RocketMQ 对此有专门的原生支持。

6.1 固定 18 级延迟(4.x 经典方案)

生产者只需设置延迟等级,消息先进入 Broker 的延迟队列(SCHEDULE_TOPIC_XXXX),由定时任务扫描,到点后再投递到真正的目标 Topic:

1
2
msg.setDelayTimeLevel(3);   // 3 = 10s,具体等级见下表
producer.send(msg);

预定义的 18 个等级(等级从 1 开始):

等级 时长 等级 时长 等级 时长
1 1s 7 3m 13 9m
2 5s 8 4m 14 10m
3 10s 9 5m 15 20m
4 30s 10 6m 16 30m
5 1m 11 7m 17 40m
6 2m 12 8m 18 1h

固定等级的局限是时间档位不可自定义,且延迟期间消息落在 Broker 磁盘上,量大时会有压力。

6.2 任意时间定时(5.x 定时消息)

RocketMQ 5.x 引入了基于时间轮(Timer Wheel)的定时消息,支持精确到毫秒的任意时间点投递,不再受 18 级限制:

1
2
msg.setDeliverTimeMs(System.currentTimeMillis() + 30 * 60 * 1000); // 30 分钟后投递
producer.send(msg);

时间轮把定时任务按时间刻度分桶,Insert/Cancel 都是 O(1),比”扫描整个延迟队列”更适合海量定时任务。做订单超时关闭、定时提醒这类需求,5.x 的时间轮是更优解。

七、消费模型:推拉、集群与广播

7.1 Push 还是 Pull

  • Push 消费者(DefaultMQPushConsumer):名字叫 Push,底层其实还是 Pull + 长轮询——Broker 收到拉取请求后如果没有消息,会挂起请求(默认 15s)直到有消息或超时再返回。兼顾了 Push 的实时性和 Pull 的流控能力,是最常用的方式。
  • Pull 消费者(DefaultLitePullConsumer):由业务自己控制拉取节奏,适合需要精确流控或批处理的高级场景。

7.2 集群消费 vs 广播消费

模式 语义 适用场景
集群消费 CLUSTERING(默认) 同一 ConsumerGroup 的多实例分摊消息,一条消息只被组内一个实例消费 订单处理、库存扣减等正常业务
广播消费 BROADCASTING 同一 ConsumerGroup 的每个实例都收到全量消息 配置刷新、缓存失效通知

集群消费下,消费进度(offset)以 ConsumerGroup 为单位存在 Broker;广播消费下,进度存在各消费者本地。这也是为什么广播模式不提供失败重试——没有集中的进度管理,重试无从谈起。

7.3 重试队列与死信队列

集群消费时,如果某条消息消费失败(返回 RECONSUME_LATER 或抛异常),RocketMQ 会自动把它送入该消费组的重试队列 %RETRY%<group>:

  • 默认最多重试 16 次,重试间隔逐次拉长(1s、5s、10s、30s、1m、2m…直到 2h)。
  • 16 次仍失败,消息进入死信队列 %DLQ%<group>,不再自动投递。

死信队列是”最后的安全网”,生产环境务必给死信队列配监控告警。大量消息进死信,通常意味着消费逻辑有 bug 或下游依赖长时间不可用,需要人工介入补单,而不是让它静静躺在队列里。

八、可靠性与幂等:至少一次的必然结果

RocketMQ 默认提供 at-least-once(至少一次) 语义:网络抖动、消费者重启、重试都可能导致同一条消息被投递多次。因此消费端幂等是必答题,不是可选项。常见做法:

  1. 业务唯一键 + 去重表:用消息的 messageKey(如订单号)做唯一索引,消费前先查/插去重表,已处理则直接跳过。
  2. 状态机幂等:订单状态从”待支付”→”已支付”,重复消费时因状态不符直接返回成功。
  3. Redis SETNX:以 messageKey 为 key 做短时去重(注意设置合理过期时间和缓存失效的兜底)。

发送端这边,事务消息解决”本地事务 + 发送”的一致性,同步发送 + SYNC_FLUSH + SYNC_MASTER 解决”消息不丢”,两者叠加才能撑起”可靠消息最终一致性”。请记住:RocketMQ 不提供 Kafka 那种 EOS 精确一次语义,幂等的最后一公里在业务侧。

九、生产避坑清单

把上面机制落到生产,这几条经验能少踩很多坑:

坑 现象 对策
NameServer 单点 路由全挂、生产停摆 至少部署 2~3 台,客户端配全地址列表
顺序消息卡队列 一条失败,整队列阻塞 关闭自动重试,消费端内部兜底 + 告警
事务回查查不到状态 消息被误回滚 checkLocalTransaction 必须能按 key 幂等查本地事务
死信无人问津 消息静默丢失 死信队列配监控,定期巡检补单
消费端不幂等 重复扣款/重复发货 唯一键 + 去重表 / 状态机幂等
Topic/队列数过多 文件句柄耗尽、路由膨胀 合理规划队列数(通常每 Topic 4~16 个)
消息堆积 消费跟不上生产 扩容 Consumer 实例(不超过队列数),排查下游慢调用

总结

RocketMQ 的设计,处处透着”为业务消息负责”的味道:

  • NameServer 用无状态换取轻量与横向扩展,把一致性交给 Broker 与客户端重试;
  • CommitLog 混合存储 + ConsumeQueue 索引用顺序写换取高吞吐,同时保持逻辑队列的灵活;
  • 事务消息 + 事务回查解决本地事务与消息发送的最终一致;
  • 顺序消息 / 延迟消息 / 重试与死信队列把电商场景的常见需求做成开箱即用的能力。

如果说 Kafka 篇讲的是”消息怎么流得更快”,那这篇讲的是”业务消息怎么送得更稳”。把这两篇合起来看,你就有了在 Kafka 与 RocketMQ 之间做技术选型的完整坐标:流式日志与极致吞吐选 Kafka,事务型业务消息与可靠投递选 RocketMQ。