消息队列 / 技术文章

消息队列技术选型:主流消息队列对比

很多团队第一次做消息队列选型时,会先拉一张 Excel:

Kafka 吞吐高,RabbitMQ 路由强,RocketMQ 支持事务消息,Pulsar 存算分离。

然后给“性能”“可靠性”“顺序消息”“延迟消息”“运维成本”分别打 1~5 分,最后算出一个总分最高的产品。

这种方法看起来客观,实际上很容易把选型带偏。

因为 Kafka、RabbitMQ、RocketMQ 和 Pulsar 并不是四个只在性能参数上不同的同类产品。它们对“消息是什么”“消息应该怎样存储”“消费者怎样读取消息”“Broker 应该承担多少职责”的理解,本身就不一样。

真正有效的选型,不是问:

哪个消息队列最强?

而是问:

我的系统究竟需要一条可重复读取的事件日志、一套可靠的业务消息机制,还是一个面向多个团队的消息基础设施?

这个问题回答清楚以后,候选范围通常会迅速缩小。

消息队列选型

先理解四种 MQ 分别在解决什么问题

如果只记住一句话,可以先建立下面这组心智模型:

产品 更合适的理解
Kafka 分布式事件日志
RabbitMQ 消息路由与任务队列
RocketMQ 面向业务事件的分布式消息平台
Pulsar 分层式消息与流平台

这比比较“谁的 TPS 更高”重要得多。

Kafka:消息首先是一条可以反复读取的日志

Kafka 最重要的设计不是“快”,而是 Log。

Producer 把事件追加到 Topic 的 Partition 中,消息不会因为某个 Consumer 已经消费就立即消失。Consumer Group 维护自己的消费位置,不同 Consumer Group 可以分别读取同一份数据。

因此:

text
订单事件
   │
   ├── 风控系统
   ├── 数据仓库
   ├── 推荐系统
   └── 实时计算

这些系统并不需要生产者分别发送四份消息。

它们读取的是同一条事件流。

Kafka 的顺序保证也建立在 Partition 上:同一 Partition 内的记录保持顺序,但不同 Partition 之间不存在 Topic 级的全局顺序。使用相同 Key 可以把相关事件映射到同一 Partition。

所以 Kafka 很适合:

日志采集、CDC、用户行为事件、数据管道、实时计算、Event Sourcing,以及“一份事件被多个系统独立消费”的场景。

一旦你的需求里频繁出现:

text
回放过去 7 天的数据
新增一个消费者重新从头计算
同一事件供多个系统独立消费
积压几亿条以后慢慢追赶

Kafka 的设计会非常自然。

反过来,如果你的核心诉求是“订单超时 30 分钟自动取消”“失败后按照业务规则重试”“消息根据复杂规则路由到不同队列”,那就不能因为 Kafka 吞吐高便直接选择 Kafka。


RabbitMQ:消息首先是要被正确送到某个消费者

RabbitMQ 的思路和 Kafka 很不一样。

RabbitMQ 的核心抽象之一是:

text
Producer
    │
    ▼
 Exchange
    │
    ├──── routing rule ────► Queue A
    │
    ├──── routing rule ────► Queue B
    │
    └──── routing rule ────► Queue C

Producer 不一定直接关心消息最终进入哪个 Queue,而是把消息交给 Exchange,由 Exchange、Binding 和 Routing Key 决定消息流向。

Direct、Topic、Fanout 等 Exchange 可以构造相当灵活的路由关系;RabbitMQ 还支持 Exchange-to-Exchange Binding,使复杂消息拓扑可以继续组合。

这意味着 RabbitMQ 特别适合这样的业务:

text
订单创建
  ├─ 电商订单 → order.queue
  ├─ 海外订单 → overseas.queue
  ├─ VIP订单 → vip.queue
  └─ 所有订单 → audit.queue

它关心的是:

这条消息现在应该交给谁。

而 Kafka 更关心:

这条事件应该被可靠地保留下来,以便谁需要谁去读。

这是两者非常本质的区别。

RabbitMQ 现在做高可用时还需要注意一个容易过时的知识点:RabbitMQ 4.x 中,Quorum Queue 是需要复制和高可用时的重要队列类型,经典队列镜像已经在 RabbitMQ 4.0 中移除。

所以不要再按照很多旧文章里的“Classic Mirrored Queue”方案设计新系统。


RocketMQ:很多企业业务消息需求直接进入了 Broker

RocketMQ 很容易被简单描述为:

一个类似 Kafka、但更适合 Java 业务系统的 MQ。

这种描述并不准确。

RocketMQ 真正有特点的地方,是它把大量企业业务系统常见的问题直接做成了消息能力。

例如电商系统里经常出现这样一条链路:

text
创建订单
    │
    ▼
本地事务提交
    │
    ├──► 库存
    ├──► 积分
    ├──► 营销
    └──► 数据分析

这里最麻烦的问题不是“每秒能写多少消息”,而是:

text
数据库事务成功了,但消息没发出去怎么办?
消息发出去了,但数据库事务失败怎么办?

RocketMQ 的事务消息就是针对这种问题设计的:Broker 首先保存暂不可投递的事务消息,Producer 执行本地事务,再根据结果提交或回滚消息;在状态不明确时还可以进入事务检查流程。

除此之外,RocketMQ 还原生提供 FIFO、延迟消息、消费重试和死信等机制。RocketMQ 5.x 的 FIFO 并不是整个 Topic 全局串行,而是通过 Message Group 对相关消息进行有序处理。

这使得下面这些场景非常契合 RocketMQ:

text
订单创建 → 支付 → 发货
支付超时关闭订单
库存锁定超时释放
营销活动定时触发
业务失败自动重试
本地事务与消息发送保持最终一致

换句话说,RocketMQ 的优势往往不是一个单独的性能数字,而是:

很多原本需要应用自己实现的业务消息机制,Broker 已经提供了。


Pulsar:先把 Broker 和存储拆开

Pulsar 经常被介绍成“比 Kafka 更新的下一代消息队列”。

这种说法容易制造误解。

Pulsar 更值得关注的是它的架构选择。

Pulsar Broker 主要负责连接、协议、Topic lookup 和消息分发,持久化消息则由 BookKeeper 的 Bookie 节点承担。

可以粗略理解成:

text
Producer / Consumer
        │
        ▼
   Pulsar Broker
        │
        ▼
    BookKeeper
        │
        ▼
   Persistent Storage

Broker 和持久化存储职责被分离,因此计算层和存储层可以采用不同的扩展方式。Pulsar 还把 tenant、namespace、多种 subscription 类型以及 geo-replication 等能力放进了核心模型。

例如同一个 Topic 可以根据不同订阅方式表现出不同的消费模型。

Shared 可以让多个消费者分摊消息,但不保证顺序;Key_Shared 则可以让相同 Key 的消息交给同一消费者并保持按 Key 的投递顺序。

因此 Pulsar 更值得进入候选名单的情况,通常不是:

我有一个普通 Spring Boot 服务需要异步发消息。

而是:

我准备建设一个公司级消息平台。

例如:

text
数十个业务团队
数万个甚至更多 Topic
多个租户
多个机房或地域
消息需要长期保存
Broker 和存储希望独立扩容
既有 Queue,又有 Streaming

在这种尺度下,Pulsar 的架构价值才真正开始体现出来。

真正选型时,先看这几个差异

把四种 MQ 放在一起,可以得到比“功能支持 √/×”更有意义的一张表。

维度 Kafka RabbitMQ RocketMQ Pulsar
核心模型 Partition Log Exchange + Queue Topic + Queue + Consumer Group Topic + Subscription
强项 事件流、回放、大吞吐 路由、任务队列、消息控制 交易型业务消息 多租户、流与队列统一、分层架构
消息回放 很自然 传统 Queue 模型下不是核心能力 支持重新消费,但事件日志生态不如 Kafka 突出 原生支持基于持久化日志重新读取
复杂路由 通常由应用或流处理实现 很强 Tag / Filter 等业务过滤能力 Subscription / Topic 模型灵活
顺序模型 Partition 内顺序 Queue FIFO,但多消费者和重投会影响实际处理顺序 Message Group FIFO Exclusive / Failover / Key_Shared 等模型
事务业务消息 Kafka Transaction 更偏流处理链路语义 通常由应用设计一致性方案 原生事务消息是重要能力 支持事务
延迟业务消息 通常额外设计 TTL / DLX 等方式可实现 原生延迟消息 支持延迟投递
大规模积压 非常典型 需要结合 Queue 类型和容量设计 支持 BookKeeper 持久化层适合大规模消息存储
多租户 可以通过权限和集群规划实现 通常通过 vhost 等机制隔离 可做业务级隔离 Tenant / Namespace 是核心模型
跨地域 可以建设跨集群复制体系 通常需要额外架构设计 可以建设多集群方案 Geo-replication 是核心能力之一
运维形态 成熟,但 Partition 与存储规划重要 相对直观 企业业务场景成熟 Broker、BookKeeper、Metadata Store 等组件更多

这里最值得注意的是:

没有哪一列应该直接转换成 1~5 分。

因为能力的重要程度完全取决于业务。

对于日志平台,RabbitMQ 再强的路由能力可能一分价值都没有。

对于订单系统,Kafka 再强的事件回放能力,也未必比事务消息和延迟消息重要。

第一个分水岭:你是在做“事件流”还是“业务消息”

这是整个选型里最值得先问的问题。

假设用户支付完成:

text
PaymentSucceeded

如果你的思维方式是:

text
这个事件应该永久记录下来。

风控读取它。
积分读取它。
推荐系统读取它。
数仓读取它。

以后出现一个新的数据系统,
它还可以重新读取过去的 PaymentSucceeded。

这是典型的事件流思维。

Kafka 通常会非常顺手。

如果你的思维方式是:

text
支付成功以后:

给积分服务发消息;
失败重试;
给库存服务发消息;
处理不了进入死信;
30 分钟后检查某个状态;
还要保证订单 ID 相同的消息顺序。

这已经明显进入业务消息领域。

RocketMQ 或 RabbitMQ 往往更加自然。

很多公司最终同时使用 Kafka 和 RocketMQ / RabbitMQ,也正是这个原因。

它们解决的根本就不完全是同一个问题。

第二个分水岭:积压是异常,还是系统的正常状态

这个问题非常关键,却经常被忽略。

有些系统认为:

text
队列里积压 100 万条消息

意味着生产事故。

而有些系统认为:

text
Topic 中保存几十亿条历史事件

完全正常。

Kafka 的设计天然接受:

数据在那里,Consumer 按自己的速度读取。

因此“消息已经被消费”并不意味着消息立即从系统中消失。

RabbitMQ 的传统 Queue 思维则更接近:

消息等待被处理,处理完成以后确认。

两种设计都合理,只是解决的问题不同。

所以在技术评审中,与其问:

最大 TPS 是多少?

不如先问:

如果消费者停止 6 小时,会积压多少数据?

假设生产速率为每秒 30,000 条,平均消息大小 2 KB:

text
30,000 × 2 KB × 21,600 秒
≈ 1.2 TB

这时候问题就不再只是 MQ 能不能“扛住 3 万 TPS”。

而是:

text
1.2 TB 积压放在哪里?
磁盘什么时候打满?
Consumer 恢复以后多久追平?
追赶流量会不会再次打爆下游数据库?
Broker 重启需要多久?

这才是真正的生产问题。

第三个分水岭:你说的“顺序消息”究竟是哪一种顺序

“必须保证顺序”是架构评审里非常危险的一句话。

因为它可能意味着四种完全不同的需求:

text
所有消息全局严格有序

同一个订单有序

同一个用户有序

同一个设备有序

前三者的工程成本完全不同。

绝大多数业务真正需要的是:

text
OrderId = 10001

Created
Paid
Shipped
Completed

只要求同一个 OrderId 的事件顺序正确。

Kafka 可以通过相同 Key 进入同一个 Partition 实现这种局部顺序;RocketMQ 可以通过 Message Group 实现 FIFO;Pulsar 可以通过 Key_Shared 等消费模型保持相同 Key 的消息有序。RabbitMQ 本身以 FIFO 方式从队列取消息,但多个消费者、优先级以及重新投递都会影响应用最终观察到的处理顺序。

所以正确的问题不是:

MQ 支不支持顺序消息?

而应该是:

顺序的业务 Key 是什么?

如果连这个问题都回答不出来,通常意味着需求本身还没有定义清楚。

第四个分水岭:不要迷信 Exactly Once

消息系统里最容易制造误解的词之一,就是:

text
Exactly Once

假设消费者收到一条支付消息:

text
MQ
 │
 ▼
Consumer
 │
 ▼
UPDATE account_balance
 │
 ▼
ACK

如果数据库 UPDATE 成功以后,Consumer 在 ACK 之前宕机:

text
数据库:成功

MQ:不知道成功

消息就可能再次投递。

于是第二次消费时:

text
UPDATE account_balance

可能再次执行。

真正的问题已经不只是 MQ 的投递语义,而是:

MQ 和你的业务数据库之间有没有共同事务边界?

Kafka 官方文档同样强调,消息投递语义需要分别考虑生产持久化和消费处理,“exactly once”必须明确它所覆盖的边界。

因此生产系统更稳妥的设计通常仍然是:

text
at-least-once
        +
业务幂等

例如支付通知可以利用业务唯一键:

sql
INSERT INTO payment_event (
    event_id,
    order_id,
    event_type
)
VALUES (
    'PAY_20260918_001',
    'ORDER_10001',
    'PAYMENT_SUCCESS'
);

并对 event_id 建立唯一约束。

即使 MQ 重复投递:

text
第一次:INSERT 成功
第二次:唯一键冲突 → 已处理

业务结果仍然只有一次。

这比在架构图上简单写一句“MQ 保证 Exactly Once”可靠得多。

RocketMQ 和 RabbitMQ 到底怎么选

这两个产品最容易同时出现在业务系统候选名单里。

区别可以这样理解。

如果你的系统充满:

text
Exchange
Routing Key
不同规则进入不同 Queue
Worker 消费任务
ACK / NACK
Dead Letter

RabbitMQ 的模型非常自然。

如果你的系统充满:

text
订单
支付
库存
事务消息
顺序消息
延迟消息
消费重试
死信

RocketMQ 往往与业务模型贴得更近。

尤其是在 Java 企业应用里,如果本身已经存在完整的 RocketMQ 部署、监控和运维经验,那么为了理论上的某一点性能差异更换中间件,通常意义并不大。

中间件最大的成本从来不是:

text
pom.xml 多一个 dependency

而是:

text
凌晨 3 点 Broker 出问题以后,
有没有人知道应该查什么。

Kafka 和 Pulsar 到底怎么选

这两个更容易出现在事件平台、数据基础设施和大规模消息平台建设中。

Kafka 最大的现实优势之一是成熟。

Kafka Connect、Kafka Streams、Flink、Debezium 以及大量数据库和数据平台都围绕 Kafka 建立了成熟集成。

如果你的系统是:

text
MySQL
  │
Debezium
  │
Kafka
  │
  ├── Flink
  ├── Elasticsearch
  ├── Data Lake
  └── Recommendation

生态本身就是架构能力的一部分。

Pulsar 的吸引力则更多来自它的分层架构以及原生多租户、Subscription、Geo-replication 等设计。Pulsar 的 Broker 与 BookKeeper 存储层分工明确,跨集群复制也属于其核心架构能力。

所以如果组织面对的是:

text
很多团队
大量 Topic
独立扩缩 Broker 与 Storage
多租户隔离
多个地域
Queue 与 Streaming 共存

Pulsar 值得认真 PoC。

但如果只是因为:

Pulsar 架构看起来更新。

就迁移一个已经稳定运行的 Kafka 平台,通常没有足够理由。

架构先进不等于迁移收益大于迁移成本。

不要用“总分最高”决定 MQ

假设做一张表:

text
Kafka      92
RocketMQ   89
Pulsar     88
RabbitMQ   85

然后宣布:

text
所以选择 Kafka。

这种评分的技术意义其实非常有限。

更靠谱的方法是先使用硬性条件淘汰。

例如某支付系统提出:

要求 是否必须
同订单事件有序 是
本地事务与消息最终一致 是
延迟消息 是
Java SDK 成熟 是
历史事件长期回放 否
多地域复制 否
海量 Topic 否

这时选型范围其实已经很小了。

反过来,一个数据平台如果要求:

要求 是否必须
PB 级长期事件流 是
Consumer 独立 Offset 是
历史回放 是
Flink / CDC 生态 是
复杂 Exchange 路由 否
事务业务消息 否

结果显然又会不同。

所以:

先用约束淘汰,再用 PoC 决胜。

而不是给所有产品强行算一个“综合能力分”。

一套更实用的选型结论

如果现在必须快速形成第一轮候选,可以使用下面这张图式判断:

text
                        消息系统
                           │
             ┌─────────────┴─────────────┐
             │                           │
          事件流                      业务消息
             │                           │
      是否大量回放?               是否复杂业务语义?
             │                           │
          是 │                           │ 是
             ▼                           ▼
          Kafka                    RocketMQ
             │
     是否需要平台级多租户、
     存储独立扩展、跨地域?
             │
          是 ▼
         Pulsar


业务消息
   │
   └── 如果核心是灵活路由、
       Worker / Task Queue、
       ACK / DLX
             │
             ▼
         RabbitMQ

它并不是绝对规则,却比“谁 TPS 高就选谁”更接近真实工程决策。

简单归纳就是:

你的核心问题 优先进入候选
日志、CDC、事件流、实时计算、历史回放 Kafka
Worker、任务队列、灵活路由、低延迟业务消息 RabbitMQ
订单、支付、库存、事务、延迟、顺序业务消息 RocketMQ
企业级多租户消息平台、海量 Topic、跨地域、存储独立扩展 Pulsar

这里故意用了“进入候选”,而不是“直接选择”。

因为生产环境最后一步必须是 PoC。

PoC 不应该只是跑一个 TPS

很多所谓 MQ PoC 最后都会变成:

text
启动 Producer
发送 1000 万条消息
记录 TPS

然后:

text
A:18 万 TPS
B:21 万 TPS

选择 B。

这种测试几乎没有模拟真实生产环境。

真正值得测的是系统进入异常状态以后会发生什么。

例如你的真实生产目标是:

yaml
message_size: 2KB

normal:
  produce_rate: 20000 msg/s
  consumers: 12

peak:
  produce_rate: 60000 msg/s
  duration: 30m

failure_test:
  consumer_outage: 2h
  broker_failure: 1 node
  network_latency: 50ms

acceptance:
  p99_latency: < 200ms
  message_loss: 0
  recovery_time: < 10m
  backlog_catchup: < 60m

那么 PoC 应该真的制造这些条件。

例如先让消费者停止两小时:

text
Producer ───────────────► MQ

Consumer X
Consumer X
Consumer X

产生大规模积压。

然后重新启动 Consumer,观察:

text
积压增长速度
磁盘增长
Broker CPU
网络带宽
消费追赶速度
下游数据库压力
P99 延迟

再主动杀掉一个 Broker:

bash
kill -9 <BROKER_PID>

观察:

text
Producer 是否报错
Consumer 是否中断
Leader / Queue 是否切换
多久恢复
有没有重复消息
有没有乱序
人工是否需要介入

最后再做 Consumer 扩容:

text
4 Consumers
      ↓
16 Consumers

观察 Rebalance 或重新分配期间:

text
是否暂停消费
暂停多久
是否发生重复消费
顺序是否受到影响

这种 PoC 得出来的数据,才真的能进入架构评审。

最后真正要选的,其实不是 MQ

消息队列选型做到最后,表面是在比较:

text
Kafka
RabbitMQ
RocketMQ
Pulsar

实际上是在选择一种系统架构。

选择 Kafka,往往意味着接受:

text
Partition
Offset
Consumer Group
事件流
Replay

选择 RabbitMQ,意味着系统会更多围绕:

text
Exchange
Queue
Routing
ACK
Dead Letter

选择 RocketMQ,意味着大量业务消息逻辑可以直接建立在:

text
Transaction
FIFO
Delay
Retry
Consumer Group

之上。

选择 Pulsar,则意味着你开始更多考虑:

text
Broker
BookKeeper
Tenant
Namespace
Subscription
Geo-replication

所以最好的消息队列并不存在。

真正存在的是:

与你的消息模型最匹配,同时又在团队运维能力范围内的消息队列。

一个每秒 10 万消息的系统,不一定需要 Kafka。

一个订单量并不夸张的交易系统,也可能非常适合 RocketMQ。

一个复杂路由的后台任务系统,RabbitMQ 可能比更“高吞吐”的方案简单得多。

而只有当你的问题已经上升到多个团队、海量 Topic、多租户和跨地域消息基础设施时,Pulsar 的架构复杂度才可能真正转化成收益。

因此在架构评审会上,与其问:

Kafka、RabbitMQ、RocketMQ、Pulsar,哪个更好?

不如把问题换成:

如果明天消费者停止两个小时、积压达到 TB 级、一个 Broker 突然宕机,并且业务要求同一订单仍然有序,我们希望系统表现成什么样?

当这个问题能够被准确回答时,消息队列通常已经选了一半。

目录与阅读设置

记录一个想法

消息队列技术选型:主流消息队列对比

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通