Kafka vs RabbitMQ：消息中间件深度对比与 Java 选型实战

三、项目选型指南：如何选择？

选择没有对错，只有合适与否。请根据你的业务场景回答以下问题：

选择 RabbitMQ 如果：

你的系统是一个业务系统（Enterprise System），更关注消息的可靠投递和复杂路由。

• 场景 1：事务性消息/任务队列
  • 例如：用户下单后，需要发送邮件、短信、更新积分等。你可以将订单消息发送到 RabbitMQ，由不同的服务（消费者）各自完成一项任务。RabbitMQ 能确保任务不被丢失，并且即使某个消费者失败，任务也会重新投递。
• 场景 2：需要精细的路由逻辑
  • 例如：将日志消息根据严重级别（error, warning, info）路由到不同的处理程序。
• 场景 3：对消息延迟有要求
  • 例如：需要实现 30 分钟后检查订单是否支付的延迟消息。
• 总结：核心业务逻辑、异步解耦、微服务间通信、需要可靠执行的任务队列。

选择 Kafka 如果：

你的系统是一个数据流处理系统（Data Pipeline System），更关注海量数据的实时流处理和分析。

• 场景 1：用户活动追踪
  • 例如：网站上的每个点击、浏览、搜索等行为都以事件形式发送到 Kafka。后续的实时分析（如 Flink）、推荐系统、数据仓库（如 Hadoop）都可以消费这些数据流。
• 场景 2：日志聚合
  • 将所有微服务的日志收集到 Kafka，然后统一输出到 ELK（Elasticsearch, Logstash, Kibana）等日志系统。
• 场景 3：流式处理（Stream Processing）
  • 例如：实时监控、实时风控、实时排行榜等。Kafka Streams 或 Flink 可以直接消费 Kafka topic 进行实时计算。
• 总结：大数据、实时分析、事件源（Event Sourcing）、日志收集、流处理。

混合使用：在很多中大型公司，两者是共存的。RabbitMQ 处理核心业务交易，保证可靠性；Kafka 处理数据流和日志，用于分析和监控。

四、Java 代码对比案例

我们以'用户注册成功后发送短信'为例，分别用 RabbitMQ 和 Kafka 实现。

1. RabbitMQ 生产者 (Spring AMQP)

这里我们需要先定义好 Exchange 和 Queue 的配置，这是 RabbitMQ 灵活性的体现。

// 配置 Exchange 和 Queue
@Configuration
public class RabbitConfig {
    public static final String QUEUE_SMS = "queue.sms";
    public static final String EXCHANGE_DIRECT = "exchange.direct";

    @Bean
    public Queue smsQueue() {
        return new Queue(QUEUE_SMS, true); // durable queue
    }

    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(EXCHANGE_DIRECT);
    }

    @Bean
    public Binding bindingSms() {
        return BindingBuilder.bind(smsQueue()).to(directExchange()).with("sms");
    }
}

接下来是发送消息的服务层代码，注意路由键的使用：

@Service
public class UserService {
    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void registerUser(User user) {
        // ... 注册逻辑
        // 发送短信消息，路由键为 "sms"
        rabbitTemplate.convertAndSend("exchange.direct", "sms", "用户注册成功，手机号：" + user.getPhone());
    }
}

2. RabbitMQ 消费者

消费者直接监听特定的队列，一旦收到消息就进行处理：

@Component
public class SmsConsumer {
    @RabbitListener(queues = "queue.sms")
    public void receiveSmsMessage(String message) {
        System.out.println(" [RabbitMQ] 收到短信消息：" + message);
        // 调用短信服务发送短信
    }
}

3. Kafka 生产者

Kafka 的配置相对集中，重点在于 Bootstrap Server 和序列化器的设置：

// 配置
@Configuration
public class KafkaProducerConfig {
    @Bean
    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return new DefaultKafkaProducerFactory<>(configProps);
    }

    @Bean
    public KafkaTemplate<String, String> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }
}

发送消息时，Key 的设计很关键，它决定了消息落在哪个分区，从而影响顺序性：

@Service
public class UserService {
    public static final String TOPIC_USER_EVENTS = "user-events";
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public void registerUser(User user) {
        // ... 注册逻辑
        // 发送事件到 Kafka，Key 可以是 userId 以保证同一用户的消息有序
        kafkaTemplate.send(TOPIC_USER_EVENTS, user.getId(), "REGISTER_SUCCESS:" + user.getPhone());
    }
}

4. Kafka 消费者

Kafka 的消费者需要指定 Group ID，这决定了消息如何在消费者之间分配：

@Component
public class SmsConsumer {
    @KafkaListener(topics = "user-events", groupId = "sms-group")
    public void consumeUserEvent(ConsumerRecord<String, String> record) {
        String value = record.value();
        if (value.startsWith("REGISTER_SUCCESS")) {
            String phone = value.split(":")[1];
            System.out.println(" [Kafka] 收到用户注册事件，准备发送短信至：" + phone);
            // 调用短信服务
        }
    }
}

代码小结：

• RabbitMQ：代码体现了'路由'的概念，需要先定义交换器和队列的绑定关系。消费者直接监听特定队列，适合点对点或发布订阅的业务任务。
• Kafka：代码更体现'流'的概念，生产者向 Topic 发送事件，消费者组监听 Topic 并处理其中的事件流。Key 的设计用于分区和有序性，适合高吞吐的数据管道。

五、面试官：'Kafka 和 RabbitMQ 有什么区别？如何选型？'如何回答

'Kafka 和 RabbitMQ 是两种不同理念的消息中间件。RabbitMQ 基于 AMQP 协议，核心是交换器和队列模型，它更像一个智能的消息代理，擅长于复杂的消息路由、保证消息的可靠投递和不丢失，非常适合处理业务系统中的事务性任务，比如订单处理、异步解耦和微服务通信。

而 Kafka 的核心是分布式持久化日志，它被设计为一个高吞吐的流数据平台。它的优势在于海量数据的实时处理和流式分析，支持消费者重复消费和历史回溯。它更适合构建数据管道、用户活动追踪、日志聚合和实时流处理应用。

在选型上，如果业务核心是需要可靠执行的任务（比如发邮件、扣库存），且对消息路由有复杂要求，我会选择 RabbitMQ。如果业务核心是处理海量事件流或日志数据（比如用户行为分析、实时监控），并要求极高的吞吐量，我会选择 Kafka。在很多大型系统中，两者常协同工作，RabbitMQ 处理核心交易，Kafka 处理数据流。'