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

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

Hello,我是小兔大白糖。 读完能按可重放/多订阅 vs 复杂路由/任务派发选型,并理解日志型中间件之间的并存分工。

日志流 vs 任务队列:Kafka 偏可重放多订阅;RabbitMQ/RocketMQ 偏路由与任务派发——可并存分工。

估计阅读时间:73 分钟

日志流与队列任务两种哲学
日志流与队列任务两种哲学 · 点击查看 SVG 原图

一句话结论是什么?

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: 2

Producer:实时风控告警

@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 消息可靠性对比配置表

维度KafkaRabbitMQ
Producer 可靠性acks=all, enable.idempotence=true, 事务 APIPublisher 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 的高吞吐源于以下设计:

  1. 顺序磁盘 I/O:Partition 是顺序追加写(Append-only),磁盘顺序写性能接近内存。RabbitMQ 的消息需要随机写入队列索引,且消费后需要删除标记
  2. Page Cache 与 Zero Copy:Kafka 大量依赖 OS Page Cache,消费时通过 sendfile() 直接从 Page Cache 发送到网卡,不经过用户态
  3. 批处理:Producer 和 Consumer 都支持批量操作(Batching),摊平网络 RTT
  4. 无状态 Broker(Relative to Consumer):Broker 不记录 Consumer 消费状态,Offset 由 Consumer 或内部 Topic 管理,Broker 只做简单的文件读取
  5. 分区并行: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),造成延迟抖动。

优化方案:

  1. Sticky Assignor:尽量保持原有分配,减少迁移(Kafka 2.4+ 默认)
  2. Incremental Cooperative Rebalancing(KIP-429):Consumer 逐步放弃和获取 Partition,避免全组停顿。需设置 partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignor
  3. Session Timeout 调优:避免网络抖动导致 Consumer 被误判为离线。设置 session.timeout.ms=45000, heartbeat.interval.ms=15000
  4. Consumer 优雅退出:在 JVM ShutdownHook 中调用 consumer.wakeup(),主动触发 Rebalance 而非等待 Session Timeout
  5. 静态成员(Static Membership,KIP-345):设置 group.instance.id,Consumer 重启后保留原有 Partition 分配,完全避免 Rebalance

Q4: RabbitMQ 的镜像队列(Mirrored Queue)有什么缺点?Quorum Queue 解决了什么?

镜像队列(Classic Mirrored Queue)的缺点:

  1. 同步复制瓶颈:Master 节点需要同步等待所有 Slave 节点确认(ha-mode=all),写入延迟随节点数线性增加
  2. 脑裂问题:网络分区时可能出现多个节点都认为自己是 Master,导致消息重复或丢失
  3. 单队列性能上限:Queue 本质是单线程,即使镜像也无法突破单节点的吞吐上限

Quorum Queue(RabbitMQ 3.8+):

  • 基于 Raft 共识算法,Leader 选举自动完成,无需外部协调
  • 默认写多数派(Majority)即确认,平衡了性能与一致性
  • 网络分区时,少数派分区自动变为只读或不可用,避免脑裂
  • 缺点:不支持 TTL(消息级)、优先级队列、延迟消息插件(截至 3.12 版本仍有部分限制,需查阅最新文档)

Q5: Kafka 和 RabbitMQ 分别如何实现 Exactly-Once?

Kafka Exactly-Once:

  1. 幂等 Producer:设置 enable.idempotence=true,Producer 为每条消息分配 PID(Producer ID)和 Sequence Number,Broker 去重。仅保证单 Partition 内 Exactly-Once
  2. 事务 Producer:使用 initTransactions() / beginTransaction() / commitTransaction(),实现跨 Partition 的原子写入。配合 Consumer 的 isolation.level=read_committed,只读取已提交事务的消息
  3. 端到端 Exactly-Once:Kafka Streams 提供 eos.alpha / eos.beta(KIP-447),通过事务 Offset 提交保证"处理结果写入 + Offset 提交"的原子性

RabbitMQ Exactly-Once: RabbitMQ 本身不提供原生 Exactly-Once,需要业务层保证:

  1. Producer 端:Publisher Confirm 保证消息到达 Exchange/Queue,但无法防止网络重传导致的重复投递
  2. Consumer 端:Manual ACK 保证消息不丢失,但无法防止 ACK 前 Consumer 崩溃导致的重复消费
  3. 业务幂等:通过数据库唯一约束(如 INSERT IGNORE)、Redis SETNX、或业务状态机(如订单状态只能由 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)?

  1. Lazy Queue:消息直接进入磁盘,不占用内存,适合长队列场景
  2. TTL + DLX:设置队列 TTL 或消息 TTL,超期未消费的消息自动进入死信队列,避免无限堆积
  3. Queue Length Limit:设置 x-max-length 或 x-max-length-bytes,超限后新消息被拒绝或丢弃(需配合 Dead Letter)
  4. 增加 Consumer:横向扩展 Consumer 实例,但受限于 Queue 的 FIFO 单线程特性(一个 Queue 只能被一个 Consumer 充分利用)
  5. 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 超过此时间未同步,则被踢出 ISR
  • min.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,可能导致消费堆积

元数据对比

维度KafkaRocketMQ
协调组件ZooKeeper / KRaft ControllerNameServer(无状态)
路由信息Topic 元数据在 Controller/ZKTopic 路由在 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(同步,金融场景)
对比维度KafkaRocketMQ
写入模型每 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 为并发消费
对比维度KafkaRocketMQ
分片单元PartitionMessageQueue
顺序保证单 Partition 内有序单 MQ + ORDERLY 模式
多订阅多 Consumer Group多 Consumer Group 或 Broadcasting
RebalanceGroup Coordinator 触发,影响大Client 端 Rebalance,相对轻量
消费进度__consumer_offsetsBroker 端 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

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 offsetsendOneway + 自动 ack
At Least Once手动 commit + 幂等同步发送 + CONSUME_SUCCESS
跨服务事务Kafka Transaction APIHalf Message + 回查
流处理 EOSKafka 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: 1000

Producer:交易风控事件(异步发送 + 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 消息可靠性对比配置表

维度KafkaRocketMQ
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 + 回查(业务事务场景)
延迟消息自建时间轮 Topic18 级 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,按数据特性分工:

链路选型原因
全量交易流水、行情 TickKafka超高吞吐、长期保留、多 Consumer Group(风控/审计/数仓)
下单-支付-履约事务消息RocketMQ原生事务消息、Half Message 回查
延迟复核、定时关单RocketMQ原生 delayLevel / 5.x 定时消息
实时风控特征(Flink)KafkaFlink 原生 Kafka Source,生态成熟
风控告警推送(SMS/Push)RocketMQTag 过滤、毫秒级投递

集成模式:

  • 应用层桥接:风控 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 分流到不同 ConsumerselectorExpression, 多 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-OnceHalf Message 只保证生产端与本地事务一致;消费端仍需幂等表或业务状态机
Kafka 不能做延迟消息可以,但需自建时间轮 Topic 或调度服务;RocketMQ 4.x 有 18 级固定延迟,5.x 支持任意时间
acks=all 与 SYNC_FLUSH 等价Kafka 的 acks 是副本同步确认;RocketMQ 的 SYNC_FLUSH 是刷盘策略,需同时配置主从同步
Consumer Group Rebalance 只影响 KafkaRocketMQ 也有 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 年):

  1. Kafka 当时不成熟:0.7/0.8 版本尚无幂等生产者、事务 API,延迟消息、消息过滤需自建
  2. 电商业务语义:双 11 需要事务消息(下单-库存-发消息)、18 级延迟关单、Tag 过滤,MetaQ/RocketMQ 原生支持
  3. 存储优化:海量 SKU/订单 Topic,CommitLog 统一写比每 Topic 独立 Partition 目录更省磁盘 I/O
  4. 运维习惯:NameServer 无状态,比当时 Kafka 依赖 ZooKeeper 更轻

现状:阿里同时使用 Kafka(日志/大数据/流计算)与 RocketMQ(核心交易),并非二选一。

Q3: RocketMQ 事务消息与 Kafka 事务 API 有何不同?

维度Kafka TransactionRocketMQ 事务消息
机制PID + Sequence + Transaction CoordinatorHalf Message + 本地事务 + 回查
场景流处理 EOS、跨 Partition 原子写入业务库写入 + 发消息一致性
回查无,依赖事务超时与 read_committedBroker 主动 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:

  1. partition.assignment.strategy=CooperativeStickyAssignor(增量协作 Rebalance)
  2. Static Membership:group.instance.id,重启不触发 Rebalance
  3. 增大 session.timeout.ms,避免网络抖动误判离线
  4. 控制 Partition 总数,减少 Rebalance 分配开销

RocketMQ:

  1. 避免 Consumer 频繁重启;使用优雅下线
  2. 消费逻辑与 Rebalance 解耦,避免在 MessageListener 中执行耗时操作
  3. 监控 consumer lag,堆积时优先扩容 Consumer 而非盲目重启
  4. 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

面试要点:共存不是"两个都发一遍",而是按吞吐、语义、生态划分边界,中间通过幂等桥接。