消息队列是什么？消息队列的适用场景？

消息队列（Message Queue, MQ）是一种在应用程序间传递消息的通信机制。它通过队列模型在生产者和消费者之间解耦，能支持异步处理和流量削峰填谷，提升系统的性能和可扩展性。

常见的消息队列及其特点

1. RabbitMQ：基于 AMQP 协议，支持多种语言的客户端，提供强大的路由功能、可靠的消息投递机制和丰富的插件支持。

2. Kafka：适合处理高吞吐量的日志、事件流数据，基于分布式系统设计，支持消息的持久化。Kafka 使用分区和副本机制实现高可用性，适合处理大规模实时数据流。

3. RocketMQ：Apache 开源的分布式消息系统，支持事务消息和顺序消息，易于扩展，适合电商、金融等高性能场景。

4. ActiveMQ：支持多种协议（如 JMS、AMQP、MQTT 等），支持持久化和高可用，适用于中小型企业和系统的消息中间件解决方案。

5. Redis 消息队列（Redis Pub/Sub）：轻量级的消息发布/订阅机制，适用于简单的实时消息传递场景。

消息队列的适用场景

1. 解耦：不同系统或模块之间通过消息队列异步通信，降低系统间的耦合度。例如：电商系统中订单模块和库存模块可以通过消息队列解耦，订单成功后将消息放入队列，由库存模块消费进行库存更新。

2. 异步处理：对于耗时任务，消息队列可以实现异步处理，减少请求响应时间。例如：用户注册时，可以将发送欢迎邮件的任务放入消息队列，由邮件服务异步消费。

3. 削峰填谷：当系统在高峰期流量很大时，消息队列可以通过缓冲消息的方式避免系统崩溃。例如：秒杀或抢购系统将订单请求放入队列中按序处理，避免流量直达数据库引发崩溃。

4. 日志处理和数据流：Kafka 常用于日志处理和数据流处理场景。它可以采集大量的日志数据并持久化，供实时分析和数据处理系统使用。

实际业务中使用消息队列的注意事项

1. 消息丢失：确保消息传递的可靠性，尤其是关键业务，通常采用消息确认、持久化存储等机制。

2. 重复消费：由于网络等因素可能导致消息重复投递，消费者应具备幂等性，保证多次处理不会影响最终结果。

3. 消息积压：消费者消费速度较慢时，消息会在队列中积压，需及时监控并扩展消费者数量以消除积压。

4. 消息顺序：在一些场景中需要保证消息的顺序性，比如交易订单的处理。Kafka、RocketMQ 支持分区顺序消息，RabbitMQ 需要在特定队列内处理。

5. 消息过期：在延时任务、定时任务中要控制消息的 TTL（生存时间），避免过期消息处理造成错误。

实际业务中的代码示例

RabbitMQ 示例

// 引入依赖
// <dependency>
//     <groupId>com.rabbitmq</groupId>
//     <artifactId>amqp-client</artifactId>
//     <version>5.12.0</version>
// </dependency>

import com.rabbitmq.client.*;

public class RabbitMQExample {
    private static final String QUEUE_NAME = "test_queue";

    // 生产者
    public static void produceMessage() throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {

            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "Hello, RabbitMQ!";
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println("Sent message: " + message);
        }
    }

    // 消费者
    public static void consumeMessage() throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {

            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println("Received message: " + message);
            };
            channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
        }
    }

    public static void main(String[] args) throws Exception {
        produceMessage();
        consumeMessage();
    }
}

Kafka 示例

// 引入依赖
// <dependency>
//     <groupId>org.apache.kafka</groupId>
//     <artifactId>kafka-clients</artifactId>
//     <version>3.0.0</version>
// </dependency>

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Properties;
import java.util.Collections;

public class KafkaExample {
    private static final String TOPIC = "test_topic";

    // 生产者
    public static void produceMessage() {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        producer.send(new ProducerRecord<>(TOPIC, "key", "Hello, Kafka!"));
        producer.close();
        System.out.println("Message sent to Kafka");
    }

    // 消费者
    public static void consumeMessage() {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "test_group");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Collections.singletonList(TOPIC));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            records.forEach(record -> System.out.println("Received message: " + record.value()));
        }
    }

    public static void main(String[] args) {
        produceMessage();
        consumeMessage();
    }
}

小结

• RabbitMQ：适合复杂的路由需求、支持事务的场景，适用于实时系统。
• Kafka：擅长处理海量的流数据、日志分析和事件处理，适合大规模数据流处理。

在业务中使用消息队列时要考虑消息的可靠性、重复消费、消息的持久化与过期等问题，并选择合适的队列类型和配置以确保高性能和稳定性。