20K Java+AI 岗位高频考点 — 消息队列是分布式系统的核心基础设施,面试必考Kafka架构、消息可靠性、顺序消费、RocketMQ事务消息。覆盖Kafka原理、Spring Kafka集成、RocketMQ、消息幂等、最佳实践。
三大作用:
1. 异步:下单→发短信/加积分 异步处理,响应更快
2. 解耦:订单服务发消息,下游服务自己订阅
3. 削峰:秒杀请求先入队列,消费者按能力处理
缺点:
1. 系统复杂度增加(多了一个组件)
2. 消息一致性问题
3. 消息可能丢失/重复
4. 运维成本
MQ选型:
| 维度 | Kafka | RocketMQ | RabbitMQ |
|------|-------|----------|----------|
| 吞吐 | 百万级 | 十万级 | 万级 |
| 延迟 | ms级 | ms级 | μs级 |
| 事务 | 精确一次 | 事务消息 | 不支持 |
| 顺序 | 分区内有序 | 队列有序 | 队列有序 |
| 回溯 | 支持按Offset | 支持按时间 | 不支持 |
| 适用 | 大数据/日志 | 电商/金融 | 中小规模 |
核心概念:
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随机读取
- 支持数据保留策略(时间/大小)
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
// 生产者
@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);
// 重试或入死信队列
}
}
}
问题:多分区无法保证全局有序
方案:只保证分区内有序
保证有序的方法:
1. 同一业务Key发到同一分区
- Producer指定Key → Hash分区
- 如:orderId作为Key
2. 单分区单消费者
- 一个Partition只被一个Consumer消费
3. 单线程消费 + 业务线程池
@KafkaListener(concurrency = "1") // 单线程消费
public void consume(ConsumerRecord<String, String> record) {
// 按key分组到不同队列,每队列单线程处理
}
顺序消费 vs 吞吐量:
- 顺序消费:单分区,吞吐低
- 高吞吐:多分区,不保证全局有序
实际方案:
- 大多数场景:分区内有序即可
- 极少数场景:单分区(牺牲吞吐)
组件:
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
// 半消息机制:先发半消息 → 执行本地事务 → 提交/回滚
// 生产者
@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);
}
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分钟延迟消息 → 消费时检查订单状态 → 未支付则取消
原因:
- 网络抖动导致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去重 + 数据库唯一键 双重保障
原因:消费速度 < 生产速度
紧急处理:
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);
}
三阶段保证:
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%
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去重、状态机、乐观锁