Kafka、RabbitMQ 与 RocketMQ:日志流 vs 任务队列

Hello,我是小兔大白糖。 读完能按可重放/多订阅 vs 复杂路由/任务派发选型,并理解日志型中间件之间的并存分工。
日志流 vs 任务队列:Kafka 偏可重放多订阅;RabbitMQ/RocketMQ 偏路由与任务派发——可并存分工。
估计阅读时间:73 分钟
一句话结论是什么?
Kafka 是基于日志存储(Log-based)的分布式流平台,采用 Pull Model,擅长高吞吐、持久化、可重放的消息流处理;RabbitMQ 是基于队列语义(Queue-based)的消息代理,采用 Push Model,擅长低延迟、复杂路由、实时任务分发。选型核心在于:需要"读档案"时用 Kafka,需要"派任务"时用 RabbitMQ。
1. 这是什么?概念怎么定义
1.1 Kafka:分布式日志存储与流处理平台
Kafka 最初由 LinkedIn 设计,其核心哲学是将消息视为不可变的日志(Immutable Log)。Producer 向 Topic 追加记录,Consumer 从 Topic 按 Offset 顺序读取。消息在消费后不会立即删除,而是根据保留策略(时间或大小)过期后才清理。
核心概念:
- Topic / Partition:Topic 是逻辑消息流,Partition 是物理分片,每个 Partition 是一个有序的、不可变的记录序列
- Offset:消费者在 Partition 中的位置标记,由 Consumer 自行管理
- Consumer Group:组内消费者共同消费一个 Topic 的所有 Partition,实现水平扩展与负载均衡
- Replication:每个 Partition 有多个 Replica(Leader + Follower),保证高可用
- Broker:Kafka 服务节点,负责存储和转发消息
1.2 RabbitMQ:高级消息队列协议(AMQP)的实现
RabbitMQ 实现了 AMQP 0-9-1 协议,其核心哲学是消息的可靠路由与投递。Producer 将消息发送到 Exchange,Exchange 根据 Binding Rule 路由到 Queue,Consumer 从 Queue 中取出消息并 ACK,消息被确认后从 Queue 中删除。
核心概念:
- Exchange:消息路由中枢,决定消息如何分发到 Queue。类型包括 Direct、Topic、Fanout、Headers
- Queue:消息的存储容器,具有 FIFO 语义
- Binding:Exchange 与 Queue 之间的路由规则
- Channel:轻量级的逻辑连接,复用真实的 TCP 连接
- Virtual Host:逻辑隔离的命名空间,类似数据库的 Schema
1.3 类比说明
想象一个大型企业的内部信息流:
- Kafka 像图书馆的档案室:所有文件(消息)按时间顺序归档到不同的书架(Partition)上。读者(Consumer)可以自行决定从哪一天、哪一页(Offset)开始阅读。文件不会被借走删除,而是保留一段时间后统一清理。多个读者可以同时阅读同一份档案,互不影响。
- RabbitMQ 像快递分拣中心:包裹(消息)到达后,分拣员(Exchange)根据地址标签(Routing Key)迅速分派到不同的区域货架(Queue)。快递员(Consumer)从货架取走包裹并签收(ACK),包裹随即从货架移除。分拣中心的核心价值在于"快速、准确地将包裹送到对的人手中"。
1.4 为什么需要它们
在分布式系统中,服务间直接同步调用存在以下问题:
- 耦合度高:调用方与被调用方强绑定,任何一方故障都会级联影响
- 扩展困难:峰值流量直接冲击下游,缺乏缓冲
- 可靠性差:网络抖动或进程重启导致请求丢失
- 异构系统集成:不同语言、不同协议的服务难以直接通信
消息队列通过异步解耦和流量削峰解决上述问题:
- Kafka 更侧重于数据管道(Data Pipeline)和事件溯源(Event Sourcing),解决海量数据的可靠传输与持久化
- RabbitMQ 更侧重于任务分发(Task Distribution)和实时通知(Real-time Notification),解决复杂路由与低延迟投递
2. 核心原理是什么?
2.1 架构哲学:Pull Model vs Push Model
这是两者最根本的差异。
Kafka Pull Model
- Consumer 主动向 Broker 发起
fetch请求,携带期望读取的 Offset 和最大字节数 - Consumer 完全掌控消费节奏:可以批量拉取、按需拉取、甚至暂停消费(Backpressure 自然实现)
- Broker 是无状态的(Relative to Consumer 消费进度),Consumer Offset 存储在 Kafka 内部 Topic
__consumer_offsets或外部系统中 - 优势:Consumer 可根据自身处理能力调节流量,Broker 实现简单
- 劣势:低流量场景下可能产生空轮询,需要配置
fetch.min.bytes和fetch.max.wait.ms平衡延迟与吞吐
RabbitMQ Push Model
- Broker 主动将消息推送给已订阅的 Consumer,通过 Channel 的 TCP 连接持续投递
- Consumer 通过
basic.qos的prefetch_count声明自己的处理能力,Broker 据此控制推送速率 - 优势:低延迟,消息到达即可投递,无需 Consumer 轮询
- 劣势:Consumer 处理能力不足时,若 prefetch 配置不当可能导致内存溢出或被 Broker 阻塞;Broker 需要维护每个 Consumer 的投递状态
2.2 存储模型:Log Segment + Index vs Queue + Exchange
Kafka 存储模型
Kafka 的存储是面向磁盘的顺序写优化设计:
- 每个 Partition 对应文件系统上的一个目录(如
topic-0/) - 每个目录中包含多个 Segment 文件(默认 1GB),文件名即该 Segment 起始 Offset(如
00000000000000000000.log) - 每个
.log文件配套一个.index文件(稀疏索引,默认 4KB 一条)和一个.timeindex文件(时间戳索引) - 消息格式:
[Offset] [MessageSize] [CRC] [MagicByte] [Attributes] [KeyLength] [Key] [ValueLength] [Value] - 读取流程:根据目标 Offset 二分查找定位 Segment -> 加载对应
.index做稀疏索引 -> 顺序读取.log文件 - Zero Copy:Kafka 使用
sendfile()系统调用,数据直接从 Page Cache 发送到网卡,避免用户态与内核态的数据拷贝
RabbitMQ 存储模型
RabbitMQ 的存储是面向队列的内存+磁盘混合设计:
- 内存优先:消息默认先进入内存队列,当内存达到阈值(
vm_memory_high_watermark,默认 40%)时,消息被持久化到磁盘(Paged Out) - 持久化消息:标记为
persistent的消息会写入磁盘(Mnesia 数据库或消息存储文件),但仅在 Queue 声明为 Durable 时才保证重启不丢失 - Exchange 不存储消息:Exchange 只做路由决策,消息不驻留 Exchange
- Queue 索引:使用
queue_index模块管理消息在磁盘上的位置,支持快速定位与删除 - Lazy Queue(RabbitMQ 3.6+):消息直接写入磁盘,减少内存压力,适合长队列场景
2.3 消费模型:Consumer Group vs Queue Binding
Kafka Consumer Group
- 一个 Consumer Group 内的所有 Consumer 共同消费一个 Topic 的所有 Partition
- Partition 与 Consumer 是 1:N 映射(一个 Partition 只能被一个 Consumer 消费,一个 Consumer 可以消费多个 Partition)
- Rebalance:当 Consumer 加入或退出 Group 时,Coordinator 触发重新分配 Partition 所有权。Rebalance 期间整个 Group 暂停消费,是 Kafka 最著名的痛点之一
- Offset 管理:Consumer 可选择自动提交(
enable.auto.commit=true)或手动提交(commitSync/commitAsync)
RabbitMQ Queue Binding
- 多个 Consumer 可以订阅同一个 Queue,Broker 以 Round-Robin 方式分发消息
- 每条消息只会被一个 Consumer 处理(Work Queue 模式)
- Fanout 模式下,多个 Queue 绑定到同一个 Exchange,实现消息的广播(Pub/Sub)
- 不存在 Rebalance 概念,Consumer 的增删只影响该 Queue 的消费速率
2.4 一致性保证与 Delivery Semantics
Kafka
- At Most Once:Consumer 先提交 Offset,再处理消息。处理失败则消息丢失
- At Least Once:Consumer 先处理消息,再提交 Offset。处理成功但提交失败会导致重复消费
- Exactly Once:通过幂等 Producer(
enable.idempotence=true,单 Partition 内去重) + 事务 API(跨 Partition 原子写入) + Consumer 事务 Offset 提交实现。Kafka Streams 提供端到端 Exactly-Once 抽象
RabbitMQ
- At Most Once:Auto ACK 模式,消息发出即视为投递成功
- At Least Once:Manual ACK 模式,Consumer 处理成功后发送 ACK,失败则消息重新入队(或进入死信队列)
- Exactly Once:RabbitMQ 本身不提供原生 Exactly-Once。需要通过业务层幂等(如数据库唯一键、Redis SetNX)实现。Publisher Confirm + Consumer ACK 组合保证 At Least Once
3. 怎么用?关键代码与配置
3.1 Kafka 生产级配置与代码
Maven 依赖
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
<version>3.1.0</version>
</dependency>Producer 配置:交易流水实时上报
spring:
kafka:
bootstrap-servers: kafka-1:9092,kafka-2:9092,kafka-3:9092
producer:
key-serializer: org.apache.kafka.common.serialization.StringSerializer
value-serializer: org.apache.kafka.common.serialization.StringSerializer
acks: all # Leader + 所有 ISR 确认后才返回成功
retries: 3 # 发送失败重试次数
retry.backoff.ms: 1000 # 重试间隔
enable.idempotence: true # 幂等生产者,防止网络抖动导致重复写入
max.in.flight.requests.per.connection: 5
compression.type: lz4 # 压缩算法,减少网络传输与磁盘占用
batch.size: 65536 # 批次大小,提高吞吐
linger.ms: 10 # 等待时间,凑齐批次再发送@Component
public class TradeEventProducer {
private final KafkaTemplate<String, String> kafkaTemplate;
private static final String TOPIC = "trade.events.v1";
public TradeEventProducer(KafkaTemplate<String, String> kafkaTemplate) {
this.kafkaTemplate = kafkaTemplate;
}
public void sendTradeEvent(String userId, TradeEvent event) {
String key = userId; // 按用户 ID 分区,保证同一用户交易顺序
String payload = JsonUtils.toJson(event);
ProducerRecord<String, String> record = new ProducerRecord<>(
TOPIC,
key,
payload
);
// 添加消息头,用于链路追踪
record.headers().add("traceId", MDC.get("traceId").getBytes());
record.headers().add("eventTime", String.valueOf(System.currentTimeMillis()).getBytes());
ListenableFuture<SendResult<String, String>> future = kafkaTemplate.send(record);
future.addCallback(
result -> {
RecordMetadata metadata = result.getRecordMetadata();
log.info("Trade event sent to partition={}, offset={}, userId={}",
metadata.partition(), metadata.offset(), userId);
},
ex -> {
// 发送失败,落入本地死信文件或告警
log.error("Failed to send trade event for userId={}", userId, ex);
fallbackToLocalFile(event);
}
);
}
private void fallbackToLocalFile(TradeEvent event) {
// 实现本地持久化,等待后续重放
}
}Consumer 配置:风控特征实时计算
spring:
kafka:
consumer:
group-id: risk-feature-calculator
auto-offset-reset: earliest # 本地无 Offset 时从最早开始(保证不丢数据)
enable-auto-commit: false # 关闭自动提交,手动控制 Offset
max-poll-records: 500 # 单次 poll 最大记录数
fetch.min.bytes: 1048576 # 至少拉取 1MB 数据再返回,提高吞吐
fetch.max.wait.ms: 500 # 最长等待 500ms
isolation.level: read_committed # 只读取已提交的事务消息@Component
public class RiskFeatureConsumer {
private final RiskFeatureCalculator calculator;
private final KafkaTemplate<String, String> dlqTemplate;
private static final String TOPIC = "trade.events.v1";
private static final String DLQ_TOPIC = "trade.events.v1.dlq";
public RiskFeatureConsumer(RiskFeatureCalculator calculator,
KafkaTemplate<String, String> dlqTemplate) {
this.calculator = calculator;
this.dlqTemplate = dlqTemplate;
}
@KafkaListener(topics = TOPIC, containerFactory = "kafkaListenerContainerFactory")
public void onTradeEvent(List<ConsumerRecord<String, String>> records,
Acknowledgment ack) {
List<TradeEvent> events = new ArrayList<>();
for (ConsumerRecord<String, String> record : records) {
try {
TradeEvent event = JsonUtils.fromJson(record.value(), TradeEvent.class);
// 数据校验
if (!isValid(event)) {
log.warn("Invalid trade event, skipping offset={}", record.offset());
continue;
}
events.add(event);
} catch (Exception e) {
// 解析异常,直接送死信队列
sendToDLQ(record, e);
}
}
try {
// 批量计算风控特征
calculator.calculateBatch(events);
// 批量提交 Offset(至少一次语义)
ack.acknowledge();
} catch (Exception e) {
log.error("Feature calculation failed, not committing offset", e);
// 不提交 Offset,消息将被重新消费
throw e;
}
}
private void sendToDLQ(ConsumerRecord<String, String> record, Exception e) {
log.error("Sending poison pill to DLQ, offset={}, reason={}",
record.offset(), e.getMessage());
dlqTemplate.send(DLQ_TOPIC, record.key(), record.value());
}
private boolean isValid(TradeEvent event) {
return event != null && event.getAmount() != null
&& event.getTimestamp() != null;
}
}Kafka 延迟消息实现
Kafka 原生不支持延迟消息,通常通过"时间轮 Topic"或"独立调度服务"实现:
@Component
public class DelayedRiskCheckProducer {
private final KafkaTemplate<String, String> kafkaTemplate;
private static final String DELAY_TOPIC = "risk.delayed.check";
public void scheduleDelayedCheck(String orderId, long delayMs) {
long executeTime = System.currentTimeMillis() + delayMs;
DelayedTask task = new DelayedTask(orderId, executeTime);
// 将延迟消息发送到 Kafka,由消费者判断执行时间
kafkaTemplate.send(DELAY_TOPIC, orderId, JsonUtils.toJson(task));
}
}
@Component
public class DelayedRiskCheckConsumer {
private final KafkaTemplate<String, String> kafkaTemplate;
private static final String DELAY_TOPIC = "risk.delayed.check";
@KafkaListener(topics = DELAY_TOPIC, groupId = "delayed-check-processor")
public void process(ConsumerRecord<String, String> record) {
DelayedTask task = JsonUtils.fromJson(record.value(), DelayedTask.class);
long now = System.currentTimeMillis();
if (task.getExecuteTime() > now) {
// 时间未到,重新投递(配合退避策略,如指数退避)
long remaining = task.getExecuteTime() - now;
long backoff = Math.min(remaining, 60000); // 最多等 60s
kafkaTemplate.send(DELAY_TOPIC, record.key(), record.value());
try {
Thread.sleep(backoff);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
} else {
// 执行风控复核
performRiskCheck(task.getOrderId());
}
}
}3.2 RabbitMQ 生产级配置与代码
Maven 依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>配置:风控告警通知
spring:
rabbitmq:
host: rabbitmq.internal
port: 5672
username: ${RABBITMQ_USER}
password: ${RABBITMQ_PASS}
virtual-host: /risk
listener:
simple:
acknowledge-mode: manual # 手动 ACK
prefetch: 50 # QoS,控制推送速率
concurrency: 10 # 最小并发消费者
max-concurrency: 50 # 最大并发消费者
default-requeue-rejected: false # 处理失败不重入队,送死信队列
retry:
enabled: true
max-attempts: 3
initial-interval: 1000ms
multiplier: 2Producer:实时风控告警
@Component
public class RiskAlertPublisher {
private final RabbitTemplate rabbitTemplate;
private static final String EXCHANGE = "risk.alerts.exchange";
private static final String ROUTING_KEY = "risk.critical";
public RiskAlertPublisher(RabbitTemplate rabbitTemplate) {
this.rabbitTemplate = rabbitTemplate;
// 开启 Publisher Confirm,确保消息到达 Exchange
this.rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
if (!ack) {
log.error("Message failed to reach exchange: {}", cause);
}
});
// 开启 Return Callback,处理无法路由的消息
this.rabbitTemplate.setReturnsCallback(returned -> {
log.error("Message returned: exchange={}, routingKey={}, replyCode={}",
returned.getExchange(), returned.getRoutingKey(), returned.getReplyCode());
});
this.rabbitTemplate.setMandatory(true);
}
public void publishCriticalAlert(RiskAlert alert) {
MessageProperties props = new MessageProperties();
props.setDeliveryMode(MessageDeliveryMode.PERSISTENT); // 消息持久化
props.setPriority(10); // 高优先级
props.setHeader("alertType", alert.getType());
props.setHeader("severity", "CRITICAL");
props.setExpiration("60000"); // 60s TTL,超时未消费自动丢弃或转死信
Message message = new Message(JsonUtils.toJson(alert).getBytes(), props);
CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
rabbitTemplate.convertAndSend(EXCHANGE, ROUTING_KEY, message, correlationData);
}
}Consumer:告警处理与工单创建
@Component
@RabbitListener(queues = "risk.critical.alerts")
public class RiskAlertConsumer {
private final AlertProcessor alertProcessor;
private static final int MAX_RETRY = 3;
public RiskAlertConsumer(AlertProcessor alertProcessor) {
this.alertProcessor = alertProcessor;
}
@RabbitHandler
public void handleAlert(Message message, Channel channel,
@Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag,
@Header("x-death") List<Map<String, Object>> xDeath) throws IOException {
try {
RiskAlert alert = JsonUtils.fromJson(
new String(message.getBody()), RiskAlert.class);
// 幂等性检查:防止重复处理
if (alertProcessor.isProcessed(alert.getAlertId())) {
channel.basicAck(deliveryTag, false);
return;
}
alertProcessor.process(alert);
channel.basicAck(deliveryTag, false);
} catch (BusinessException e) {
// 业务异常,直接 ACK,避免无限重试
log.warn("Business exception processing alert: {}", e.getMessage());
channel.basicAck(deliveryTag, false);
} catch (Exception e) {
log.error("Failed to process alert", e);
// 判断是否超过重试次数
long retryCount = xDeath == null ? 0 :
xDeath.stream()
.filter(m -> "risk.critical.alerts".equals(m.get("queue")))
.count();
if (retryCount >= MAX_RETRY) {
// 送死信队列
channel.basicReject(deliveryTag, false);
} else {
// 重入队,延迟重试
channel.basicNack(deliveryTag, false, true);
}
}
}
}RabbitMQ 死信队列(DLQ)与延迟队列配置
@Configuration
public class RabbitRiskQueueConfig {
// 主队列:风控告警
@Bean
Queue riskAlertQueue() {
return QueueBuilder.durable("risk.critical.alerts")
.withArgument("x-dead-letter-exchange", "risk.dlx.exchange")
.withArgument("x-dead-letter-routing-key", "risk.dlq.routing")
.withArgument("x-message-ttl", 300000) // 消息在队列中存活 5 分钟
.build();
}
// 死信队列
@Bean
Queue riskDLQ() {
return QueueBuilder.durable("risk.critical.alerts.dlq").build();
}
// 延迟队列插件实现(需安装 rabbitmq_delayed_message_exchange 插件)
@Bean
CustomExchange delayedExchange() {
Map<String, Object> args = new HashMap<>();
args.put("x-delayed-type", "direct");
return new CustomExchange("risk.delayed.exchange",
"x-delayed-message", true, false, args);
}
@Bean
Queue delayedReviewQueue() {
return QueueBuilder.durable("risk.delayed.review").build();
}
@Bean
Binding delayedBinding() {
return BindingBuilder
.bind(delayedReviewQueue())
.to(delayedExchange())
.with("risk.review.routing")
.noargs();
}
}// 发送延迟消息(如:30 分钟后复核大额提现)
@Component
public class DelayedReviewPublisher {
private final RabbitTemplate rabbitTemplate;
private static final String DELAYED_EXCHANGE = "risk.delayed.exchange";
private static final String ROUTING_KEY = "risk.review.routing";
public void sendDelayedReview(String orderId, long delayMillis) {
MessageProperties props = new MessageProperties();
props.setHeader("x-delay", delayMillis); // 延迟时间
Message message = new Message(
JsonUtils.toJson(new ReviewTask(orderId)).getBytes(), props);
rabbitTemplate.send(DELAYED_EXCHANGE, ROUTING_KEY, message);
}
}3.3 消息可靠性对比配置表
| 维度 | Kafka | RabbitMQ |
|---|---|---|
| Producer 可靠性 | acks=all, enable.idempotence=true, 事务 API | Publisher Confirm (confirmSelect), 事务模式(不推荐,性能差) |
| Consumer 可靠性 | 手动 commitSync / commitAsync | 手动 basicAck / basicNack |
| 消息持久化 | 默认持久化到磁盘(log.flush.interval.messages) | deliveryMode=PERSISTENT + Queue durable=true |
| 顺序保证 | 同一 Partition 内严格有序(同 Key 同 Partition) | 同一 Queue 内 FIFO(单 Consumer) |
| 重复处理 | 业务层幂等(At Least Once)或 Kafka 幂等 Producer | 业务层幂等(At Least Once) |
| 死信处理 | 手动发送到 DLQ Topic | 原生 DLX(Dead Letter Exchange)机制 |
4. 业界怎么做?
4.1 LinkedIn:Kafka 的诞生与万亿级消息实践
LinkedIn 是 Kafka 的诞生地(2010 年由 Jay Kreps、Neha Narkhede 和 Jun Rao 开发)。在 LinkedIn,Kafka 每天处理超过 7 万亿条消息,峰值吞吐超过 1000 万条/秒。
使用场景:
- 用户行为事件流:所有前端埋点、后端服务事件统一接入 Kafka,供实时推荐、广告计费、安全风控使用
- 数据库变更捕获(CDC):通过 Kafka Connect 将 MySQL、Oracle 的 Binlog 实时同步到数据仓库(Espresso、Samza 流处理)
- 日志聚合:全站服务日志统一收集到 Kafka,下游对接 Hadoop、Spark 做离线分析
踩过的坑:
- Rebalance 风暴:早期 Consumer Group 扩容时,Coordinator 触发 Rebalance 导致全组停顿数秒。解决方案是改用 Sticky Assignor(
partition.assignment.strategy=org.apache.kafka.clients.consumer.StickyAssignor)和 Incremental Cooperative Rebalancing(KIP-429,Kafka 2.4+) - ZooKeeper 瓶颈:早期元数据管理依赖 ZooKeeper,大规模集群下 ZK 成为瓶颈。LinkedIn 主导了 KRaft 模式(Kafka 3.0+ 去掉 ZooKeeper)
- 磁盘 I/O 抖动:Broker 节点在日志清理(Log Compaction)时 I/O 飙升,导致生产延迟。解决方案是将 Log Cleaner 线程与生产流量错峰调度,并使用 SSD 替代 HDD
4.2 美团:RabbitMQ 在订单与风控通知中的实践
美团早期大量使用 RabbitMQ 处理订单状态流转、支付回调、风控告警等场景。在《美团技术团队》博客中,他们详细分享了 RabbitMQ 的大规模运维经验。
使用场景:
- 订单状态机:订单创建 -> 支付 -> 商家确认 -> 配送,各阶段通过 RabbitMQ 异步通知下游服务
- 风控实时拦截:风控引擎检测到异常订单后,通过 RabbitMQ Direct Exchange 将拦截指令推送到订单服务、支付服务、用户服务,要求低延迟(< 50ms)
- 延迟关单:用户下单后 15 分钟未支付,自动取消订单。通过 RabbitMQ TTL + 死信队列实现
踩过的坑:
- 内存告警与流控:大促期间消息堆积导致 RabbitMQ 节点内存占满,触发全局流控(Flow Control),所有 Producer 被阻塞。解决方案是:
- 设置
vm_memory_high_watermark_paging_ratio(默认 0.5),提前将消息 Page Out 到磁盘 - 使用 Lazy Queue,让消息直接进入磁盘
- 增加 Queue 的 TTL,避免无限期堆积
- 设置
- 镜像队列脑裂:早期使用 RabbitMQ 的 Mirrored Queue(镜像队列)做高可用,网络分区时容易出现脑裂(Split Brain),导致消息重复或丢失。解决方案是升级到 Quorum Queue(RabbitMQ 3.8+),基于 Raft 共识算法,牺牲部分性能换取更强的一致性
- Connection/Channel 泄漏:业务代码中未正确关闭 Channel,导致 Broker 句柄耗尽。解决方案是封装 Channel Pool,并在框架层强制使用
try-with-resources
4.3 高盛(Goldman Sachs):混合架构下的选型策略
高盛在交易系统中同时使用 Kafka 和 RabbitMQ:
- Kafka:用于交易流水(Trade Capture)的持久化与审计,所有订单和成交记录写入 Kafka,保留 7 年以满足监管要求(SEC/FINRA)。通过 Kafka 的 Log Compaction 保证每个订单 ID 的最新状态可被快速查询
- RabbitMQ:用于交易前风控(Pre-trade Risk Check)的实时阈值告警,当交易员即将突破风险限额时,风控引擎通过 RabbitMQ 在毫秒级推送告警到交易终端
5. 业务场景怎么对照?
5.1 风控/Risk 场景如何应用
Kafka 在风控中的典型应用
| 场景 | 说明 | 关键配置 |
|---|---|---|
| 海量交易流水采集 | 所有交易所/券商的成交回报(Trade Report)统一入 Kafka,供实时特征计算与离线审计 | acks=all, compression.type=lz4, retention.ms=2592000000(30天) |
| 实时风控特征计算 | Flink/Spark Streaming 读取 Kafka,计算用户滚动窗口内的交易额、频次、对手方集中度 | isolation.level=read_committed, max.poll.records=1000 |
| 审计日志持久化 | 监管要求所有风控决策(通过/拒绝/复核)不可篡改,Kafka 的不可变日志天然适合 | cleanup.policy=compact(保留每个 Key 最新值)+ delete |
| 跨机房数据复制 | Kafka MirrorMaker 2 将主机房交易数据异步复制到灾备机房 | replication.factor=3, min.insync.replicas=2 |
RabbitMQ 在风控中的典型应用
| 场景 | 说明 | 关键配置 |
|---|---|---|
| 风控告警通知 | 实时检测到大额异常转账,立即通过 RabbitMQ 推送 SMS/Email/Push 告警 | prefetch=10, ttl=60000, x-dead-letter-exchange |
| 工单流转 | 风控复核任务在"待复核 -> 复核中 -> 已通过/已拒绝"状态间流转 | Direct Exchange + per-queue routing |
| 延迟复核任务 | 高风险交易在 2 小时后自动触发二次复核(避免即时误判) | TTL Queue + DLX 或 Delayed Message Plugin |
| 低延迟规则触发 | 实时价格偏离超过阈值,触发熔断规则通知交易引擎 | basic.qos=1, 无持久化(内存队列) |
5.2 选型决策树
When to use Kafka:
- 事件溯源(Event Sourcing)与审计日志
- 需要高吞吐(> 10 万条/秒)的流数据处理
- 消息需要被多个独立 Consumer Group 重复消费(如一份交易数据同时给风控引擎和数据仓库)
- 需要按时间顺序重放消息(如复盘某时段的所有交易)
- 需要与 Flink、Spark Streaming、ksqlDB 等流处理框架深度集成
When to use RabbitMQ:
- 需要复杂路由(Topic、Headers、Fanout)的任务分发
- 需要低延迟(< 10ms)的实时通知与指令下发
- 需要延迟消息、优先级队列、死信队列等高级队列语义
- 消息量级适中(< 10 万条/秒),且需要快速上线
- 团队对 AMQP 生态更熟悉,运维资源有限(RabbitMQ 单机部署更简单)
When NOT to use Kafka:
- 每条消息需要独立路由到不同下游,且路由规则动态变化(Exchange 更灵活)
- 需要消息优先级(Priority Queue)
- 极低的部署资源环境(Kafka 最低需要 3 节点才能保证可用性)
When NOT to use RabbitMQ:
- 消息量极大,单节点 Queue 成为瓶颈(Queue 是单线程,镜像队列性能更差)
- 消息需要长期保留(RabbitMQ 的消息存储成本远高于 Kafka 的顺序日志)
- 需要跨大范围的 Offset 随机读取(Kafka 的稀疏索引不适合频繁的随机读)
5.3 常见误区 vs 正确做法
| 误区 | 正确做法 |
|---|---|
| Kafka 的 Consumer Group Rebalance 对业务无影响 | Rebalance 期间整个 Group 停止消费,应避免频繁扩缩容,使用 Sticky Assignor 减少影响 |
| RabbitMQ 的 Durable Queue + Persistent Message 一定不丢消息 | 消息在写入磁盘前若 Broker 崩溃仍可能丢失,应配合 Publisher Confirm 和集群镜像/Quorum Queue |
Kafka 的 acks=1 已经足够安全 | 对于金融场景必须 acks=all 且 min.insync.replicas >= 2,防止 Leader 宕机丢数据 |
| RabbitMQ 的 Mirror Queue 性能很好 | Mirror Queue 同步复制到所有节点,写入性能随节点数下降,高吞吐场景应改用 Quorum Queue 或考虑 Kafka |
| Kafka Consumer 自动提交 Offset 即可 | 金融场景应手动提交,且处理逻辑需保证幂等(先处理业务再提交 Offset,或反之但需幂等补偿) |
| 用 Kafka 做 RPC 调用 | Kafka 是异步管道,不适合请求-响应模式。需要同步返回结果时应使用 gRPC/HTTP |
6. 高频问题怎么答?
Q1: Kafka 为什么比 RabbitMQ 吞吐高?
Kafka 的高吞吐源于以下设计:
- 顺序磁盘 I/O:Partition 是顺序追加写(Append-only),磁盘顺序写性能接近内存。RabbitMQ 的消息需要随机写入队列索引,且消费后需要删除标记
- Page Cache 与 Zero Copy:Kafka 大量依赖 OS Page Cache,消费时通过
sendfile()直接从 Page Cache 发送到网卡,不经过用户态 - 批处理:Producer 和 Consumer 都支持批量操作(Batching),摊平网络 RTT
- 无状态 Broker(Relative to Consumer):Broker 不记录 Consumer 消费状态,Offset 由 Consumer 或内部 Topic 管理,Broker 只做简单的文件读取
- 分区并行:Topic 分多个 Partition,每个 Partition 可被独立 Consumer 并行消费
RabbitMQ 的瓶颈在于:
- Exchange 路由决策需要 CPU 计算
- Queue 的 FIFO 语义需要维护复杂的状态(消息状态:Ready / Unacked)
- 镜像队列的同步复制机制严重限制写入吞吐
Q2: RabbitMQ 的 Exchange 类型如何选择?
- Direct:精确匹配 Routing Key。适用于点对点任务分发,如
risk.alert.critical精确路由到critical-queue - Topic:通配符匹配(
#匹配零或多个单词,*匹配一个单词)。适用于多级路由,如risk.region.us.*路由到美国区风控队列 - Fanout:广播到所有绑定 Queue,忽略 Routing Key。适用于告警广播,如一条系统停机通知同时推送到 SMS、Email、Slack 三个队列
- Headers:根据消息头属性匹配,而非 Routing Key。适用于复杂属性过滤,较少使用
- Consistent Hashing:将消息按 Hash 分发到多个 Queue,实现类似 Kafka Partition 的负载均衡(需插件)
Q3: Kafka 的 Rebalance 问题是什么?如何优化?
问题描述: Consumer Group 中任何成员加入、退出或 Topic Partition 数变化时,Group Coordinator 会触发 Rebalance,重新分配 Partition 所有权。期间所有 Consumer 停止消费(Stop-the-world),造成延迟抖动。
优化方案:
- Sticky Assignor:尽量保持原有分配,减少迁移(Kafka 2.4+ 默认)
- Incremental Cooperative Rebalancing(KIP-429):Consumer 逐步放弃和获取 Partition,避免全组停顿。需设置
partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignor - Session Timeout 调优:避免网络抖动导致 Consumer 被误判为离线。设置
session.timeout.ms=45000,heartbeat.interval.ms=15000 - Consumer 优雅退出:在 JVM ShutdownHook 中调用
consumer.wakeup(),主动触发 Rebalance 而非等待 Session Timeout - 静态成员(Static Membership,KIP-345):设置
group.instance.id,Consumer 重启后保留原有 Partition 分配,完全避免 Rebalance
Q4: RabbitMQ 的镜像队列(Mirrored Queue)有什么缺点?Quorum Queue 解决了什么?
镜像队列(Classic Mirrored Queue)的缺点:
- 同步复制瓶颈:Master 节点需要同步等待所有 Slave 节点确认(
ha-mode=all),写入延迟随节点数线性增加 - 脑裂问题:网络分区时可能出现多个节点都认为自己是 Master,导致消息重复或丢失
- 单队列性能上限:Queue 本质是单线程,即使镜像也无法突破单节点的吞吐上限
Quorum Queue(RabbitMQ 3.8+):
- 基于 Raft 共识算法,Leader 选举自动完成,无需外部协调
- 默认写多数派(Majority)即确认,平衡了性能与一致性
- 网络分区时,少数派分区自动变为只读或不可用,避免脑裂
- 缺点:不支持 TTL(消息级)、优先级队列、延迟消息插件(截至 3.12 版本仍有部分限制,需查阅最新文档)
Q5: Kafka 和 RabbitMQ 分别如何实现 Exactly-Once?
Kafka Exactly-Once:
- 幂等 Producer:设置
enable.idempotence=true,Producer 为每条消息分配 PID(Producer ID)和 Sequence Number,Broker 去重。仅保证单 Partition 内 Exactly-Once - 事务 Producer:使用
initTransactions()/beginTransaction()/commitTransaction(),实现跨 Partition 的原子写入。配合 Consumer 的isolation.level=read_committed,只读取已提交事务的消息 - 端到端 Exactly-Once:Kafka Streams 提供
eos.alpha/eos.beta(KIP-447),通过事务 Offset 提交保证"处理结果写入 + Offset 提交"的原子性
RabbitMQ Exactly-Once: RabbitMQ 本身不提供原生 Exactly-Once,需要业务层保证:
- Producer 端:Publisher Confirm 保证消息到达 Exchange/Queue,但无法防止网络重传导致的重复投递
- Consumer 端:Manual ACK 保证消息不丢失,但无法防止 ACK 前 Consumer 崩溃导致的重复消费
- 业务幂等:通过数据库唯一约束(如
INSERT IGNORE)、RedisSETNX、或业务状态机(如订单状态只能由 NEW -> PAID,不能重复 PAID)实现去重
Q6: Kafka 的 Partition 数如何设计?是不是越多越好?
不是越多越好。Partition 数的影响:
- 优点:更多的 Partition 意味着更高的并行度(更多 Consumer 并发)和更高的吞吐上限
- 缺点:
- 每个 Partition 在 Broker 上对应一个目录和文件句柄,过多 Partition 导致文件句柄耗尽和 I/O 碎片
- Rebalance 时间随 Partition 数增加而增加(需要重新分配更多资源)
- Kafka Controller 的元数据管理压力增大
设计原则:
- 初始设置:预期最大 Consumer 并发数 * 2(留有余量)
- 上限:单 Broker 不超过 4000 Partition,单集群不超过 20 万 Partition(Kafka 2.x 经验值,3.x 有所改善)
- 避免频繁调整:增加 Partition 会导致 Key 的分区重新计算(旧数据仍在旧 Partition),除非使用自定义 Partitioner
Q7: RabbitMQ 如何处理消息堆积(Backlog)?
- Lazy Queue:消息直接进入磁盘,不占用内存,适合长队列场景
- TTL + DLX:设置队列 TTL 或消息 TTL,超期未消费的消息自动进入死信队列,避免无限堆积
- Queue Length Limit:设置
x-max-length或x-max-length-bytes,超限后新消息被拒绝或丢弃(需配合 Dead Letter) - 增加 Consumer:横向扩展 Consumer 实例,但受限于 Queue 的 FIFO 单线程特性(一个 Queue 只能被一个 Consumer 充分利用)
- Sharding:使用 Consistent Hash Exchange 将消息分散到多个 Queue,每个 Queue 由独立 Consumer 消费(类似 Kafka Partition)
Q8: 在金融交易系统中,Kafka 和 RabbitMQ 可以共存吗?如何分工?
可以且推荐共存。典型分工:
- Kafka:交易流水持久化(Trade Capture)、行情数据分发(Market Data)、审计日志、批处理 ETL
- RabbitMQ:交易前风控告警(Pre-trade Risk Alert)、订单状态通知、内部工单流转、延迟任务(如结算提醒)
集成模式:
- 使用 Kafka Connect 的 RabbitMQ Sink Connector 将 Kafka Topic 数据同步到 RabbitMQ Queue(或反之)
- 在应用层桥接:一个服务同时作为 Kafka Consumer 和 RabbitMQ Producer,实现跨系统的任务触发
Q9: Kafka 的 ISR(In-Sync Replicas)机制是什么?为什么重要?
ISR 是与 Leader 保持同步的 Replica 集合。Leader 维护一个 ISR 列表,只有 ISR 内的 Follower 才有资格竞选新 Leader。
关键参数:
replica.lag.time.max.ms:Follower 超过此时间未同步,则被踢出 ISRmin.insync.replicas:Producer 设置acks=all时,必须有多少个 ISR 确认才返回成功
重要性:
- 防止数据丢失:如果 Leader 宕机,只有 ISR 中的 Follower 能晋升为 Leader,保证已确认的消息不丢失
- 吞吐与可用性权衡:ISR 越小,写入确认越快但可用性越低;ISR 越大,可用性越高但写入延迟增加
- Unclean Leader Election:配置
unclean.leader.election.enable=false,禁止非 ISR 节点成为 Leader,牺牲可用性保证数据一致性(金融场景推荐)
Q10: RabbitMQ 的 Channel 和 Connection 有什么区别?如何正确使用?
- Connection:TCP 长连接,建立和销毁成本高
- Channel:AMQP 的逻辑连接,复用同一个 TCP Connection,轻量(创建/销毁成本低)
最佳实践:
- 一个应用进程维持 1-2 个 Connection(Producer 一个,Consumer 一个)
- 每个线程/每次发布使用独立的 Channel,避免线程竞争
- Consumer 的 Channel 不应同时用于发布(避免死锁:Consumer 处理消息时发布新消息,若触发 Flow Control 会互相阻塞)
- 使用 Channel Pool(如 Spring AMQP 的
CachingConnectionFactory)管理 Channel 生命周期,防止泄漏
一句话结论是什么?
Kafka 与 RocketMQ 同属 Log-based(基于日志) 分布式消息中间件,都擅长高吞吐、持久化与水平扩展,但设计目标不同:Kafka 是全球流数据的事实标准,强项在于多 Consumer Group 独立消费、海量数据可重放、与 Flink/Spark/Kafka Connect 的深度集成;RocketMQ 由阿里巴巴在电商核心链路中打磨,强项在于 CommitLog 统一写、原生 事务消息 / 定时延迟 / Tag·SQL92 过滤、毫秒级业务投递。选型核心在于:需要"建数据管道、做多路订阅与流计算"时用 Kafka,需要"保障交易一致性、延迟调度与业务消息语义"时用 RocketMQ。二者在金融/电商系统中常共存分工,而非互斥替代。
1. 这是什么?概念怎么定义
1.1 Kafka:分布式日志存储与流处理平台
Kafka 最初由 LinkedIn 设计(2010 年开源),其核心哲学是将消息视为不可变的日志(Immutable Log)。Producer 向 Topic 追加记录,Consumer 从 Topic 按 Offset 顺序读取。消息在消费后不会立即删除,而是根据保留策略(时间或大小)过期后才清理。
核心概念:
- Topic / Partition:Topic 是逻辑消息流,Partition 是物理分片,每个 Partition 是一个有序的、不可变的记录序列
- Offset:消费者在 Partition 中的位置标记,由 Consumer 自行管理或提交到
__consumer_offsets - Consumer Group:组内消费者共同消费一个 Topic 的所有 Partition,实现水平扩展与负载均衡
- ISR(In-Sync Replicas):与 Leader 保持同步的副本集合,决定
acks=all时的写入确认范围 - Broker:Kafka 服务节点,负责存储和转发消息;元数据由 ZooKeeper(旧版)或 KRaft(Kafka 3.0+)管理
1.2 RocketMQ:金融级分布式消息中间件
RocketMQ 源于阿里巴巴内部的 MetaQ(2011 年),2012 年捐赠 Apache 基金会。其核心哲学是在日志模型之上提供完整的业务消息语义——不仅传输数据,还要支撑分布式事务、定时投递、消息过滤等企业级需求。
核心概念:
- Topic / MessageQueue(MQ):Topic 是逻辑分类;每个 Topic 在 Broker 上被划分为多个 MessageQueue(类似 Kafka 的 Partition,但存储架构不同)
- CommitLog:Broker 上所有 Topic 共享的顺序追加写日志,是消息的唯一物理写入点
- ConsumeQueue:每个 MessageQueue 对应的消费索引文件,记录消息在 CommitLog 中的物理偏移,加速消费定位
- Offset:消费者在 MessageQueue 中的消费进度,由 Broker 或客户端管理
- NameServer:轻量级路由注册中心,Broker 与 Client 均向其注册/拉取路由,无选主、无持久化状态
- Producer Group / Consumer Group:生产者/消费者逻辑分组,用于事务消息、负载均衡与故障转移
- Tag / Keys:Tag 用于消息过滤(如
CRITICAL/WARNING);Keys 用于消息索引与顺序路由(同 Key 进同一 MQ)
RocketMQ 不是 RabbitMQ 式的 Exchange 路由模型,而是 Topic + Tag + Filter 的发布订阅语义,更接近 Kafka 的 Topic 模型,但内置了更多 MQ 特性。
1.3 类比说明
想象一个大型金融机构的内部信息流:
- Kafka 像中央档案馆:所有交易流水按时间顺序装订到不同卷宗(Partition)中。审计员、风控分析师、数据仓库工程师(不同 Consumer Group)可以各自从任意卷宗、任意页码(Offset)开始阅读,互不影响。卷宗保留期满后统一销毁,而非"借走即删"。档案馆的价值在于存档、检索、多读者并行。
- RocketMQ 像带调度中心的运单系统:所有运单(消息)先写入中央运单库(CommitLog),再按目的地拆分到各分拣队列(ConsumeQueue)。调度中心(NameServer)告诉发货方和收货方去哪取货。系统支持预约送达(延迟消息)、两阶段提交运单(事务消息)、按紧急程度分拣(Tag 过滤)。运单被签收后标记完成,失败则自动重投。
1.4 为什么需要它们
在分布式系统中,服务间直接同步调用存在以下问题:
- 耦合度高:调用方与被调用方强绑定,任何一方故障都会级联影响
- 扩展困难:峰值流量直接冲击下游,缺乏缓冲
- 可靠性差:网络抖动或进程重启导致请求丢失
- 异构系统集成:不同语言、不同协议的服务难以直接通信
Kafka 与 RocketMQ 都通过异步解耦和流量削峰解决上述问题,但侧重点不同:
- Kafka 更侧重于数据管道(Data Pipeline)、事件溯源(Event Sourcing)和流式计算,解决海量数据的可靠传输、持久化与多路订阅
- RocketMQ 更侧重于业务消息(Business Messaging)和分布式事务协同,解决交易链路一致性、延迟调度、顺序消费与毫秒级投递
与系列文档的关系:Kafka 架构细节见 d1-kafka-architecture-done-1.md;RocketMQ 事务消息与可靠性见 d6-message-reliability.md 第 4.1 节。
2. 核心原理是什么?
2.1 架构哲学:Pull Model、元数据与集群角色
Kafka 与 RocketMQ 在消费模式上表面相似,底层实现有重要差异。
Kafka:纯 Pull Model
- Consumer 主动向 Broker 发起
fetch请求,携带期望读取的 Offset 和最大字节数 - Consumer 完全掌控消费节奏:可以批量拉取、按需拉取、甚至暂停消费(Backpressure 自然实现)
- Broker 相对 Consumer 消费进度是"无状态"的,Offset 存储在内部 Topic
__consumer_offsets或外部系统 - 元数据:ZooKeeper(2.x 及以前)或 KRaft(3.0+,基于 Raft 的内置 Controller)
- 优势:Consumer 可根据自身处理能力调节流量,Broker 实现简单,适合超高吞吐
- 劣势:低流量场景下可能产生空轮询,需配置
fetch.min.bytes和fetch.max.wait.ms平衡延迟与吞吐
RocketMQ:Pull 为主,Push 为辅
- Pull 模式(推荐):Consumer 主动拉取,通过长轮询(Long Polling,
pullInterval+brokerSuspendMaxTimeMillis)降低空轮询开销 - Push 模式:Broker 主动推送,但底层仍是 长轮询 Pull——Broker 在本地有消息时立即返回,无消息时挂起请求直至超时或新消息到达
- 元数据:NameServer 集群(通常 2~3 节点),无选主、无状态;Broker 启动时向 NameServer 注册 Topic 路由,Client 定时拉取路由缓存
- 优势:Push 模式对业务开发者更友好(回调式消费);NameServer 轻量,扩缩容简单
- 劣势:Push 模式下 Consumer 处理能力不足时,若未正确配置消费线程与
pullThresholdForQueue,可能导致消费堆积
元数据对比
| 维度 | Kafka | RocketMQ |
|---|---|---|
| 协调组件 | ZooKeeper / KRaft Controller | NameServer(无状态) |
| 路由信息 | Topic 元数据在 Controller/ZK | Topic 路由在 NameServer,Broker 上报 |
| 选主 | Controller 选举(KRaft) | Broker Master 选举(Dledger / 主从) |
| 扩缩容 | 增加 Broker + 迁移 Partition | 增加 Broker + 队列自动分配 |
2.2 存储模型:Partition Segment vs CommitLog + ConsumeQueue
这是 Kafka 与 RocketMQ 最根本的架构差异。
Kafka 存储模型:每 Partition 独立日志
- 每个 Partition 对应文件系统上的一个目录(如
trade-events-0/) - 每个目录中包含多个 Segment 文件(默认 1GB),文件名即该 Segment 起始 Offset
- 每个
.log配套.index(稀疏索引)和.timeindex(时间戳索引) - 读取流程:根据目标 Offset 二分定位 Segment → 稀疏索引定位 → 顺序读
.log - Zero Copy:使用
sendfile(),数据从 Page Cache 直接发送到网卡 - 特点:Partition 之间完全独立,Topic 数量多时目录与文件句柄增多;单 Partition 内顺序写性能极高
RocketMQ 存储模型:统一 CommitLog + 分散 ConsumeQueue
- 所有 Topic 的消息顺序写入同一个 CommitLog 文件(按 Broker 节点)
- 写入 CommitLog 后,异步构建各 Topic 的 ConsumeQueue 索引(固定 20 字节/条:CommitLog Offset + Size + Tag HashCode)
- 消费时:先读 ConsumeQueue 获得 CommitLog 物理偏移 → 再读 CommitLog 取完整消息体
- 特点:
- 写放大低:无论多少 Topic,磁盘写入都是顺序追加,适合 Topic 数量极多的电商场景
- 读路径多一跳:消费需两次磁盘访问(ConsumeQueue + CommitLog),但通过 Page Cache 通常可命中
- 刷盘策略:
flushDiskType=ASYNC_FLUSH(异步,默认)或SYNC_FLUSH(同步,金融场景)
| 对比维度 | Kafka | RocketMQ |
|---|---|---|
| 写入模型 | 每 Partition 独立顺序写 | 全 Broker 共享 CommitLog 顺序写 |
| 索引 | Partition 内稀疏 Offset 索引 | 每 MQ 独立 ConsumeQueue 索引 |
| Topic 多时 | 文件句柄与目录增多 | CommitLog 写路径不变,磁盘友好 |
| 随机读 | 按 Offset 稀疏索引,高效 | 先 CQ 后 CommitLog,两次 IO |
| 磁盘清理 | 按 Partition Segment 过期删除 | CommitLog 与 CQ 联动清理 |
2.3 消费模型:Consumer Group 与队列负载均衡
Kafka Consumer Group
- 一个 Consumer Group 内的所有 Consumer 共同消费一个 Topic 的所有 Partition
- Partition 与 Consumer 是 1:N 映射(一个 Partition 只能被一个 Consumer 消费,一个 Consumer 可消费多个 Partition)
- Rebalance:Consumer 加入/退出或 Partition 数变化时,Coordinator 重新分配 Partition 所有权;期间整个 Group 可能暂停消费
- 广播:多个 Consumer Group 各自独立消费同一 Topic(天然支持多订阅)
- Offset 管理:自动提交(
enable.auto.commit)或手动提交(commitSync/commitAsync)
RocketMQ Consumer Group
- 组内 Consumer 分摊 Topic 下所有 MessageQueue,每条消息只被组内一个 Consumer 消费
- 负载均衡策略(
allocateMessageQueueStrategy):- 平均分配(默认)、轮询、一致性 Hash、机房亲和(同机房优先)
- Rebalance:Consumer 上下线时触发队列重新分配,消费进度保存在 Broker(
broadcast模式除外) - 广播消费(Broadcasting):组内每个 Consumer 都收到全量消息(配置
MessageModel.BROADCASTING),类似 Kafka 多 Group 但语义在组内 - 顺序消费:
ConsumeMode.ORDERLY保证同一 MessageQueue 内 FIFO;CONCURRENTLY为并发消费
| 对比维度 | Kafka | RocketMQ |
|---|---|---|
| 分片单元 | Partition | MessageQueue |
| 顺序保证 | 单 Partition 内有序 | 单 MQ + ORDERLY 模式 |
| 多订阅 | 多 Consumer Group | 多 Consumer Group 或 Broadcasting |
| Rebalance | Group Coordinator 触发,影响大 | Client 端 Rebalance,相对轻量 |
| 消费进度 | __consumer_offsets | Broker 端 ConsumerOffset |
2.4 一致性保证与 Delivery Semantics
Kafka
- At Most Once:Consumer 先提交 Offset,再处理消息
- At Least Once:先处理消息,再提交 Offset(金融场景主流)
- Exactly Once:
- 幂等 Producer:
enable.idempotence=true(PID + Sequence Number,单 Partition 内去重) - 事务 API:
initTransactions/beginTransaction/commitTransaction,跨 Partition 原子写入 - 端到端:Kafka Streams 的 EOS(事务 Offset 提交 + 输出原子性)
- Consumer 配合
isolation.level=read_committed
- 幂等 Producer:
RocketMQ
- At Most Once:单向发送(
sendOneway),不等待 Broker 确认 - At Least Once:同步/异步发送 + Broker 刷盘确认 + Consumer 返回
CONSUME_SUCCESS前不推进 Offset - Exactly Once:
- 事务消息(Half Message):Producer 发送半消息 → 执行本地事务 → 提交/回滚半消息;Broker 回查未知状态
- 消费端仍需业务幂等(At Least Once + 去重表)
- Kafka 式跨 Topic 事务:RocketMQ 5.x 支持更完善的事务消息,但主流仍是 Half Message 模式
| 语义 | Kafka 实现 | RocketMQ 实现 |
|---|---|---|
| At Most Once | 先 commit offset | sendOneway + 自动 ack |
| At Least Once | 手动 commit + 幂等 | 同步发送 + CONSUME_SUCCESS |
| 跨服务事务 | Kafka Transaction API | Half Message + 回查 |
| 流处理 EOS | Kafka Streams | 需 Flink Connector 或业务层 |
3. 怎么用?关键代码与配置
3.1 Kafka 生产级配置与代码
Maven 依赖
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
<version>3.1.0</version>
</dependency>Producer 配置:交易流水实时上报
spring:
kafka:
bootstrap-servers: kafka-1:9092,kafka-2:9092,kafka-3:9092
producer:
key-serializer: org.apache.kafka.common.serialization.StringSerializer
value-serializer: org.apache.kafka.common.serialization.StringSerializer
acks: all
retries: 3
retry.backoff.ms: 1000
enable.idempotence: true
max.in.flight.requests.per.connection: 5
compression.type: lz4
batch.size: 65536
linger.ms: 10@Component
public class TradeEventProducer {
private final KafkaTemplate<String, String> kafkaTemplate;
private static final String TOPIC = "trade.events.v1";
public TradeEventProducer(KafkaTemplate<String, String> kafkaTemplate) {
this.kafkaTemplate = kafkaTemplate;
}
public void sendTradeEvent(String userId, TradeEvent event) {
String key = userId; // 按用户 ID 分区,保证同一用户交易顺序
String payload = JsonUtils.toJson(event);
ProducerRecord<String, String> record = new ProducerRecord<>(TOPIC, key, payload);
record.headers().add("traceId", MDC.get("traceId").getBytes());
record.headers().add("eventTime", String.valueOf(System.currentTimeMillis()).getBytes());
kafkaTemplate.send(record).whenComplete((result, ex) -> {
if (ex != null) {
log.error("Failed to send trade event for userId={}", userId, ex);
fallbackToLocalFile(event);
return;
}
RecordMetadata metadata = result.getRecordMetadata();
log.info("Trade event sent partition={} offset={} userId={}",
metadata.partition(), metadata.offset(), userId);
});
}
private void fallbackToLocalFile(TradeEvent event) {
// 本地持久化,等待后续重放
}
}Consumer 配置:风控特征实时计算
spring:
kafka:
consumer:
group-id: risk-feature-calculator
auto-offset-reset: earliest
enable-auto-commit: false
max-poll-records: 500
fetch.min.bytes: 1048576
fetch.max.wait.ms: 500
isolation.level: read_committed@Component
public class RiskFeatureConsumer {
private final RiskFeatureCalculator calculator;
private final KafkaTemplate<String, String> dlqTemplate;
private static final String TOPIC = "trade.events.v1";
private static final String DLQ_TOPIC = "trade.events.v1.dlq";
@KafkaListener(topics = TOPIC, containerFactory = "kafkaListenerContainerFactory")
public void onTradeEvent(List<ConsumerRecord<String, String>> records,
Acknowledgment ack) {
List<TradeEvent> events = new ArrayList<>();
for (ConsumerRecord<String, String> record : records) {
try {
TradeEvent event = JsonUtils.fromJson(record.value(), TradeEvent.class);
if (!isValid(event)) {
log.warn("Invalid trade event, skipping offset={}", record.offset());
continue;
}
events.add(event);
} catch (Exception e) {
sendToDLQ(record, e);
}
}
try {
calculator.calculateBatch(events);
ack.acknowledge();
} catch (Exception e) {
log.error("Feature calculation failed, not committing offset", e);
throw e;
}
}
private void sendToDLQ(ConsumerRecord<String, String> record, Exception e) {
log.error("Sending poison pill to DLQ, offset={}", record.offset(), e);
dlqTemplate.send(DLQ_TOPIC, record.key(), record.value());
}
private boolean isValid(TradeEvent event) {
return event != null && event.getAmount() != null && event.getTimestamp() != null;
}
}Kafka 延迟消息(自建方案)
Kafka 原生不支持延迟消息,通常通过独立 Topic + 消费者判断执行时间实现:
@Component
public class DelayedRiskCheckProducer {
private final KafkaTemplate<String, String> kafkaTemplate;
private static final String DELAY_TOPIC = "risk.delayed.check";
public void scheduleDelayedCheck(String orderId, long delayMs) {
long executeTime = System.currentTimeMillis() + delayMs;
DelayedTask task = new DelayedTask(orderId, executeTime);
kafkaTemplate.send(DELAY_TOPIC, orderId, JsonUtils.toJson(task));
}
}3.2 RocketMQ 生产级配置与代码
Maven 依赖
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-spring-boot-starter</artifactId>
<version>2.3.0</version>
</dependency>配置:风控与交易消息
rocketmq:
name-server: namesrv-1:9876;namesrv-2:9876
producer:
group: risk-producer-group
send-message-timeout: 3000
retry-times-when-send-failed: 3
retry-times-when-send-async-failed: 3
compress-message-body-threshold: 4096
max-message-size: 4194304
consumer:
pull-threshold-for-queue: 1000Producer:交易风控事件(异步发送 + Keys 保序)
@Slf4j
@Service
@RequiredArgsConstructor
public class TradeRiskEventProducer {
private final RocketMQTemplate rocketMQTemplate;
private static final String TOPIC = "trade-risk-events";
public void sendRiskEvent(String orderId, RiskEvent event) {
Message<RiskEvent> message = MessageBuilder.withPayload(event)
.setHeader(RocketMQHeaders.KEYS, orderId) // 同订单进同一 MQ,保证顺序
.setHeader("traceId", MDC.get("traceId"))
.build();
rocketMQTemplate.asyncSend(
TOPIC + ":CRITICAL", // Topic:Tag 格式
message,
new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
log.info("Risk event sent msgId={} queueId={}",
sendResult.getMsgId(), sendResult.getMessageQueue().getQueueId());
}
@Override
public void onException(Throwable e) {
log.error("Failed to send risk event orderId={}", orderId, e);
persistToOutbox(event);
}
},
3000,
2 // delayLevel,见延迟消息章节
);
}
private void persistToOutbox(RiskEvent event) {
// Outbox 兜底
}
}事务消息:下单与风控事件一致性(Half Message)
@Service
@RequiredArgsConstructor
public class OrderTransactionProducer {
private final RocketMQTemplate rocketMQTemplate;
private final OrderService orderService;
private static final String TX_TOPIC = "order-tx-events";
public void createOrderWithRiskEvent(CreateOrderRequest request) {
Message<CreateOrderRequest> message = MessageBuilder
.withPayload(request)
.setHeader(RocketMQHeaders.KEYS, request.getOrderId())
.build();
rocketMQTemplate.sendMessageInTransaction(
TX_TOPIC,
message,
request // arg 传给 LocalTransactionExecutor
);
}
}
@RocketMQTransactionListener
@RequiredArgsConstructor
public class OrderTransactionListener implements RocketMQLocalTransactionListener {
private final OrderService orderService;
@Override
public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
CreateOrderRequest request = (CreateOrderRequest) arg;
try {
orderService.createOrder(request); // 本地事务:写订单库
return RocketMQLocalTransactionState.COMMIT;
} catch (Exception e) {
log.error("Local transaction failed orderId={}", request.getOrderId(), e);
return RocketMQLocalTransactionState.ROLLBACK;
}
}
@Override
public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
String orderId = msg.getKeys();
// Broker 回查:本地事务状态未知时调用
if (orderService.exists(orderId)) {
return RocketMQLocalTransactionState.COMMIT;
}
return RocketMQLocalTransactionState.ROLLBACK;
}
}延迟消息:2 小时后二次风控复核
@Service
@RequiredArgsConstructor
public class DelayedRiskReviewProducer {
private final RocketMQTemplate rocketMQTemplate;
private static final String TOPIC = "risk-delayed-review";
/**
* RocketMQ 内置 18 级延迟:1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
* delayLevel=18 表示延迟 2 小时
*/
public void scheduleReview(String orderId, RiskReviewTask task) {
Message<RiskReviewTask> message = MessageBuilder.withPayload(task)
.setHeader(RocketMQHeaders.KEYS, orderId)
.build();
rocketMQTemplate.syncSend(TOPIC, message, 3000, 18);
}
}RocketMQ 5.x:支持任意精度的定时消息(
deliveryTimestamp),不再局限于 18 级固定延迟。生产环境需确认 Broker 版本与timerWheel配置。
Consumer:顺序消费 + 死信
@Slf4j
@Component
@RocketMQMessageListener(
topic = "trade-risk-events",
consumerGroup = "risk-event-consumer",
selectorExpression = "CRITICAL || WARNING", // Tag 过滤
consumeMode = ConsumeMode.ORDERLY, // 单 MQ 内顺序消费
messageModel = MessageModel.CLUSTERING,
maxReconsumeTimes = 3 // 超过后进 %DLQ%risk-event-consumer
)
@RequiredArgsConstructor
public class RiskEventConsumer implements RocketMQListener<RiskEvent> {
private final RiskAlertProcessor processor;
private final IdempotencyService idempotencyService;
@Override
public void onMessage(RiskEvent event) {
if (idempotencyService.isProcessed(event.getEventId())) {
return;
}
try {
processor.process(event);
idempotencyService.markProcessed(event.getEventId());
} catch (BusinessException e) {
log.warn("Business reject eventId={}", event.getEventId(), e);
// 业务拒绝,不重试
} catch (Exception e) {
log.error("Process failed, will reconsume eventId={}", event.getEventId(), e);
throw new RuntimeException(e); // 触发 RECONSUME_LATER
}
}
}3.3 消息可靠性对比配置表
| 维度 | Kafka | RocketMQ |
|---|---|---|
| Producer 可靠性 | acks=all, enable.idempotence=true, 事务 API | 同步发送 + SYNC_FLUSH + 主从同步复制 |
| Consumer 可靠性 | 手动 commitSync / commitAsync | 返回 CONSUME_SUCCESS 才推进 Offset |
| 消息持久化 | 默认持久化到 Segment 文件 | CommitLog 持久化 + flushDiskType |
| 顺序保证 | 同 Key 同 Partition | 同 Key 同 MessageQueue + ORDERLY |
| 事务消息 | Kafka Transaction(流处理场景) | Half Message + 回查(业务事务场景) |
| 延迟消息 | 自建时间轮 Topic | 18 级 delayLevel / 5.x 定时消息 |
| 消息过滤 | Header + 下游过滤 | Tag、SQL92 Filter |
| 死信处理 | 手动发送到 DLQ Topic | 自动 %DLQ%{consumerGroup} |
| 重复处理 | 业务幂等 + 幂等 Producer | 业务幂等 + uniq_msg_id |
4. 业界怎么做?
4.1 LinkedIn:Kafka 的诞生与万亿级消息实践
LinkedIn 是 Kafka 的诞生地(2010 年由 Jay Kreps、Neha Narkhede 和 Jun Rao 开发)。在 LinkedIn,Kafka 每天处理超过 7 万亿条消息,峰值吞吐超过 1000 万条/秒。
使用场景:
- 用户行为事件流:所有前端埋点、后端服务事件统一接入 Kafka,供实时推荐、广告计费、安全风控使用
- 数据库变更捕获(CDC):通过 Kafka Connect 将 MySQL、Oracle 的 Binlog 实时同步到数据仓库
- 日志聚合:全站服务日志统一收集到 Kafka,下游对接 Hadoop、Spark 做离线分析
踩过的坑:
- Rebalance 风暴:Consumer Group 扩容时全组停顿数秒。解决方案:Sticky Assignor、Incremental Cooperative Rebalancing(KIP-429,Kafka 2.4+)、Static Membership(
group.instance.id) - ZooKeeper 瓶颈:大规模集群下 ZK 成为瓶颈。LinkedIn 主导 KRaft 模式(Kafka 3.0+ 去除 ZooKeeper)
- 磁盘 I/O 抖动:Log Compaction 时 I/O 飙升。解决方案:错峰调度 + SSD
4.2 阿里巴巴:RocketMQ 在双 11 核心交易链路的实践
阿里巴巴内部消息系统经历了 Notify → MetaQ → RocketMQ 的演进。需要区分:RocketMQ 承载核心交易业务消息(下单、支付、库存、履约),而 Kafka 在阿里同时用于日志采集、大数据管道、风控特征等流式场景(见 d1-kafka-architecture-done-1.md 4.2 节),二者分工而非替代。
使用场景:
- 下单-扣库存-发消息:通过事务消息保证本地订单创建与下游消息发送的一致性
- 支付回调:支付成功消息通过 Tag 路由到订单、积分、风控等多个 Consumer Group
- 延迟关单:下单 30 分钟未支付,通过 delayLevel 自动触发关单
- 全链路追踪:Message Trace 记录消息从生产到消费的每个节点
踩过的坑(与 d6-message-reliability.md 4.1 节一致):
- 2015 年双 11 磁盘故障:部分消息丢失,后续核心链路引入
flushDiskType=SYNC_FLUSH,牺牲写入性能换取可靠性 - 消费堆积导致 Rebalance 雪崩:消费者处理慢 → 堆积 → Rebalance → 进一步降速。解决方案:消费线程池隔离、慢消费告警、
pullThresholdForQueue限流 - Broker 单点:早期主从切换不够自动化,后引入 Dledger(基于 Raft 的多副本自动选主)
4.3 混合架构:Kafka + RocketMQ 分工(以金融机构为例)
大型金融机构常同时使用 Kafka 与 RocketMQ,按数据特性分工:
| 链路 | 选型 | 原因 |
|---|---|---|
| 全量交易流水、行情 Tick | Kafka | 超高吞吐、长期保留、多 Consumer Group(风控/审计/数仓) |
| 下单-支付-履约事务消息 | RocketMQ | 原生事务消息、Half Message 回查 |
| 延迟复核、定时关单 | RocketMQ | 原生 delayLevel / 5.x 定时消息 |
| 实时风控特征(Flink) | Kafka | Flink 原生 Kafka Source,生态成熟 |
| 风控告警推送(SMS/Push) | RocketMQ | Tag 过滤、毫秒级投递 |
集成模式:
- 应用层桥接:风控 Flink 作业消费 Kafka 流水,命中规则后写入 RocketMQ 告警 Topic
- CDC 双写:Canal/Debezium 捕获数据库变更 → Kafka(数仓)+ RocketMQ(业务通知)
- 避免:同一业务事件在 Kafka 与 RocketMQ 之间无幂等地来回转发,应明确"单一事实来源"
5. 业务场景怎么对照?
5.1 风控/Risk 场景如何应用
Kafka 在风控中的典型应用
| 场景 | 说明 | 关键配置 |
|---|---|---|
| 海量交易流水采集 | 所有成交回报统一入 Kafka,供实时特征与离线审计 | acks=all, compression.type=lz4, retention.ms=2592000000 |
| 实时风控特征计算 | Flink 读取 Kafka,计算滚动窗口交易额、频次 | isolation.level=read_committed, max.poll.records=1000 |
| 审计日志持久化 | 风控决策不可篡改,Kafka 不可变日志天然适合 | cleanup.policy=compact + delete |
| 跨机房数据复制 | MirrorMaker 2 异步复制到灾备机房 | replication.factor=3, min.insync.replicas=2 |
RocketMQ 在风控中的典型应用
| 场景 | 说明 | 关键配置 |
|---|---|---|
| 交易事务消息 | 下单与发风控检查消息的一致性 | 事务消息 + checkLocalTransaction 回查 |
| 延迟复核任务 | 高风险交易 2 小时后二次复核 | delayLevel=18(2h)或 5.x 定时消息 |
| 告警分级推送 | Tag=CRITICAL/WARNING 分流到不同 Consumer | selectorExpression, 多 Consumer Group |
| 单笔订单事件链顺序 | 创建→支付→发货状态机顺序消费 | KEYS=orderId, ConsumeMode.ORDERLY |
| 风控拦截指令下发 | 毫秒级推送冻结指令到交易网关 | 同步发送 + 主从同步 |
5.2 选型决策树
When to use Kafka:
- 事件溯源与审计日志,需要按 Offset/时间重放
- 超高吞吐(> 10 万条/秒)的流数据处理
- 消息需被多个独立 Consumer Group 重复消费
- 与 Flink、Spark Streaming、ksqlDB、Kafka Connect 深度集成
- 使用 AWS MSK、Confluent Cloud 等托管服务
When to use RocketMQ:
- 分布式事务消息(下单-发消息一致性)
- 原生延迟/定时消息(关单、复核、结算提醒)
- Tag/SQL92 消息过滤,减少 Consumer 无效拉取
- 同业务 Key 强顺序 + 毫秒级投递
- 国内金融/电商场景,社区与案例丰富
When NOT to use Kafka:
- 强依赖原生事务消息 + 回查机制(需自建 Outbox,不如 RocketMQ 开箱即用)
- 仅需固定 18 级延迟而非任意时间调度(RocketMQ 4.x 更省事;5.x 定时消息两者均可)
- 团队无流处理需求,仅需业务 MQ 语义
When NOT to use RocketMQ:
- 重度依赖 Kafka 生态(Connect、Streams、Schema Registry)
- 海外部署且需成熟托管产品(MSK / Confluent 生态远超 RocketMQ 云服务)
- 超大规模 Topic(数千+)且以 Log Compaction 为主的数据保留模型
5.3 常见误区 vs 正确做法
| 误区 | 正确做法 |
|---|---|
| RocketMQ 是 Kafka 的国产替代品,API 可互换 | 存储模型、事务语义、消费 API 均不同,需按场景重新设计,不能 drop-in 替换 |
| RocketMQ Push 消费比 Kafka Pull 更快 | Push 底层是长轮询 Pull,性能差异主要来自存储架构与批处理配置,而非 Push/Pull 本身 |
| 事务消息可以保证端到端 Exactly-Once | Half Message 只保证生产端与本地事务一致;消费端仍需幂等表或业务状态机 |
| Kafka 不能做延迟消息 | 可以,但需自建时间轮 Topic 或调度服务;RocketMQ 4.x 有 18 级固定延迟,5.x 支持任意时间 |
acks=all 与 SYNC_FLUSH 等价 | Kafka 的 acks 是副本同步确认;RocketMQ 的 SYNC_FLUSH 是刷盘策略,需同时配置主从同步 |
| Consumer Group Rebalance 只影响 Kafka | RocketMQ 也有 Rebalance,消费慢或频繁上下线同样会触发队列重分配 |
| 阿里只用 RocketMQ 不用 Kafka | 阿里核心交易用 RocketMQ,日志/大数据/部分风控流处理用 Kafka,混合架构 |
| 用 Kafka 做 RPC 请求-响应 | 两者都是异步管道,同步调用应使用 gRPC/HTTP;RocketMQ 有 Request-Reply 但不替代 RPC |
| 消息过滤在 Broker 完成就不丢消息 | Tag 过滤只减少 Consumer 拉取量;可靠性仍取决于 acks/刷盘/幂等 |
| 只部署单节点 RocketMQ/Kafka 即可上生产 | 生产至少 3 Broker + 多副本,金融场景 min.insync.replicas>=2 或主从同步 |
6. 高频问题怎么答?
Q1: Kafka 和 RocketMQ 架构上最根本的区别是什么?
存储架构是根本差异:
- Kafka:每个 Partition 独立日志文件(Segment + Index),写入与读取都在 Partition 维度完成
- RocketMQ:所有 Topic 共享 CommitLog 顺序写,再通过 ConsumeQueue 索引分发到各 MessageQueue
这导致:
- Topic 数量极多时,RocketMQ 写路径更统一,磁盘顺序写效率更稳定
- Kafka 单 Partition 读取只需一次 IO + Zero Copy,随机按 Offset 定位更高效
- 两者都基于磁盘顺序写,但 Kafka 是"多分片并行日志",RocketMQ 是"单日志 + 多索引"
Q2: 为什么阿里要自研 RocketMQ 而不是直接用 Kafka?
历史背景(2010~2012 年):
- Kafka 当时不成熟:0.7/0.8 版本尚无幂等生产者、事务 API,延迟消息、消息过滤需自建
- 电商业务语义:双 11 需要事务消息(下单-库存-发消息)、18 级延迟关单、Tag 过滤,MetaQ/RocketMQ 原生支持
- 存储优化:海量 SKU/订单 Topic,CommitLog 统一写比每 Topic 独立 Partition 目录更省磁盘 I/O
- 运维习惯:NameServer 无状态,比当时 Kafka 依赖 ZooKeeper 更轻
现状:阿里同时使用 Kafka(日志/大数据/流计算)与 RocketMQ(核心交易),并非二选一。
Q3: RocketMQ 事务消息与 Kafka 事务 API 有何不同?
| 维度 | Kafka Transaction | RocketMQ 事务消息 |
|---|---|---|
| 机制 | PID + Sequence + Transaction Coordinator | Half Message + 本地事务 + 回查 |
| 场景 | 流处理 EOS、跨 Partition 原子写入 | 业务库写入 + 发消息一致性 |
| 回查 | 无,依赖事务超时与 read_committed | Broker 主动 checkLocalTransaction |
| 典型用法 | Kafka Streams consume-transform-produce | 下单成功才 COMMIT 半消息 |
RocketMQ 的 Half Message 本质是 Outbox Pattern 的中间件实现(见 d6);Kafka 事务更适合 流处理管道内 的原子性。
Q4: 两者如何保证消息顺序?
Kafka:
- 生产端:相同 Key 的消息路由到同一 Partition(
DefaultPartitioner对 Key 做 Hash) - 消费端:单 Partition 内严格有序;多 Partition 之间无全局顺序
RocketMQ:
- 生产端:相同
KEYS(或 ShardingKey)路由到同一 MessageQueue - 消费端:
ConsumeMode.ORDERLY对单 MQ 加锁顺序消费;CONCURRENTLY不保证顺序
注意:顺序消费会降低并行度。金融场景通常按 orderId 分区,而非全局顺序。
Q5: Rebalance 问题两边分别怎么优化?
Kafka:
partition.assignment.strategy=CooperativeStickyAssignor(增量协作 Rebalance)- Static Membership:
group.instance.id,重启不触发 Rebalance - 增大
session.timeout.ms,避免网络抖动误判离线 - 控制 Partition 总数,减少 Rebalance 分配开销
RocketMQ:
- 避免 Consumer 频繁重启;使用优雅下线
- 消费逻辑与 Rebalance 解耦,避免在
MessageListener中执行耗时操作 - 监控
consumer lag,堆积时优先扩容 Consumer 而非盲目重启 - 5.x 改进了 Pop 消费模式,减少传统 Rebalance 影响(需查阅对应版本文档)
Q6: RocketMQ NameServer 挂了会怎样?
NameServer 是无状态的路由注册中心:
- 已运行的 Producer/Consumer:本地缓存 Topic 路由,短期内可继续收发消息
- 新启动的 Client:无法获取路由,无法发送/消费
- Broker:无法注册新 Topic 路由,但不影响已注册 Topic 的读写
最佳实践:部署至少 2 个 NameServer 节点,Client 配置多个地址(namesrvAddr=host1:9876;host2:9876)。NameServer 之间不通信,各自独立,Client 轮询连接。
Q7: 延迟消息怎么实现?各有什么限制?
Kafka:
- 无原生支持。常见方案:独立 delay Topic + Consumer 判断
executeTime后重新投递;或使用时间轮调度服务(如 Redis ZSet + 定时任务) - 优点:灵活,任意延迟精度
- 缺点:需自建,消费端可能空转,堆积时精度下降
RocketMQ 4.x:
- 18 级固定延迟(1s ~ 2h),通过
delayLevel参数指定 - 实现:Broker 内部
ScheduleMessageService定时扫描,到期后写入目标 Topic - 限制:无法精确到任意毫秒;超过 2h 需多次投递或升级 5.x
RocketMQ 5.x:
- 支持
deliveryTimestamp任意时间定时消息 - 需 Broker 开启
timerWheel相关配置
Q8: 金融场景 acks=all 与 SYNC_FLUSH 如何取舍?
Kafka 金融配置:
acks=all
min.insync.replicas=2
replication.factor=3
enable.idempotence=true
unclean.leader.election.enable=false含义:至少 2 个 ISR 副本确认写入,禁止非 ISR 节点当选 Leader。
RocketMQ 金融配置:
flushDiskType=SYNC_FLUSH
brokerRole=SYNC_MASTER含义:消息同步刷盘 + 主从同步复制后才返回成功。
取舍:
- 两者都牺牲延迟换取可靠性,Kafka 侧重点是副本 quorum;RocketMQ 侧重点是刷盘 + 主从
- 极端场景(如交易所 Tick):可能接受
acks=1或ASYNC_FLUSH换取更低延迟,但需业务层补偿与对账 - 不能只配
acks=all却使用异步刷盘的 RocketMQ Broker,或只配SYNC_FLUSH却acks=0
Q9: 消息过滤:Kafka vs RocketMQ Tag/SQL92
Kafka:
- Broker 端不支持业务级过滤(除 Kafka Streams 的 Filter)
- 通常做法:Consumer 拉取后过滤,或通过不同 Topic 物理隔离
- Header 可携带元数据,但不过滤传输
RocketMQ:
- Tag:
topic:tag格式,Consumer 订阅时指定selectorExpression(如CRITICAL || WARNING) - SQL92 Filter:基于消息属性的 SQL 表达式(如
amount > 10000 AND region = 'US'),Broker 端过滤,减少网络传输 - 限制:SQL92 需开启
enablePropertyFilter,复杂表达式有性能开销
风控场景:按告警级别用 Tag;按金额/地区用 SQL92。
Q10: Kafka 和 RocketMQ 能否共存?如何分工与桥接?
推荐共存,按数据特性分工(见 4.3 节):
| 集成方式 | 说明 |
|---|---|
| 应用层桥接 | Flink 消费 Kafka → 规则命中 → 写入 RocketMQ 告警 |
| CDC 双写 | Canal 同时投递 Kafka(数仓)与 RocketMQ(业务) |
| Kafka Connect | 社区有 RocketMQ Sink/Source Connector,适合标准化集成 |
| 避免循环转发 | 同一事件只在一个系统中作为 Source of Truth |
面试要点:共存不是"两个都发一遍",而是按吞吐、语义、生态划分边界,中间通过幂等桥接。