RabbitMQ 消息队列详解

拾亿.

已于 2023-11-20 16:46:07 修改

阅读量112

点赞数 1

文章标签： rabbitmq 分布式 java 微服务架构

于 2023-11-20 11:55:52 首次发布

本文链接：https://blog.csdn.net/weixin_49104405/article/details/134504019

版权

1. 前言

在分布式系统中，消息队列是一种关键的组件，用于实现系统之间的异步通信。RabbitMQ 作为一款强大的消息中间件，通过高级消息队列协议（AMQP）实现了可靠的消息传递。

2. RabbitMQ 简介

2.1 什么是 RabbitMQ

RabbitMQ 是一个开源的消息中间件，通过消息队列实现了应用程序的解耦和异步通信。

2.2 RabbitMQ 的特点

多消息模型支持： 点对点、发布/订阅、RPC等。
消息持久化： 保证消息不会因系统故障而丢失。
灵活的路由机制： 通过交换机实现消息的灵活路由。

3. RabbitMQ 核心概念

3.1 生产者（Producer）

生产者负责将消息发送到 RabbitMQ 服务器。以下是一个简单的 Java 生产者示例：

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Producer {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) 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(" [x] Sent '" + message + "'");
        }
    }
}

3.2 消费者（Consumer）

消费者从 RabbitMQ 接收消息并进行处理。以下是一个简单的 Java 消费者示例：

import com.rabbitmq.client.*;

public class Consumer {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) 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);
            System.out.println(" [*] Waiting for messages. To exit press Ctrl+C");

            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            };

            channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
        }
    }
}

3.3 队列（Queue）

队列是消息的缓冲区，保证消息按照先进先出的原则被处理。以下是创建队列的示例：

import com.rabbitmq.client.*;

public class CreateQueue {
    private final static String QUEUE_NAME = "my_queue";

    public static void main(String[] argv) 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);
            System.out.println("Queue '" + QUEUE_NAME + "' created successfully.");
        }
    }
}

3.4 交换机（Exchange）

交换机定义了消息的路由规则，将消息发送到一个或多个队列。以下是一个简单的交换机配置示例：

import com.rabbitmq.client.*;

public class CreateExchange {
    private final static String EXCHANGE_NAME = "my_exchange";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); 
             Channel channel = connection.createChannel()) {

            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
            System.out.println("Exchange '" + EXCHANGE_NAME + "' created successfully.");
        }
    }
}

4. RabbitMQ 的使用场景

4.1 异步任务处理

当涉及到异步任务处理时，RabbitMQ 可以用于将任务放入队列中，由消费者异步执行。以下是一个简单的异步任务处理的场景示例，包括生产者（将任务放入队列）和消费者（执行任务）的示例代码：

4.1.1 生产者（Producer）

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class TaskProducer {
    private final static String TASK_QUEUE_NAME = "task_queue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); 
             Channel channel = connection.createChannel()) {

            channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);

            String message = "Task to be processed.";

            // 设置消息持久化
            channel.basicPublish("", TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

4.1.2 消费者（Consumer）

import com.rabbitmq.client.*;

public class TaskConsumer {
    private final static String TASK_QUEUE_NAME = "task_queue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); 
             Channel channel = connection.createChannel()) {

            channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
            System.out.println(" [*] Waiting for messages. To exit press Ctrl+C");

            // 设置每次从队列中获取的消息数量为1
            channel.basicQos(1);

            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "'");

                // 模拟任务处理
                doWork(message);

                // 手动发送消息确认
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            };

            // 设置消息的手动确认模式
            channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback, consumerTag -> { });
        }
    }

    private static void doWork(String task) throws InterruptedException {
        // 模拟任务处理
        for (char ch : task.toCharArray()) {
            if (ch == '.') {
                Thread.sleep(1000);
            }
        }
    }
}

在这个场景中，生产者将异步任务（消息）发送到名为 task_queue 的队列中。消费者监听这个队列，当有任务到达时，执行相应的处理。由于异步任务可能需要一些时间来完成，因此消费者设置了消息的手动确认模式，并通过 channel.basicAck 在任务完成后手动确认消息。

这个示例展示了如何使用 RabbitMQ 实现简单的异步任务处理，确保任务在系统中以异步方式进行处理，从而提高系统的性能和响应速度。
一个具有注脚的文本。

4.2 解耦系统组件

通过消息队列，系统组件之间的耦合度降低，提高系统的可维护性。以下是一个解耦示例：

4.2.1 生产者（Producer）

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class EventProducer {
    private final static String EXCHANGE_NAME = "events";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); 
             Channel channel = connection.createChannel()) {

            // 定义交换机为fanout类型，实现广播消息给所有队列
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

            // 模拟不同事件类型
            String eventType1 = "UserLoggedIn";
            String eventType2 = "OrderPlaced";

            // 发送事件消息
            channel.basicPublish(EXCHANGE_NAME, "", null, eventType1.getBytes());
            System.out.println(" [x] Sent '" + eventType1 + "'");

            channel.basicPublish(EXCHANGE_NAME, "", null, eventType2.getBytes());
            System.out.println(" [x] Sent '" + eventType2 + "'");
        }
    }
}

4.2.2 消费者1（Consumer1）

import com.rabbitmq.client.*;

public class UserEventHandler {
    private final static String EXCHANGE_NAME = "events";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); 
             Channel channel = connection.createChannel()) {

            // 定义交换机为fanout类型，实现广播消息给所有队列
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

            // 创建一个独立的队列，并绑定到交换机
            String queueName = channel.queueDeclare().getQueue();
            channel.queueBind(queueName, EXCHANGE_NAME, "");

            System.out.println(" [*] Waiting for events. To exit press Ctrl+C");

            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "' for UserEventHandler");
            };

            channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
        }
    }
}
4.2.3 消费者2（Consumer2）
java
Copy code
import com.rabbitmq.client.*;

public class OrderEventHandler {
    private final static String EXCHANGE_NAME = "events";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); 
             Channel channel = connection.createChannel()) {

            // 定义交换机为fanout类型，实现广播消息给所有队列
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

            // 创建一个独立的队列，并绑定到交换机
            String queueName = channel.queueDeclare().getQueue();
            channel.queueBind(queueName, EXCHANGE_NAME, "");

            System.out.println(" [*] Waiting for events. To exit press Ctrl+C");

            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "' for OrderEventHandler");
            };

            channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
        }
    }
}

在这个示例中，生产者发送两种不同类型的事件消息（UserLoggedIn 和 OrderPlaced）到名为 events 的交换机。两个消费者，UserEventHandler 和 OrderEventHandler，创建各自的独立队列并绑定到交换机。这样，每个消费者只接收与其相关的事件消息，实现了系统组件之间的解耦。

通过消息队列，不同的系统组件可以通过发布/订阅模式进行通信，而不需要直接知道彼此的存在。这提高了系统的灵活性和可维护性，因为系统中的组件可以独立演化而不会对其他组件产生负面影响。

4.3 发布/订阅模式

当涉及到发布/订阅模式时，RabbitMQ 提供了 fanout 类型的交换机，它会将消息广播给所有绑定到该交换机的队列。以下是一个简单的发布/订阅示例，其中一个生产者发布消息，而两个消费者分别订阅这些消息：

4.3.1 发布者（Publisher）

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class LogPublisher {
    private final static String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); 
             Channel channel = connection.createChannel()) {

            // 定义交换机为fanout类型，实现广播消息给所有队列
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

            String message = "Log message to be broadcasted.";

            // 发送日志消息
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

4.3.2 订阅者1（Subscriber1）

import com.rabbitmq.client.*;

public class LogSubscriber1 {
    private final static String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); 
             Channel channel = connection.createChannel()) {

            // 定义交换机为fanout类型，实现广播消息给所有队列
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

            // 创建一个独立的队列，并绑定到交换机
            String queueName = channel.queueDeclare().getQueue();
            channel.queueBind(queueName, EXCHANGE_NAME, "");

            System.out.println(" [*] Waiting for logs. To exit press Ctrl+C");

            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "' in LogSubscriber1");
            };

            channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
        }
    }
}

4.3.3 订阅者2（Subscriber2）

import com.rabbitmq.client.*;

public class LogSubscriber2 {
    private final static String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); 
             Channel channel = connection.createChannel()) {

            // 定义交换机为fanout类型，实现广播消息给所有队列
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

            // 创建一个独立的队列，并绑定到交换机
            String queueName = channel.queueDeclare().getQueue();
            channel.queueBind(queueName, EXCHANGE_NAME, "");

            System.out.println(" [*] Waiting for logs. To exit press Ctrl+C");

            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "' in LogSubscriber2");
            };

            channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
        }
    }
}

在这个示例中，LogPublisher 生产者发布日志消息到名为 logs 的 fanout 类型交换机。LogSubscriber1 和 LogSubscriber2 两个消费者创建各自的独立队列并绑定到交换机，从而接收所有发布到该交换机的消息。

通过发布/订阅模式，一个生产者可以轻松地将消息广播给多个消费者，而这些消费者则可以独立地处理这些消息，实现了系统组件之间的解耦。这提高了系统的可维护性和灵活性。

5. RabbitMQ 实战

5.1 安装和配置 RabbitMQ

详细介绍 RabbitMQ 的安装和基本配置步骤。请参考 RabbitMQ 官方文档。

5.2 生产者和消费者的实现

当创建一个简单的 Java 生产者，通常需要使用 RabbitMQ 的 Java客户端库。以下是一个基本的 Java 生产者示例，演示如何连接到 RabbitMQ 服务器、创建队列、发送消息：

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class SimpleProducer {
    private final static String QUEUE_NAME = "my_queue";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 设置 RabbitMQ 服务器地址
        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(" [x] Sent '" + message + "'");
        }
    }
}

这个示例中，使用 RabbitMQ 的 Java 客户端库创建了一个简单的生产者。关键步骤如下：

创建 ConnectionFactory 对象，并设置 RabbitMQ 服务器地址。
通过 ConnectionFactory 创建连接 (Connection)。
通过连接创建信道 (Channel)。
使用 channel.queueDeclare 定义要发送消息的队列。
使用 channel.basicPublish 发布消息到队列。

在这个例子中，消息被发送到名为 my_queue 的队列中。这是一个简单的点对点模式，其中生产者将消息发送到队列，而消费者从队列中接收消息。

确保你已经添加 RabbitMQ 的 Java 客户端库到你的项目中，可以在 Maven 项目中的 pom.xml 文件中添加以下依赖：

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.13.0</version> <!-- 使用当前最新版本 -->
</dependency>

5.3 使用 Exchange 进行消息路由

在 RabbitMQ 中，Exchange 负责定义消息的路由规则，决定消息应该发送到哪个队列。有不同类型的 Exchange，包括 fanout、direct、topic、headers，每种类型都有不同的路由规则。

以下是一个简单的 Java 示例，演示如何使用 Exchange 定义消息的路由规则，实现复杂的消息处理场景。

import com.rabbitmq.client.*;

public class ExchangeExample {
    private final static String EXCHANGE_NAME = "my_exchange";
    private final static String QUEUE_NAME_1 = "queue_1";
    private final static String QUEUE_NAME_2 = "queue_2";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); 
             Channel channel = connection.createChannel()) {

            // 定义交换机为direct类型，实现精确的消息路由
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

            // 定义两个队列
            channel.queueDeclare(QUEUE_NAME_1, false, false, false, null);
            channel.queueDeclare(QUEUE_NAME_2, false, false, false, null);

            // 将队列绑定到交换机，同时指定路由键
            channel.queueBind(QUEUE_NAME_1, EXCHANGE_NAME, "routing_key_1");
            channel.queueBind(QUEUE_NAME_2, EXCHANGE_NAME, "routing_key_2");

            // 发送带有路由键的消息到交换机
            String message1 = "Message for routing_key_1";
            String message2 = "Message for routing_key_2";

            // 发送消息到交换机，并指定路由键
            channel.basicPublish(EXCHANGE_NAME, "routing_key_1", null, message1.getBytes());
            System.out.println(" [x] Sent '" + message1 + "'");

            channel.basicPublish(EXCHANGE_NAME, "routing_key_2", null, message2.getBytes());
            System.out.println(" [x] Sent '" + message2 + "'");
        }
    }
}

这个示例中，我们创建了一个名为 my_exchange 的 direct 类型的交换机。我们定义了两个队列 queue_1 和 queue_2，并分别将它们绑定到交换机上，同时指定了不同的路由键。当我们发送消息到交换机时，通过指定不同的路由键，可以实现消息的精确路由到特定的队列。在实际场景中，这种方式可以用于实现更复杂的消息路由规则，满足系统不同组件之间的通信需求。

6. 总结

RabbitMQ是一个实现了AMQP（Advanced Message Queuing Protocol）高级消息队列协议的消息队列服务，用Erlang语言。是面向消息的中间件。

你可以把它想像成一个邮局：你把信件放入邮箱，邮递员就会把信件投递到你的收件人处。在这个比喻中，RabbitMQ是一个邮箱、邮局、邮递员。RabbitMQ和邮局的主要区别是，它处理的不是纸，而是接收、存储和发送二进制的数据——消息。

生产者（Producer）与消费者（Consumer）和 RabbitMQ 服务（Broker）建立连接，然后生产者发布消息（Message）同时需要携带交换机（Exchange）名称以及路由规则（Routing Key），这样消息会到达指定的交换机，然后交换机根据路由规则匹配对应的 Binding，最终将消息发送到匹配的消息队列（Quene），最后 RabbitMQ 服务将队列中的消息投递给订阅了该队列的消费者（消费者也可以主动拉取消息）

拾亿.

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ 消息队列详解

在分布式系统中，消息队列是一种关键的组件，用于实现系统之间的异步通信。RabbitMQ 作为一款强大的消息中间件，通过高级消息队列协议（AMQP）实现了可靠的消息传递。本文将深入研究 RabbitMQ 的核心概念、使用场景以及实际应用。RabbitMQ 是一个开源的消息中间件，通过消息队列实现了应用程序的解耦和异步通信。RabbitMQ是一个实现了AMQP（Advanced Message Queuing Protocol）高级消息队列协议的消息队列服务，用Erlang语言。是面向消息的中间件。
复制链接

扫一扫