← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共7章,点击直达)
一、为什么需要消息队列?二、四大MQ核心对比三、消息可靠性三环节四、面试高频场景题五、Spring Boot集成实战六、面试高频综合题面试速记口诀

Q104 消息队列深度对比与选型实战

20K Java+AI 岗位高频考点 — 消息队列是分布式系统的神经中枢,面试必问选型与对比。覆盖Kafka/RocketMQ/RabbitMQ/Pulsar四大MQ的核心原理、选型决策、消息可靠性、顺序性、幂等性、积压处理等。

一、为什么需要消息队列?

1. 消息队列的三大核心作用?

作用说明示例
异步非核心逻辑异步化,缩短响应时间注册后异步发短信/邮件
解耦上下游不直接依赖订单→库存/物流/积分各系统
削峰瞬时高并发排队,保护下游秒杀排队下单

缺点:系统复杂度增加、一致性问题、运维成本上升。

2. 消息队列引入的问题?


二、四大MQ核心对比

3. Kafka vs RocketMQ vs RabbitMQ vs Pulsar?

维度KafkaRocketMQRabbitMQPulsar
语言Scala+JavaJavaErlangJava
吞吐量百万级/s十万级/s万级/s百万级/s
延迟ms级ms级μs级ms级
可靠性高(副本)极高(同步刷盘)高(镜像队列)高(BookKeeper)
事务消息支持(0.11+)原生支持不原生支持
延迟消息不原生原生支持(18级别)支持(TTL+DLX)原生
消息回溯✅✅❌✅
顺序消息单Partition单Queue单Queue单Partition
多租户弱弱弱原生
适用场景大数据/日志电商/金融中小项目云原生

4. 如何做MQ选型决策?


数据量级?
├── 日均亿级 → Kafka / Pulsar
├── 日均千万级 → RocketMQ
└── 日均百万级以下 → RabbitMQ

业务需求?
├── 需要事务消息 → RocketMQ
├── 需要延迟消息 → RocketMQ / Pulsar
├── 需要灵活路由 → RabbitMQ
├── 大数据生态 → Kafka
└── 多租户/云原生 → Pulsar

团队技术栈?
├── Java为主 → Kafka / RocketMQ
├── 多语言 → RabbitMQ / Pulsar
└── 运维能力弱 → RabbitMQ(最简单)

5. Kafka为什么吞吐量这么高?

1. 顺序写磁盘:追加写入,充分利用磁盘顺序写性能(600MB/s vs 随机写100KB/s)

2. 零拷贝:sendfile系统调用,数据从Page Cache直接到网卡,跳过用户态

3. 页缓存:利用OS的Page Cache,避免JVM GC

4. 批量压缩:批量发送,减少网络IO

5. 分区并行:多个Partition并行读写

6. RocketMQ的事务消息原理?


1. Producer发送半消息(Half Message) → Broker存储(对Consumer不可见)
2. Broker返回确认 → Producer执行本地事务
3. 本地事务成功 → 发送Commit → Broker投递消息给Consumer
4. 本地事务失败 → 发送Rollback → Broker删除半消息
5. 如果Producer超时未回复 → Broker回查本地事务状态(最多15次)

// Spring Boot + RocketMQ事务消息
@RocketMQTransactionListener
class OrderTransactionListener implements RocketMQLocalTransactionListener {
    @Autowired OrderService orderService;

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

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

7. RabbitMQ的Exchange类型?

类型路由规则场景
Direct精确匹配routing key点对点
Fanout广播到所有绑定队列广播通知
Topic通配符匹配(*和#)发布订阅
Headers匹配消息头特殊路由

8. Pulsar的存算分离架构?


Producer → Broker(无状态,计算层) → BookKeeper(存储层)
                                        ↓
                                   多副本Ledger

优势:
- Broker可随时扩缩容(无状态)
- 存储独立扩展
- 天然支持多租户
- 分层存储(热BookKeeper + 冷S3)

三、消息可靠性三环节

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

生产端:


// Kafka - acks=all确保所有副本写入
producer.send(record, (metadata, exception) -> {
    if (exception != null) {
        // 重试
        retrySend(record);
    }
});
// 配置:acks=all, retries=3, enable.idempotence=true

// RocketMQ - 同步发送+重试
SendResult result = producer.send(msg);
if (result.getSendStatus() != SendStatus.SEND_OK) {
    // 重试或告警
}

Broker端:

消费端:


// Kafka - 手动提交offset
@KafkaListener(topics = "orders")
public void consume(ConsumerRecord<String, String> record, Acknowledgment ack) {
    try {
        process(record.value());
        ack.acknowledge();  // 处理成功后才提交
    } catch (Exception e) {
        // 不提交,下次重新消费
    }
}

10. 如何保证消息顺序性?

分区有序(推荐):同一业务Key路由到同一分区/队列,单线程消费。


// Kafka - 按orderId路由到同一Partition
producer.send(new ProducerRecord<>("orders", orderId, message));

// RocketMQ - MessageQueueSelector
producer.send(msg, new MessageQueueSelector() {
    public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
        Long orderId = (Long) arg;
        return mqs.get((int) (orderId % mqs.size()));
    }
}, orderId);

全局有序:只用1个分区(牺牲并发,不推荐)。

11. 如何保证消息幂等性?

方案一:数据库唯一约束


@Transactional
public void consumeOrder(String messageId, OrderEvent event) {
    // 唯一约束:message_id
    if (consumeLogMapper.existsByMessageId(messageId)) {
        return;  // 已消费,跳过
    }
    orderService.process(event);
    consumeLogMapper.insert(new ConsumeLog(messageId));
}

方案二:Redis去重


public boolean isDuplicate(String messageId) {
    return !redisTemplate.opsForValue()
        .setIfAbsent("mq:consumed:" + messageId, "1", 24, TimeUnit.HOURS);
}

方案三:业务层幂等


// 乐观锁版本号
UPDATE account SET balance = balance - 100, version = version + 1
WHERE user_id = 1 AND version = #{expectedVersion};

12. 消息积压怎么处理?

紧急处理:

1. 增加Consumer实例数(需同步增加分区数)

2. 批量消费(改为批量拉取)

3. 临时转发到新Topic,多Consumer分发

根因排查:

预防措施:


四、面试高频场景题

13. 如何设计消息的消费重试机制?


@RocketMQMessageListener(topic = "orders", consumerGroup = "order-group",
    consumeMode = ConsumeMode.ORDERLY,
    maxReconsumeTimes = 5)  // 最多重试5次
public class OrderConsumer implements RocketMQListener<String> {
    @Override
    public void onMessage(String message) {
        try {
            process(message);
        } catch (Exception e) {
            log.error("消费失败", e);
            throw new RuntimeException(e);  // 抛异常触发重试
        }
    }
}

重试策略:1s → 5s → 10s → 30s → 1min → ...

死信队列:超过最大重试次数 → 进入死信队列 → 人工处理。

14. 如何实现延迟消息?

RocketMQ原生支持:


// 18个延迟级别:1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
Message msg = new Message("delay-topic", "Hello".getBytes());
msg.setDelayTimeLevel(3);  // 10秒后投递
producer.send(msg);

Kafka方案(无原生支持):


// 方案一:时间轮
// 方案二:延迟Topic + 定时任务搬运
// 方案三:外部调度(Redis ZSET + 定时扫描)

15. 如何实现消息的广播消费?

场景:所有Consumer都需要收到消息(如缓存刷新通知)。

16. 如何保证消息的Exactly-Once?

Kafka方案:


// 生产端:幂等Producer
props.put("enable.idempotence", "true");
props.put("transactional.id", "order-txn-1");

KafkaProducer<String, String> producer = new KafkaProducer<>(props);
producer.initTransactions();
try {
    producer.beginTransaction();
    producer.send(record1);
    producer.send(record2);
    producer.commitTransaction();
} catch (Exception e) {
    producer.abortTransaction();
}

消费端:手动提交offset + 幂等消费。


五、Spring Boot集成实战

17. Spring Boot + Kafka集成?


spring:
  kafka:
    bootstrap-servers: localhost:9092
    producer:
      acks: all
      retries: 3
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      group-id: order-group
      auto-offset-reset: earliest
      enable-auto-commit: false  # 手动提交

@KafkaListener(topics = "orders", groupId = "order-group")
public void consume(ConsumerRecord<String, String> record, Acknowledgment ack) {
    process(record.value());
    ack.acknowledge();
}

18. 如何实现消息的灰度消费?


// 按Header路由到不同处理逻辑
@KafkaListener(topics = "orders")
public void consume(ConsumerRecord<String, String> record) {
    String version = new String(record.headers().lastHeader("version").value());
    if ("v2".equals(version)) {
        processV2(record.value());
    } else {
        processV1(record.value());
    }
}

六、面试高频综合题

19. Kafka的Rebalance机制?

触发条件:Consumer加入/离开、订阅Topic变化、分区变化。

Rebalance过程:

1. Coordinator选出Leader Consumer

2. Leader分配分区方案

3. 通知所有Consumer新方案

4. Consumer按新方案消费

问题:Rebalance期间所有Consumer暂停消费(Stop The World)。

优化:

20. 如何回答"你们的MQ选型"?

"我们选了RocketMQ。日订单量50万+,需要事务消息保证订单-库存一致性,原生延迟消息实现超时自动取消。RocketMQ同步刷盘保证消息不丢失。之前评估过Kafka,但Kafka不支持事务消息和延迟消息,且在业务消息场景可靠性不如RocketMQ。"

21. MQ的监控指标?

指标说明告警阈值
Consumer Lag消费延迟> 10万
发送成功率生产成功率< 99.9%
消费延迟消息投递到消费的时间> 30秒
磁盘使用率Broker磁盘> 80%
分区均衡各分区数据量差异不均衡度 > 50%

22. 消息队列的压测方案?


@Test
void pressureTest() {
    int messageCount = 1_000_000;
    long start = System.currentTimeMillis();

    for (int i = 0; i < messageCount; i++) {
        producer.sendAsync(new Message("topic", ("msg-" + i).getBytes()));
    }
    producer.flush();

    long duration = System.currentTimeMillis() - start;
    System.out.printf("发送 %d 条消息,耗时 %d ms,TPS: %d%n",
        messageCount, duration, messageCount * 1000L / duration);
}

23. 如何设计一个消息中间件的统一抽象?


// 统一接口
public interface MessageQueue {
    void send(String topic, String key, String message);
    void subscribe(String topic, String group, MessageHandler handler);
}

// Kafka实现 / RocketMQ实现 / RabbitMQ实现
// 切换MQ只需换实现类,业务代码不变

面试速记口诀

MQ选型三步:看数据量→看业务需求→看团队能力

>

可靠性三环节:生产端重试+Broker持久化+消费端手动ACK

>

顺序性方案:同Key同分区+单线程消费

>

幂等三方案:唯一约束、Redis去重、业务层CAS