RabbitMQ常用工作模式+整合springboot

**RabbitMQ 常用工作模式 + 整合 Spring Boot**

RabbitMQ 是一个流行的消息队列系统，支持多种工作模式。下面我们将介绍常用的工作模式，并结合 Spring Boot 进行整合。

###1. 直接队列（Direct Queue）

直接队列是最简单的一种工作模式。在这种模式中，生产者将消息发送到一个特定的队列中，而消费者从该队列中取出消息。

**Spring Boot 整合示例**

首先，我们需要在 `pom.xml` 文件中添加 RabbitMQ 的依赖：

xml<dependency>
 <groupId>com.rabbitmq</groupId>
 <artifactId>amqp</artifactId>
 <version>5.14.4</version>
</dependency>

然后，我们可以创建一个生产者和一个消费者：

**Producer.java**

java@Componentpublic class Producer {
 @Autowired private ConnectionFactory connectionFactory;
 public void sendMsg(String msg) {
 // 创建连接工厂 Connection connection = connectionFactory.createConnection();
 // 创建通道 Channel channel = connection.createChannel();
 // 声明队列 channel.queueDeclare("myQueue", true, false, false, null);
 // 发送消息 channel.basicPublish("", "myQueue", null, msg.getBytes());
 System.out.println("发送消息：" + msg);
 }
}

**Consumer.java**

java@Componentpublic class Consumer {
 @Autowired private ConnectionFactory connectionFactory;
 public void receiveMsg() {
 // 创建连接工厂 Connection connection = connectionFactory.createConnection();
 // 创建通道 Channel channel = connection.createChannel();
 // 声明队列 channel.queueDeclare("myQueue", true, false, false, null);
 // 绑定队列 String queueName = "myQueue";
 channel.basicConsume(queueName, true, (consumerTag, delivery) -> {
 System.out.println("接收消息：" + new String(delivery.getBody()));
 }, consumerTag -> {
 System.out.println("消费者取消订阅");
 });
 }
}

###2. 队列（Queue）

队列是另一种常用的工作模式。在这种模式中，生产者将消息发送到一个特定的队列中，而消费者从该队列中取出消息。

**Spring Boot 整合示例**

与直接队列类似，我们需要在 `pom.xml` 文件中添加 RabbitMQ 的依赖：

xml<dependency>
 <groupId>com.rabbitmq</groupId>
 <artifactId>amqp</artifactId>
 <version>5.14.4</version>
</dependency>

然后，我们可以创建一个生产者和一个消费者：

**Producer.java**

java@Componentpublic class Producer {
 @Autowired private ConnectionFactory connectionFactory;
 public void sendMsg(String msg) {
 // 创建连接工厂 Connection connection = connectionFactory.createConnection();
 // 创建通道 Channel channel = connection.createChannel();
 // 声明队列 channel.queueDeclare("myQueue", true, false, false, null);
 // 发送消息 channel.basicPublish("", "myQueue", null, msg.getBytes());
 System.out.println("发送消息：" + msg);
 }
}

**Consumer.java**

java@Componentpublic class Consumer {
 @Autowired private ConnectionFactory connectionFactory;
 public void receiveMsg() {
 // 创建连接工厂 Connection connection = connectionFactory.createConnection();
 // 创建通道 Channel channel = connection.createChannel();
 // 声明队列 channel.queueDeclare("myQueue", true, false, false, null);
 // 绑定队列 String queueName = "myQueue";
 channel.basicConsume(queueName, true, (consumerTag, delivery) -> {
 System.out.println("接收消息：" + new String(delivery.getBody()));
 }, consumerTag -> {
 System.out.println("消费者取消订阅");
 });
 }
}

###3. 主题（Topic）

主题是 RabbitMQ 中一种更复杂的工作模式。在这种模式中，生产者将消息发送到一个特定的主题中，而消费者从该主题中取出消息。

**Spring Boot 整合示例**

与队列类似，我们需要在 `pom.xml` 文件中添加 RabbitMQ 的依赖：

xml<dependency>
 <groupId>com.rabbitmq</groupId>
 <artifactId>amqp</artifactId>
 <version>5.14.4</version>
</dependency>

然后，我们可以创建一个生产者和一个消费者：

**Producer.java**

java@Componentpublic class Producer {
 @Autowired private ConnectionFactory connectionFactory;
 public void sendMsg(String msg) {
 // 创建连接工厂 Connection connection = connectionFactory.createConnection();
 // 创建通道 Channel channel = connection.createChannel();
 // 声明主题 String topicName = "myTopic";
 channel.exchangeDeclare(topicName, "fanout", true);
 // 发送消息 channel.basicPublish(topicName, "", null, msg.getBytes());
 System.out.println("发送消息：" + msg);
 }
}

**Consumer.java**

java@Componentpublic class Consumer {
 @Autowired private ConnectionFactory connectionFactory;
 public void receiveMsg() {
 // 创建连接工厂 Connection connection = connectionFactory.createConnection();
 // 创建通道 Channel channel = connection.createChannel();
 // 声明主题 String topicName = "myTopic";
 channel.exchangeDeclare(topicName, "fanout", true);
 // 绑定主题 String queueName = "myQueue";
 channel.queueDeclare(queueName, true, false, false, null);
 channel.queueBind(queueName, topicName, "");
 // 绑定队列 channel.basicConsume(queueName, true, (consumerTag, delivery) -> {
 System.out.println("接收消息：" + new String(delivery.getBody()));
 }, consumerTag -> {
 System.out.println("消费者取消订阅");
 });
 }
}

###4. 死信队列（Dead Letter Queue）

死信队列是 RabbitMQ 中一种特殊的工作模式。在这种模式中，生产者将消息发送到一个特定的队列中，而消费者从该队列中取出消息。如果消息无法被消费者处理，则会被转移到死信队列。

**Spring Boot 整合示例**

与主题类似，我们需要在 `pom.xml` 文件中添加 RabbitMQ 的依赖：

xml<dependency>
 <groupId>com.rabbitmq</groupId>
 <artifactId>amqp</artifactId>
 <version>5.14.4</version>
</dependency>

然后，我们可以创建一个生产者和一个消费者：

**Producer.java**

java@Componentpublic class Producer {
 @Autowired private ConnectionFactory connectionFactory;
 public void sendMsg(String msg) {
 // 创建连接工厂 Connection connection = connectionFactory.createConnection();
 // 创建通道 Channel channel = connection.createChannel();
 // 声明队列 String queueName = "myQueue";
 channel.queueDeclare(queueName, true, false, false, null);
 // 发送消息 channel.basicPublish("", queueName, null, msg.getBytes());
 System.out.println("发送消息：" + msg);
 }
}

**Consumer.java**

java@Componentpublic class Consumer {
 @Autowired private ConnectionFactory connectionFactory;
 public void receiveMsg() {
 // 创建连接工厂 Connection connection = connectionFactory.createConnection();
 // 创建通道 Channel channel = connection.createChannel();
 // 声明队列 String queueName = "myQueue";
 channel.queueDeclare(queueName, true, false, false, null);
 // 绑定队列 channel.basicConsume(queueName, true, (consumerTag, delivery) -> {
 System.out.println("接收消息：" + new String(delivery.getBody()));
 }, consumerTag -> {
 System.out.println("消费者取消订阅");
 });
 }
}

###5. 事务（Transaction）

事务是 RabbitMQ 中一种特殊的工作模式。在这种模式中，生产者将消息发送到一个特定的队列中，而消费者从该队列中取出消息。如果消息无法被消费者处理，则会回滚事务。

**Spring Boot 整合示例**

与死信队列类似，我们需要在 `pom.xml` 文件中添加 RabbitMQ 的依赖：

xml<dependency>
 <groupId>com.rabbitmq</groupId>
 <artifactId>amqp</artifactId>
 <version>5.14.4</version>
</dependency>

然后，我们可以创建一个生产者和一个消费者：

**Producer.java**

java@Componentpublic class Producer