← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共6章,点击直达)
一、消息队列基础二、Kafka深度三、RocketMQ四、消息幂等五、面试高频综合题面试速记口诀

Q137 消息队列Kafka与RocketMQ深度实战

20K Java+AI 岗位高频考点 — 消息队列是分布式系统的核心基础设施,面试必考Kafka架构、消息可靠性、顺序消费、RocketMQ事务消息。覆盖Kafka原理、Spring Kafka集成、RocketMQ、消息幂等、最佳实践。

一、消息队列基础

1. 为什么用消息队列?


三大作用:
1. 异步:下单→发短信/加积分 异步处理,响应更快
2. 解耦:订单服务发消息,下游服务自己订阅
3. 削峰:秒杀请求先入队列,消费者按能力处理

缺点:
1. 系统复杂度增加(多了一个组件)
2. 消息一致性问题
3. 消息可能丢失/重复
4. 运维成本

MQ选型:
| 维度 | Kafka | RocketMQ | RabbitMQ |
|------|-------|----------|----------|
| 吞吐 | 百万级 | 十万级 | 万级 |
| 延迟 | ms级 | ms级 | μs级 |
| 事务 | 精确一次 | 事务消息 | 不支持 |
| 顺序 | 分区内有序 | 队列有序 | 队列有序 |
| 回溯 | 支持按Offset | 支持按时间 | 不支持 |
| 适用 | 大数据/日志 | 电商/金融 | 中小规模 |

二、Kafka深度

2. Kafka架构?


核心概念:
Broker:Kafka服务节点
Topic:消息主题(逻辑分类)
Partition:分区(物理分片,并行度)
Offset:消息在分区内的偏移量
Consumer Group:消费组(组内竞争,组间广播)

架构:
Producer → Broker Cluster → Consumer
              │
         ┌────┼────┐
     Partition 0  Partition 1  Partition 2
     (Leader)    (Leader)    (Leader)
     (Follower)  (Follower)  (Follower)

高可用:
- 每个Partition有Leader和Follower(ISR列表)
- Leader负责读写,Follower同步
- Leader故障 → Follower选举为新Leader
- ISR(In-Sync Replicas):与Leader同步的副本集合

存储:
- 消息追加写入日志文件(顺序IO,极快)
- 按Offset随机读取
- 支持数据保留策略(时间/大小)

3. Kafka消息可靠性?


Producer端:
1. acks=all(等待所有ISR确认)→ 最可靠但最慢
2. acks=1(等待Leader确认)→ 折中
3. acks=0(不等确认)→ 最快但可能丢

Broker端:
1. replication.factor=3(3副本)
2. min.insync.replicas=2(最少2个同步副本)
3. unclean.leader.election.enable=false(禁止非ISR副本成为Leader)

Consumer端:
1. 手动提交Offset(enable.auto.commit=false)
2. 处理完消息再提交
3. 幂等处理(防止重复消费)

Producer配置:
spring.kafka.producer.properties.acks=all
spring.kafka.producer.properties.enable.idempotence=true
spring.kafka.producer.properties.max.in.flight.requests.per.connection=5
spring.kafka.producer.retries=3

Consumer配置:
spring.kafka.consumer.enable-auto-commit=false
spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.listener.ack-mode=manual

4. Spring Kafka实战?


// 生产者
@Service
public class OrderEventProducer {
    @Autowired KafkaTemplate<String, String> kafkaTemplate;

    public void sendOrderCreated(OrderEvent event) {
        ProducerRecord<String, String> record = new ProducerRecord<>(
            "order-events",
            event.getOrderId(),       // key(同key进同一分区→有序)
            toJson(event));
        kafkaTemplate.send(record)
            .addCallback(
                result -> log.info("发送成功: {}", result.getRecordMetadata()),
                ex -> log.error("发送失败", ex));
    }
}

// 消费者(手动ACK)
@Component
@KafkaListener(groupId = "order-service", topics = "order-events")
public class OrderEventConsumer {

    @KafkaHandler
    public void handleOrderCreated(
            ConsumerRecord<String, String> record,
            Acknowledgment ack) {
        try {
            OrderEvent event = parseJson(record.value(), OrderEvent.class);
            processOrder(event);
            ack.acknowledge();  // 手动提交
        } catch (Exception e) {
            log.error("处理失败, offset={}", record.offset(), e);
            // 重试或入死信队列
        }
    }
}

5. Kafka顺序消费?


问题:多分区无法保证全局有序
方案:只保证分区内有序

保证有序的方法:
1. 同一业务Key发到同一分区
   - Producer指定Key → Hash分区
   - 如:orderId作为Key

2. 单分区单消费者
   - 一个Partition只被一个Consumer消费

3. 单线程消费 + 业务线程池
   @KafkaListener(concurrency = "1")  // 单线程消费
   public void consume(ConsumerRecord<String, String> record) {
       // 按key分组到不同队列,每队列单线程处理
   }

顺序消费 vs 吞吐量:
- 顺序消费:单分区,吞吐低
- 高吞吐:多分区,不保证全局有序

实际方案:
- 大多数场景:分区内有序即可
- 极少数场景:单分区(牺牲吞吐)

三、RocketMQ

6. RocketMQ架构?


组件:
NameServer:路由注册中心(无状态,轻量)
Broker:消息存储(Master/Slave)
Producer:消息生产者
Consumer:消息消费者

vs Kafka:
- NameServer vs ZooKeeper(更轻量)
- 支持事务消息(Kafka不支持)
- 支持延迟消息(Kafka不支持)
- 支持消息过滤(Tag/SQL92)
- 支持消息回溯

Spring Boot集成:
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
</dependency>

rocketmq.name-server=localhost:9876
rocketmq.producer.group=order-producer

7. RocketMQ事务消息?


// 半消息机制:先发半消息 → 执行本地事务 → 提交/回滚

// 生产者
@RocketMQTransactionListener
class OrderTransactionListener implements RocketMQLocalTransactionListener {
    @Autowired OrderService orderService;

    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        try {
            orderService.createOrder(parseOrder(msg));
            return COMMIT;
        } catch (Exception e) {
            return ROLLBACK;
        }
    }

    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(MessageExt msg) {
        String orderId = parseOrderId(msg);
        return orderService.exists(orderId) ? COMMIT : ROLLBACK;
    }
}

// 发送事务消息
@Autowired RocketMQTemplate rocketMQTemplate;

public void sendOrderMessage(OrderDTO order) {
    rocketMQTemplate.sendMessageInTransaction(
        "order-topic",
        MessageBuilder.withPayload(order).build(),
        order);
}

8. 延迟消息?


RocketMQ延迟消息:
// 18个延迟级别:1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
// RocketMQ 5.0+支持任意延迟时间

rocketMQTemplate.syncSend("order-timeout",
    MessageBuilder.withPayload(orderId).build(),
    3000,  // 超时
    4      // 延迟级别4 = 30秒后投递
);

// 场景:订单超时自动取消
// 下单后发30分钟延迟消息 → 消费时检查订单状态 → 未支付则取消

四、消息幂等

9. 消息重复消费怎么办?


原因:
- 网络抖动导致ACK失败 → Broker重发
- Consumer重启 → 从上次Commit的Offset重新消费
- Producer重试 → 消息发送多次

幂等方案:

1. 数据库唯一键:
INSERT IGNORE INTO order_log (id, ...) VALUES (?, ...)
-- 重复插入会被唯一键拒绝

2. Redis去重:
if (redis.setnx("msg:" + msgId, "1", 5, TimeUnit.MINUTES)) {
    process(msg);
}

3. 状态机:
if (order.status == CREATED) {  // 只有CREATED状态才能改为PAID
    order.status = PAID;
}

4. 乐观锁:
UPDATE orders SET status = 'PAID', version = version + 1
WHERE id = ? AND version = ?

推荐:Redis去重 + 数据库唯一键 双重保障

10. 消息积压怎么处理?


原因:消费速度 < 生产速度

紧急处理:
1. 增加消费者实例(Kafka增加Consumer)
2. 如果分区数已满 → 增加分区
3. 扩容消费者线程数
4. 临时转发到新Topic(更多分区)

根本解决:
1. 优化消费逻辑(减少单条处理时间)
2. 批量消费
3. 异步处理(先落库再异步处理)
4. 扩容(更多分区+更多消费者)

监控:
- 消费延迟(Consumer Lag)
- Kafka: kafka-consumer-groups.sh --describe
- 告警:Lag > 10000

Spring Kafka批量消费:
@KafkaListener(topics = "orders", batch = "true")
public void batchConsume(List<ConsumerRecord<String, String>> records) {
    List<OrderEvent> events = records.stream()
        .map(r -> parseJson(r.value(), OrderEvent.class))
        .toList();
    orderService.batchProcess(events);
}

五、面试高频综合题

11. 如何保证消息不丢失?


三阶段保证:

1. Producer → Broker:
   - acks=all(等待所有ISR确认)
   - retries=3(自动重试)
   - enable.idempotence=true(幂等Producer)

2. Broker存储:
   - replication.factor=3(3副本)
   - min.insync.replicas=2
   - unclean.leader.election=false
   - flush.messages=1(每条消息刷盘,牺牲性能)

3. Broker → Consumer:
   - 手动提交Offset(处理完再提交)
   - 死信队列(处理失败的消息不丢弃)

总结:acks=all + 3副本 + 手动提交Offset = 基本不丢
代价:吞吐量下降约30-50%

12. Kafka为什么快?


1. 顺序写:消息追加到日志文件(顺序IO比随机IO快100倍)
2. 零拷贝:sendfile()直接从文件到网卡(跳过用户态)
3. 页缓存:利用OS Page Cache(避免JVM GC)
4. 批量发送:Producer批量攒消息后发送
5. 压缩:LZ4/ZSTD压缩减少网络传输
6. 分区并行:多分区并行读写
7. 稀疏索引:Offset→文件位置的稀疏索引(二分查找)

零拷贝对比:
传统:磁盘→内核缓冲→用户缓冲→Socket缓冲→网卡(4次拷贝)
Kafka:磁盘→内核缓冲→网卡(2次拷贝,sendfile)

面试速记口诀

MQ三作用:异步(提响应)、解耦(减依赖)、削峰(保稳定)

>

Kafka不丢三招:acks=all + 3副本 + 手动提交Offset

>

Kafka快四因:顺序写、零拷贝、页缓存、分区并行

>

幂等四方案:唯一键、Redis去重、状态机、乐观锁