Skip to content

5.3-6 RocketMQ 事务消息:半消息与回查 ​

所属:05 消息中间件 / 5.3 RocketMQ 分级:A 状态:◐ 初稿 关联:3.1-6、5.1-1、5.1-2、5.3-1、5.3-2、5.3-3、6.1-3

  • 题型:原理 / 流程 / 场景

  • 一句话结论:事务消息解决的是**“本地数据库事务 + 发消息”的原子性**:先发一条对消费者不可见的半消息,再执行本地事务,成功则 commit(Broker 把消息转到真实 Topic)、失败则 rollback;如果 commit/rollback 丢了,Broker 定时回查生产者的 checkLocalTransaction,由它查数据库状态决定提交还是回滚。它是最终一致 + 消费端幂等,不是强一致两阶段提交;回查次数耗尽会丢弃消息,所以必须监控。

  • 分层要点:

    1. 要解决的问题:业务写完 DB 再发消息,可能“DB 成功、消息没发”;先发消息再写 DB,可能“消息发了、DB 回滚”。两者都不原子。事务消息把“发消息”拆成“先占位(半消息)+ 后确认(commit/rollback)”,让 DB 的提交结果成为消息是否可见的裁决依据。
    2. 半消息对消费者不可见:Producer 发到 Broker 后,消息被写到半消息 Topic(RMQ_SYS_TRANS_HALF_TOPIC),真实 Topic 与队列 ID 存在消息属性里(REAL_TOPIC / REAL_QID),消费者订阅的是真实 Topic,看不到半消息。只有 commit 后,Broker 才把消息“转正”到真实 Topic。
    3. 三段流程:① sendMessageInTransaction 发半消息;② 回调 executeLocalTransaction 执行本地事务(如 DB 写单);③ 根据返回值发 END_TRANSACTION(commit / rollback / unknown)。commit → Broker 将半消息转成真实消息,消费者可消费;rollback → 丢弃;unknown 或没收到 → 进入回查。
    4. 回查是兜底机制:Broker 的 TransactionalMessageCheckService 默认每 60 秒扫描半消息,超过 transactionTimeOut(默认 6 秒)仍未确认的,回查 Producer 的 checkLocalTransaction;最多 transactionCheckMax(默认 15 次),超过后丢弃并打日志。所以 checkLocalTransaction 必须查 DB 真实状态,不能依赖内存标志——Producer 可能已经重启。
    5. TransactionListener 的两个方法:executeLocalTransaction 返回 COMMIT_MESSAGE / ROLLBACK_MESSAGE / UNKNOW;checkLocalTransaction 返回 COMMIT_MESSAGE / ROLLBACK_MESSAGE / UNKNOW。UNKNOW 会让 Broker 下次继续回查;返回 ROLLBACK 要确保业务真的没成功,否则消息永久丢失。
    6. 它不是 XA/2PC:没有全局锁、没有同步阻塞,Broker 不参与本地事务;一致性靠“本地事务结果 + 回查 + 消费端幂等”达成,是最终一致。中间态(半消息、已提交未消费)是允许的;消费端仍可能收到重复消息,必须幂等(5.1-2)。
    7. 限制与适用面:事务消息不支持延迟消息和批量发送(4.x);半消息有存储成本,回查有频率与次数上限;适合本地事务结果可查询的场景(订单、支付、账户流水),不适合“本地事务不可查询/不可幂等”的场景。跨多个服务的分布式事务,仍要 Saga/TCC/对账,不能指望一个事务消息全包。
    8. 可靠性边界:半消息发送失败 → 本地事务不会执行(调用方需处理异常);本地事务成功但 commit 丢失 → 回查兜底;本地事务失败但误发 commit → 数据不一致(代码 bug);回查耗尽 → 消息丢弃(必须告警 + 补偿);消费端处理失败 → 重试/死信(5.3-8)。每一步都有失败分支,面试要能逐段说清。
  • 图/流程:

text
正常流程:
  Producer
    → ① send half message
        → Broker: RMQ_SYS_TRANS_HALF_TOPIC(消费者不可见)
    → ② executeLocalTransaction(写 DB)
        ├─ 成功 → ③ COMMIT
        │          → Broker 转正到真实 Topic
        │            → Consumer 消费
        └─ 失败 → ③ ROLLBACK
                   → Broker 丢弃半消息
text
回查流程:
  Broker(每 60s 扫描)
    → 半消息超过 6s 未确认
      → checkLocalTransaction(半消息)
        ├─ COMMIT   → 转正
        ├─ ROLLBACK → 丢弃
        └─ UNKNOW   → 下次再查
  达到 15 次仍未决 → 丢弃 + 日志(需告警)
text
消息状态:
  Half ──commit──▶ Committed ──消费──▶ Consumed
    │
    ├──rollback──▶ RolledBack(丢弃)
    └──超时未决──▶ Checking ──超限──▶ Discarded(丢弃)
text
与本地消息表对比:
  事务消息:DB 事务 → 半消息 → commit → MQ 投递
  本地消息表:DB 事务(业务 + outbox)→ 定时任务投递 → 标记已发
  • 版本/源码锚点:

    • 生产者:TransactionMQProducer、TransactionListener、LocalTransactionState(COMMIT_MESSAGE / ROLLBACK_MESSAGE / UNKNOW)、sendMessageInTransaction、EndpointProcessor。
    • Broker:TransactionalMessageService、TransactionalMessageCheckService、EndTransactionProcessor、TransactionalMessageUtil、半消息 Topic RMQ_SYS_TRANS_HALF_TOPIC、Op 消息 Topic RMQ_SYS_TRANS_OP_HALF_TOPIC。
    • 属性:TRAN_MSG、REAL_TOPIC、REAL_QID、UNIQ_KEY。
    • 参数:transactionTimeOut(默认 6000ms)、transactionCheckMax(默认 15)、transactionCheckInterval(默认 60000ms)。
    • 5.x:Proxy/gRPC 也提供事务消息 API;语义与 4.x 一致。
  • 三步与失败分支:

步骤成功失败/异常结果
① 发半消息Broker 存储网络/存储失败抛异常,本地事务不执行
② 本地事务DB 提交DB 回滚返回 ROLLBACK
③ 发 commit/rollbackBroker 转正/丢弃网络失败/Producer 崩溃进入回查
回查查到 DB 状态 → commit/rollback查不到/UNKNOW继续查,超限丢弃
消费正常处理处理失败重试 → 死信(5.3-8)
  • TransactionListener 返回值:
方法返回值含义风险
executeLocalTransactionCOMMIT_MESSAGE本地事务成功无
ROLLBACK_MESSAGE本地事务失败误判会丢消息
UNKNOW状态不确定触发回查
checkLocalTransactionCOMMIT_MESSAGE查 DB 确认成功必须真实查询
ROLLBACK_MESSAGE查 DB 确认失败误判会丢消息
UNKNOW仍不确定继续回查,超限丢弃
  • 方案对比:
方案一致性复杂度依赖适用
XA / 2PC强一致高、阻塞数据库支持短事务、强一致
事务消息最终一致中RocketMQ本地事务 + 发消息
本地消息表/outbox最终一致中DB + 定时任务不想依赖 MQ 特性
Saga / TCC最终一致高业务改造跨服务长事务
对账补偿最终一致低(兜底)定时任务所有方案的兜底
  • 参数与限制:
项默认/限制说明
transactionTimeOut6s超过后开始回查
transactionCheckMax15 次超过丢弃并记录
transactionCheckInterval60s扫描间隔
延迟消息不支持事务消息不能设延迟级别
批量发送不支持需逐条发送
半消息存储占用 CommitLog未决半消息会占空间
消费可见性commit 后可见半消息对消费者透明
  • 失效场景与定位:
现象根因处理
消息一直不消费半消息未 commit,回查未决查 Producer 日志、回查返回值
回查报错checkLocalTransaction 抛异常/超时修查询逻辑、加超时与幂等
消息丢了回查超限被丢弃告警 + 对账补偿
DB 成功但消息回滚executeLocalTransaction 误返回 ROLLBACK修代码,补发
DB 失败但消息提交误返回 COMMIT修代码,人工冲正
消息重复commit 重试/消费重投消费端幂等(5.1-2)
半消息堆积回查慢/Producer 不可用扩回查线程、修 Producer
事务消息发不出去用了延迟/批量参数拆成普通发送或去掉参数
消费端看不到订阅了错误 Topic / 未 commit查真实 Topic、Broker 状态
回查压力大半消息多、间隔短调参、减少事务消息使用面
  • 深挖点(面试官常追的 6 个):

    1. 半消息为什么消费者看不到:半消息不是“特殊消息”,而是被写进了半消息专用 Topic(RMQ_SYS_TRANS_HALF_TOPIC),真实 Topic 和队列存在属性里;消费者订阅的是真实 Topic,自然收不到。commit 时 EndTransactionProcessor 会构造一条写到真实 Topic 的消息(Op 消息记录操作),rollback 则只记操作、不投递。“不可见”是靠 Topic 隔离实现的,不是靠消费者过滤。
    2. 回查为什么必须查数据库:checkLocalTransaction 可能在 Producer 重启后、或另一台实例上被调用,内存里的“我提交过”标志早就没了;唯一可靠的事实是 DB 里那条业务记录的状态。所以回查要按业务主键查库(订单是否存在、状态是否已支付),返回 commit/rollback;查询必须幂等、只读、快,不能有副作用。
    3. 回查次数耗尽会怎样:Broker 超过 transactionCheckMax(默认 15 次)后不再回查,丢弃半消息并打日志——对业务来说就是消息永久丢失。所以生产上要监控半消息堆积、回查失败和丢弃日志,并配定时对账:DB 有记录但下游没收到,就补发。事务消息不是“设了就绝对不丢”。
    4. 事务消息 vs 本地消息表:两者都是最终一致。事务消息把“存储 + 回查”交给 MQ,业务代码只实现两个回调,适合已用 RocketMQ 的团队;本地消息表把消息和业务写在同一 DB 事务里,后台任务轮询投递,不依赖 MQ 特性、可审计、易补偿,但要多一张表、一个投递任务和清理逻辑。不想绑死 MQ 或用 Kafka 时,outbox 更通用。
    5. 事务消息 vs Kafka 事务:Kafka 事务保证“多个分区写入 + offset 提交”原子,作用域在 Kafka 内部,管不到外部数据库;RocketMQ 事务消息保证“本地 DB 事务 + 消息投递”一致,作用域跨 DB 与 MQ。两者解决的不是同一个问题,不能互相替代(5.4-6)。
    6. 事务消息能保证“只消费一次”吗:不能。commit 可能重试、Broker 可能重投、消费端可能失败重试,消费者仍会收到重复消息。事务消息只保证“本地事务成功则消息最终可见、失败则不可见”,消费端必须幂等(唯一键/状态机/去重表,5.1-2)。面试时把“最终一致 + 至少一次 + 幂等”一起说,才是完整答案。
  • 追问链:

    1. 事务消息解决什么? → DB 事务与发消息的原子性。
    2. 怎么实现的? → 半消息 + 本地事务 + commit/rollback + 回查。
    3. 半消息存在哪? → RMQ_SYS_TRANS_HALF_TOPIC。
    4. 消费者能看到吗? → 不能。
    5. 为什么? → 写在不同 Topic。
    6. commit 后呢? → Broker 转到真实 Topic。
    7. rollback 后呢? → 丢弃。
    8. 本地事务什么时候执行? → 半消息发送成功之后。
    9. 谁执行? → executeLocalTransaction。
    10. 返回什么? → COMMIT/ROLLBACK/UNKNOW。
    11. commit 丢了怎么办? → Broker 回查。
    12. 回查谁? → Producer 的 checkLocalTransaction。
    13. 回查查什么? → 数据库真实状态。
    14. 为什么不能查内存? → Producer 可能重启/换实例。
    15. 回查多久一次? → 默认 60 秒扫描。
    16. 多久开始查? → 超过 6 秒未确认。
    17. 最多查几次? → 默认 15 次。
    18. 超限怎么办? → 丢弃 + 日志。
    19. 丢了怎么发现? → 告警 + 对账。
    20. 是强一致吗? → 不是,最终一致。
    21. 是 2PC 吗? → 不是,无全局锁。
    22. 消费会重复吗? → 会,要幂等。
    23. 能保证只消费一次吗? → 不能。
    24. 支持延迟消息吗? → 4.x 不支持。
    25. 支持批量吗? → 不支持。
    26. 半消息占存储吗? → 占 CommitLog。
    27. 半消息堆积说明什么? → 回查未决/Producer 异常。
    28. execute 返回 UNKNOW 会怎样? → 触发回查。
    29. check 返回 UNKNOW 会怎样? → 继续查。
    30. 误返回 ROLLBACK 会怎样? → 消息丢失。
    31. 误返回 COMMIT 会怎样? → 数据不一致。
    32. 本地事务失败但 commit? → 下游多做,需冲正。
    33. DB 成功但 rollback? → 下游少做,需补发。
    34. 怎么补? → 对账 + 补偿 Job。
    35. 和本地消息表区别? → MQ 托管 vs DB 托管。
    36. 本地消息表怎么做? → 同事务写业务+outbox,定时投递。
    37. 和 Kafka 事务区别? → 作用域不同。
    38. Kafka 事务能覆盖 DB 吗? → 不能。
    39. 和 XA 区别? → 无阻塞、最终一致。
    40. 和 Saga/TCC 区别? → 单服务本地事务 vs 跨服务。
    41. 适合什么场景? → 订单、支付、账户流水。
    42. 不适合什么? → 本地事务不可查、跨多服务。
    43. 回查接口要注意什么? → 幂等、只读、超时。
    44. 回查线程池? → TransactionMQProducer 可配 executor。
    45. Producer 挂了会怎样? → 恢复后回查,或超限丢弃。
    46. Broker 挂了会怎样? → 半消息按存储可靠性恢复。
    47. 怎么监控? → 半消息数、回查失败、丢弃日志。
    48. 5.x 有变化吗? → Proxy/gRPC 也支持,语义一致。
    49. 能替代分布式事务吗? → 不能,只能解决本地事务+发消息。
    50. 面试怎么总结? → 半消息 → 本地事务 → commit/rollback → 回查 → 幂等 → 对账兜底。
  • 生产案例/取舍(示例,替换成你的项目):

    • 订单创建后发履约消息,DB 提交成功但发送超时,履约没收到;改事务消息 + 回查订单表,恢复。
    • checkLocalTransaction 里查缓存,缓存过期返回 UNKNOW,回查 15 次后消息被丢;改查 DB 主库。
    • 回查接口超时 30 秒,半消息堆了几万条;加索引 + 超时 200ms + 独立线程池。
    • 本地事务失败但代码返回 COMMIT,下游多发了货;修返回值 + 人工冲正。
    • 事务消息误加延迟参数,发送直接失败;去掉延迟,用普通消息 + 定时任务。
    • 消费端没做幂等,commit 重试导致重复扣款;加唯一键(5.1-2)。
    • 半消息 Topic 堆积告警,排查是 Producer 实例假死;重启 + 加回查监控。
    • 回查超限丢弃日志没人看,月底对账发现少 200 单;加丢弃告警 + 自动补偿。
    • 团队已用 Kafka,为了事务消息引入 RocketMQ;评估后改用 outbox,减少一套中间件。
    • 跨三个服务的分布式事务想用事务消息一把梭,发现只能覆盖本地事务 + 发消息;改 Saga + 对账。
    • 事务消息 + 本地消息表双保险,回查失败时由 outbox 补发;复杂度上升但兜底更稳。
    • 取舍:事务消息换开发简单,代价是绑 MQ + 回查限制;outbox 换通用与可审计,代价是多表与投递任务;强一致换 XA,代价是阻塞与性能;最终一致换吞吐,代价是对账与补偿。
  • 易错点:

    • 认为事务消息是强一致/2PC。
    • 认为半消息消费者能看到。
    • 认为半消息存在真实 Topic。
    • 认为本地事务在发半消息之前执行。
    • 认为 commit 丢了消息就丢了。
    • 认为回查可以查内存。
    • 认为回查会无限重试。
    • 认为回查超限会进死信(实际是丢弃 + 日志)。
    • 认为事务消息能保证只消费一次。
    • 认为消费端不需要幂等。
    • 认为事务消息支持延迟/批量。
    • 认为事务消息能覆盖跨服务分布式事务。
    • 认为 Kafka 事务能替代事务消息。
    • 认为本地消息表不需要清理。
    • 认为返回 ROLLBACK 没有风险。
    • 认为返回 COMMIT 一定正确。
    • 认为 UNKNOW 会立即重试。
    • 认为半消息不占存储。
    • 认为回查频率不可调。
    • 认为 Producer 重启后事务自动恢复。
    • 认为 Broker 会替业务判断事务结果。
    • 认为事务消息不需要对账。
    • 认为事务消息能解决消息重复。
    • 认为事务消息能解决下游失败。
    • 认为所有业务都适合事务消息。
    • 认为事务消息没有性能代价。
    • 认为半消息堆积只是存储问题。
    • 认为 5.x 事务消息语义完全变了。
  • 30 秒口述稿:

RocketMQ 事务消息解决的是本地数据库事务和发消息的原子性。流程是三步:先发一条半消息,写到半消息 Topic,消费者看不到;然后执行本地事务,成功就发 commit,Broker 把消息转到真实 Topic,失败就发 rollback 丢弃;如果 commit 或 rollback 丢了,Broker 每 60 秒扫描、超过 6 秒没确认就回查生产者的 checkLocalTransaction,由它查数据库真实状态决定提交还是回滚,最多查 15 次,超了就丢弃并打日志。所以回查必须查库不能查内存,业务必须监控丢弃日志并配对数补偿。它是最终一致,不是 2PC,消费端仍然会收到重复消息,必须幂等。另外 4.x 的事务消息不支持延迟和批量。

  • 3 分钟展开顺序:结论(半消息 + 本地事务 + 回查,最终一致)→ 要解决的“DB 与消息不原子”问题 → 半消息的存储与不可见原理 → 正常三段流程 → commit/rollback 丢失后的回查机制 → TransactionListener 两个方法与返回值 → 各步骤失败分支表 → 与 XA/outbox/Kafka 事务/Saga 的边界 → 限制(延迟/批量/回查次数)→ 监控、对账与补偿 → 消费端幂等。