1.MQ简介

MQ 全称为 Message Queue，是在消息的传输过程中保存消息的容器。多用于分布式系统 之间进行通信。

2.为什么要用 MQ

1.流量消峰

没使用MQ



使用了MQ

2.应用解耦

3.异步处理

没使用MQ



使用了MQ

3.常见的MQ对比

先学习RabbitMQ,后面可以再学学RocketMQ和Kafka

4.RabbitMQ的安装(linux:centos7环境,我使用的是docker容器进行安装的,也可以使用其他方式 >>>> 非docker方式安装RabbitMQ)

一、下载镜像

docker search RabbitMQ

进入docker hub镜像仓库地址：https://hub.docker.com/

搜索rabbitMq，进入官方的镜像，可以看到以下几种类型的镜像；我们选择带有“mangement”的版本（包含web管理页面）；

拉取镜像

  1. docker pull rabbitmq:management

二、安装和web界面启动

镜像创建和启动容器

  1.  docker run -d -p 5672:5672 -p 15672:15672 --name rabbitmq rabbitmq:management

说明：

  • -d 后台运行容器；
  • --name 指定容器名；
  • -p 指定服务运行的端口（5672：应用访问端口；15672：控制台Web端口号）；
  • --hostname 主机名（RabbitMQ的一个重要注意事项是它根据所谓的 “节点名称” 存储数据，默认为主机名）；

查看所有正在运行容器

  1. docker ps -a

删除指定容器

  1. docker rm ID/NAME

删除所有闲置容器

  1. docker container prune

重启docker

  1. systemctl restart docker

重启启动RabbitMQ

  1.  docker run -d -p 5672:5672 -p 15672:15672 --name rabbitmq rabbitmq:management

开启防火墙15672端口

  1.  firewall-cmd --zone=public --add-port=15672/tcp --permanent
  3.  firewall-cmd --reload

停止RabbitMQ容器

  1. - 命令： docker stop rabbitmq

启动RabbitMQ容器

  1. - 命令：docker start rabbitmq

重启RabbitMQ容器

  1. - 命令：docker restart rabbitmq

三、测试

http://linuxip地址:15672，这里的用户名和密码默认都是guest

四、进入rabbitmq容器

  1. docker exec -it rabbitmq /bin/bash

五、添加新的用户

创建账号

  1. rabbitmqctl add_user 【用户名】 【密码】

设置用户角色

  1. rabbitmqctl set_user_tags admin administrator

设置用户权限

  1. rabbitmqctl set_permissions -p "/" qbb ".*"".*"".*"

查看当前用户角色、权限

  1. rabbitmqctl list_users

安装好RabbitMQ后如果需要熟悉里面的操作,大家可以参考官方网站

5.RabbitMQ提供了7种工作模式

6.RabbitMQ入门之简单模式(Java操作RabbitMQ)

1.创建一个普通的maven项目



2.在pom.xml中导入相关依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.qbb</groupId>
  8.     <artifactId>java-mq-producer</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>com.rabbitmq</groupId>
  14.             <artifactId>amqp-client</artifactId>
  15.             <version>5.14.2</version>
  16.         </dependency>
  17.     </dependencies>
  19. </project>

3.编写生产者发送消息

  1. package com.qbb.simple;
  3. import com.rabbitmq.client.Channel;
  4. import com.rabbitmq.client.Connection;
  5. import com.rabbitmq.client.ConnectionFactory;
  7. /**
  8.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  9.  * @version 1.0
  10.  * @date 2022-03-28  16:25
  11.  * @Description:生产者
  12.  */
  13. public class SimpleProducer {
  14.     public static void main(String[] args) {
  15.         try {
  16.             // 创建连接工厂
  17.             ConnectionFactory factory = new ConnectionFactory();
  18.             factory.setHost("192.168.137.72");
  19.             factory.setPort(5672);
  20.             factory.setUsername("qbb");
  21.             factory.setPassword("qbb");
  22.             factory.setVirtualHost("/");
  23.             // 获取连接对象
  24.             Connection connection = factory.newConnection();
  25.             // 获取channel
  26.             Channel channel = connection.createChannel();
  27.             // 我们将消息发送到队列中,前提是我们要有一个队列,所以先声明一个队列
  28.             /**
  29.              * String queue : 队列名称
  30.              * boolean durable : 队列是否持久化
  31.              * boolean exclusive : 是否独占本次连接,默认true
  32.              * boolean autoDelete : 是否自动删除，最后一个消费者断开连接以后，该队列是否自动删除
  33.              * Map<String, Object> arguments : 队列其它参数
  34.              */
  35.             channel.queueDeclare("simple-queue", false, false, false, null);
  36.             // 发送消息
  37.             /**
  38.              * String exchange : 交换机名称,发送到哪个交换机
  39.              * String routingKey : 路由key是哪个
  40.              * BasicProperties props : 其他参数信息
  41.              * byte[] body : 要发送的消息
  42.              */
  43.             String message = "hello QiuQiu RabbitMQ";
  44.             channel.basicPublish("", "simple-queue", null, message.getBytes());
  46.             System.out.println("消息发送完毕");
  47.             // 释放资源
  48.             channel.close();
  49.             connection.close();
  50.         } catch (Exception e) {
  51.             e.printStackTrace();
  52.         }
  53.     }
  54. }

4.编写消费者接收消息

  1. package com.qbb.simple;
  3. import com.rabbitmq.client.*;
  5. import java.io.IOException;
  6. import java.util.concurrent.TimeoutException;
  8. /**
  9.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  10.  * @version 1.0
  11.  * @date 2022-03-28  18:11
  12.  * @Description:消费者
  13.  */
  14. public class SimpleConsumer {
  15.     public static void main(String[] args) {
  16.         try {
  17.             // 创建连接工厂
  18.             ConnectionFactory factory = new ConnectionFactory();
  19.             factory.setHost("192.168.137.72");
  20.             factory.setPort(5672);
  21.             factory.setUsername("qbb");
  22.             factory.setPassword("qbb");
  23.             factory.setVirtualHost("/");
  24.             // 获取连接对象
  25.             Connection connection = factory.newConnection();
  26.             // 获取channel通道
  27.             Channel channel = connection.createChannel();
  28.             // 声明队列
  29.             /**
  30.              * String queue,
  31.              * boolean autoAck,
  32.              * Consumer callback
  33.              */
  34.             Consumer consumer = new DefaultConsumer(channel) {
  35.                 @Override
  36.                 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  37.                     String msg = new String(body);
  38.                     System.out.println(msg);
  39.                 }
  40.             };
  41.             //监听队列,第二个参数false，手动进行ACK
  42.             channel.basicConsume("simple-queue", true, consumer);
  43.             // 注意消费者端不要释放资源,需要一直监控着队列中的消息
  44.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.         }
  47.     }
  48. }

注意:我们可以看到控制台报了一个错,应该是少了个slf4j的依赖,我们导入就好了

  1. <dependency>
  2. 	<groupId>org.slf4j</groupId>
  3. 	<artifactId>slf4j-simple</artifactId>
  4. 	<version>1.7.25</version>
  5. 	<scope>compile</scope>
  6. </dependency>

7.消息确认机制

我们查询图形化界面发现消息一经消费,就被删除了.

那么RabbitMQ怎么知道消息已经被我们消费了呢?

如果消费者领取消息后，还没执行操作就挂掉了呢？

或者抛出了异常？消息消费失败，但是 RabbitMQ 无从得知，这样消息就丢失了！

因此，RabbitMQ 有一个 ACK 机制。

当消费者获取消息后，会向 RabbitMQ 发送回执 ACK， 告知消息已经被接收。

不过这种回执 ACK 分两种情况:

  • 自动 ACK：消息一旦被接收，消费者自动发送 ACK
  • 手动 ACK：消息接收后，不会发送 ACK，需要手动调用
  • 如果消息不太重要，丢失也没有影响，那么自动 ACK 会比较方便
  • 如果消息非常重要，不容丢失。那么最好在消费完成后手动 ACK，否则接收消息后 就自动 ACK，RabbitMQ 就会把消息从队列中删除。如果此时消费者宕机，那么消 息就丢失了。

手动在consumer中制造一个异常,发现消息依旧被消费了

测试一下手动ACK

  1. // 修改consumer端的代码
  2.  Consumer consumer = new DefaultConsumer(channel) {
  3. 	 @Override
  4. 	 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  5. 		 String msg = new String(body);
  6. 		 int a = 1 / 0;
  7. 		 System.out.println(msg);
  9. 		 //手动进行ACK
  10. 		 channel.basicAck(envelope.getDeliveryTag(), false);
  11. 	 }
  12.  };
  13. //监听队列,第二个参数false，手动进行ACK
  14. channel.basicConsume("simple-queue", false, consumer);

可以看出即使出现了异常消息依旧不会被消费丢失



去掉异常重新启动consumer发现消息又被消费了

8.RabbitMQ入门之工作队列模式(Java操作RabbitMQ)

与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息

应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

在前面的工程基础上创建两个包,继续编写代码

我们把获取connection对象抽取一个utils工具类

1.编写生产者发送消息

  1. package com.qbb.workqueue;
  3. import com.qbb.utils.MQUtil;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  7. /**
  8.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  9.  * @version 1.0
  10.  * @date 2022-03-28  19:09
  11.  * @Description:
  12.  */
  13. public class WorkQueueProducer {
  14.     public static void main(String[] args) {
  15.         try {
  16.             Connection connection = MQUtil.getConnection();
  17.             Channel channel = connection.createChannel();
  18.             channel.queueDeclare("work-queue", false, false, false, null);
  19.             // 发送消息
  20.             for (int i = 0; i < 20; i++) {
  21.                 String message = "hello QiuQiu work-queue:"+i;
  22.                 channel.basicPublish("", "work-queue", null, message.getBytes());
  23.             }
  24.             // 释放资源
  25.             channel.close();
  26.             connection.close();
  27.         } catch (Exception e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31. }

2.编写消费者接收消息

  1. **消费者1**
  2. package com.qbb.workqueue;
  4. import com.qbb.utils.MQUtil;
  5. import com.rabbitmq.client.*;
  7. import java.io.IOException;
  8. import java.util.Timer;
  9. import java.util.TimerTask;
  10. import java.util.concurrent.TimeUnit;
  12. /**
  13.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  14.  * @version 1.0
  15.  * @date 2022-03-28  19:21
  16.  * @Description:
  17.  */
  18. public class WorkQueueConsumer1 {
  19.     public static void main(String[] args) {
  20.         try {
  21.             Connection connection = MQUtil.getConnection();
  22.             Channel channel = connection.createChannel();
  23.             channel.queueDeclare("work-queue", false, false, false, null);
  24.             Consumer consumer = new DefaultConsumer(channel) {
  25.                 @Override
  26.                 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  27.                     // 消费者1消费消息
  28.                     try {
  29.                         // 睡50ms秒模拟,此服务性能差一点
  30.                         Thread.sleep(50);
  31.                     } catch (InterruptedException e) {
  32.                         e.printStackTrace();
  33.                     }
  34.                     String msg = new String(body);
  35.                     System.out.println("消费者1消费消息 = " + msg);
  36.                     channel.basicAck(envelope.getDeliveryTag(), false);
  37.                 }
  38.             };
  39.             channel.basicConsume("work-queue", false, consumer);
  40.         } catch (Exception e) {
  41.             e.printStackTrace();
  42.         }
  43.     }
  44. }
  1. **消费者2**
  2. package com.qbb.workqueue;
  4. import com.qbb.utils.MQUtil;
  5. import com.rabbitmq.client.*;
  7. import java.io.IOException;
  8. import java.util.concurrent.TimeUnit;
  10. /**
  11.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  12.  * @version 1.0
  13.  * @date 2022-03-28  19:21
  14.  * @Description:
  15.  */
  16. public class WorkQueueConsumer2 {
  17.     public static void main(String[] args) {
  18.         try {
  19.             Connection connection = MQUtil.getConnection();
  20.             Channel channel = connection.createChannel();
  21.             channel.queueDeclare("work-queue", false, false, false, null);
  22.             Consumer consumer = new DefaultConsumer(channel) {
  23.                 @Override
  24.                 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  25.                     // 消费者2消费消息
  26.                     String msg = new String(body);
  27.                     System.out.println("消费者2消费消息 = " + msg);
  28.                     channel.basicAck(envelope.getDeliveryTag(), false);
  29.                 }
  30.             };
  31.             channel.basicConsume("work-queue", false, consumer);
  32.         } catch (Exception e) {
  33.             e.printStackTrace();
  34.         }
  35.     }
  36. }



可以发现，两个消费者各自消费了 25 条消息，而且各不相同，这就实现了任务的分发。

但是我现在想让性能差一点的服务器少处理点消息,实现能者多劳怎么办呢? 好办

在比较慢的消费者创建队列后我们可以使用 basicQos 方法和 prefetchCount = n ,告诉RabbitMQ每次给我发送一个消息等我处理完这个消息再给我发一个,一次一个的发消息

  1. ... WorkQueueConsumer1.java ...
  2. // 设置每次拉取一条消息消费
  3. channel.basicQos(1);



这样就解决了服务器性能差异问题

8.RabbitMQ入门之发布订阅模式|Publish/Subscribe(Java操作RabbitMQ)

一次同时向多个消费者发送消息,一条消息可以被多个消费者消费

在订阅模型中，多了一个 exchange 角色，而且过程略有变化：

  • P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给 X（交换机）
  • C：消费者，消息的接受者，会一直等待消息到来。
  • Queue：消息队列，接收消息、缓存消息。
  • Exchange：交换机，图中的 X。

    一方面，接收生产者发送的消息。另一方面，知道如 何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何 操作，取决于 Exchange 的类型。

Exchange 有常见以下 3 种类型：

  • Fanout：广播，将消息交给所有绑定到交换机的队列
  • Direct：定向，把消息交给符合指定 routing key 的队列
  • Topic：通配符，把消息交给符合 routing pattern（路由模式） 的队列 Exchange（交换机）只负责转发消息，不具备存储消息的能力,因此如果没有任何队列与 Exchange 绑定，或者没有符合路由规则的队列，那么消息会丢失！

在广播模式下，消息发送流程是这样的:

  • 可以有多个消费者 -每个消费者有自己的 queue（队列）
  • 每个队列都要绑定到 Exchange（交换机）
  • 生产者发送的消息,只能发送到交换机,交换机来决定要发给哪个队列,生产者无法决定
  • 交换机把消息发送给绑定过的所有队列
  • 队列的消费者都能拿到消息。实现一条消息被多个消费者消费

Fanout 交换机

1.队列在绑定到交换机的时候不需要指定 routing key

2.发送消息的时候也不需要指定 routing key

3.凡是发送给交换机的消息都会广播发送到所有与交换机绑定的队列中。

1.编写生产者发送消息

  1. package com.qbb.pubsub;
  3. import com.qbb.utils.MQUtil;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  7. /**
  8.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  9.  * @version 1.0
  10.  * @date 2022-03-28  19:56
  11.  * @Description:发布订阅模式
  12.  */
  13. public class PubSubProducer {
  14.     public static void main(String[] args) {
  15.         try {
  16.             Connection connection = MQUtil.getConnection();
  17.             Channel channel = connection.createChannel();
  18.             // 声明交换机
  19.             /**
  20.              * 参数1:交换机名
  21.              * 参数2:交换机类型
  22.              */
  23.             channel.exchangeDeclare("fanout-exchange","fanout");
  25.             String message = "hello QiuQiu pubsub";
  26.             channel.basicPublish("fanout-exchange", "pubsub-queue", null, message.getBytes());
  28.             channel.close();
  29.             connection.close();
  30.         } catch (Exception e) {
  31.             e.printStackTrace();
  32.         }
  33.     }
  34. }

2.编写消费者接收消息

  1. **消费者1**
  2. package com.qbb.pubsub;
  4. import com.qbb.utils.MQUtil;
  5. import com.rabbitmq.client.*;
  7. import java.io.IOException;
  9. /**
  10.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  11.  * @version 1.0
  12.  * @date 2022-03-28  20:02
  13.  * @Description:发布订阅消费者
  14.  */
  15. public class PubSubConsumer1 {
  16.     public static void main(String[] args) {
  17.         try {
  18.             // 获取连接
  19.             Connection connection = MQUtil.getConnection();
  20.             // 获取channel通道
  21.             Channel channel = connection.createChannel();
  22.             // 声明队列
  23.             channel.queueDeclare("fanout-queue1", false, false, false, null);
  24.             // 将队列绑定到交换机
  25.             /**
  26.              * 参数1:队列名称
  27.              * 参数2:交换机名称
  28.              * 参数3:路由key
  29.              */
  30.             channel.queueBind("fanout-queue1", "fanout-exchange", "pubsub-queue");
  31.             Consumer consumer = new DefaultConsumer(channel) {
  32.                 @Override
  33.                 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  34.                     System.out.println("消费者唯一标识 = " + consumerTag);
  35.                     System.out.println("交换机名称 = " + envelope.getExchange());
  36.                     System.out.println("消息唯一标识 = " + envelope.getDeliveryTag());
  37.                     System.out.println("路由key = " + envelope.getRoutingKey());
  39.                     System.out.println("消费者1消费消息Message = " + new String(body));
  40.                     // 手动ACK
  41.                     channel.basicAck(envelope.getDeliveryTag(), false);
  42.                 }
  43.             };
  44.             channel.basicConsume("fanout-queue1", false, consumer);
  45.         } catch (Exception e) {
  46.             e.printStackTrace();
  47.         }
  48.     }
  49. }
  1. **消费者2**
  2. package com.qbb.pubsub;
  4. import com.qbb.utils.MQUtil;
  5. import com.rabbitmq.client.*;
  7. import java.io.IOException;
  9. /**
  10.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  11.  * @version 1.0
  12.  * @date 2022-03-28  20:02
  13.  * @Description:发布订阅消费者
  14.  */
  15. public class PubSubConsumer2 {
  16.     public static void main(String[] args) {
  17.         try {
  18.             // 获取连接
  19.             Connection connection = MQUtil.getConnection();
  20.             // 获取channel通道
  21.             Channel channel = connection.createChannel();
  22.             // 声明队列
  23.             channel.queueDeclare("fanout-queue2", false, false, false, null);
  24.             // 将队列绑定到交换机
  25.             /**
  26.              * 参数1:队列名称
  27.              * 参数2:交换机名称
  28.              * 参数3:路由key
  29.              */
  30.             channel.queueBind("fanout-queue2", "fanout-exchange", "pubsub-queue");
  31.             Consumer consumer = new DefaultConsumer(channel) {
  32.                 @Override
  33.                 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  34.                     System.out.println("消费者唯一标识 = " + consumerTag);
  35.                     System.out.println("交换机名称 = " + envelope.getExchange());
  36.                     System.out.println("消息唯一标识 = " + envelope.getDeliveryTag());
  37.                     System.out.println("路由key = " + envelope.getRoutingKey());
  39.                     System.out.println("消费者2消费消息Message = " + new String(body));
  40.                     // 手动ACK
  41.                     channel.basicAck(envelope.getDeliveryTag(), false);
  42.                 }
  43.             };
  44.             channel.basicConsume("fanout-queue2", false, consumer);
  45.         } catch (Exception e) {
  46.             e.printStackTrace();
  47.         }
  48.     }
  49. }

测试结果:



发布订阅模式与工作队列模式的区别

1、工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机。

2、发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发 送消息(底层使用默认交换机)。

3、发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作 队列模式会将队列绑 定到默认的交换机 。

9.RabbitMQ入门之Routing 路由模式(Java操作RabbitMQ)

有选择性的接收消息

  • 在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到 Direct 类 型的 Exchange。

路由模式特点：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由 key）
  • 消息的发送方在 向 Exchange 发送消息时，也必须指定消息的 RoutingKey。
  • Exchange 不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行 判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

  • P：生产者，向 Exchange 发送消息，发送消息时，会指定一个 routing key。
  • X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与 routing key 完全匹配的队列
  • C1：消费者，其所在队列指定了需要 routing key 为 error 的消息
  • C2：消费者，其所在队列指定了需要 routing key 为 info、error、warning 的 消息

可以看出routing模式和发布订阅模式没多大区别,只是交换机不同而已

1.编写生产者发送消息(发送增 删 改消息)

  1. package com.qbb.routing;
  3. import com.qbb.utils.MQUtil;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  7. /**
  8.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  9.  * @version 1.0
  10.  * @date 2022-03-28  20:39
  11.  * @Description:
  12.  */
  13. public class RoutingProducer {
  14.     public static void main(String[] args) {
  15.         try {
  16.             Connection connection = MQUtil.getConnection();
  17.             Channel channel = connection.createChannel();
  18.             // 声明交换机
  19.             /**
  20.              * 参数1:交换机名
  21.              * 参数2:交换机类型
  22.              */
  23.             channel.exchangeDeclare("routing-exchange", "direct");
  25.             String message = "hello QiuQiu 添加商品";
  26.             channel.basicPublish("routing-exchange", "insert", null, message.getBytes());
  27.             // String message1 = "hello QiuQiu 删除商品";
  28.             // channel.basicPublish("routing-exchange", "delete", null, message1.getBytes());
  29.             // String message2 = "hello QiuQiu 修改商品";
  30.             // channel.basicPublish("routing-exchange", "update", null, message2.getBytes());
  32.             channel.close();
  33.             connection.close();
  34.         } catch (Exception e) {
  35.             e.printStackTrace();
  36.         }
  37.     }
  38. }

2.编写消费者接收消息

  1. **消费者1**
  2. package com.qbb.routing;
  4. import com.qbb.utils.MQUtil;
  5. import com.rabbitmq.client.*;
  7. import java.io.IOException;
  9. /**
  10.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  11.  * @version 1.0
  12.  * @date 2022-03-28  20:36
  13.  * @Description:routing模式
  14.  */
  15. public class RoutingComsumer1 {
  16.     public static void main(String[] args) {
  17.         try {
  18.             // 获取连接
  19.             Connection connection = MQUtil.getConnection();
  20.             // 获取channel通道
  21.             Channel channel = connection.createChannel();
  22.             // 声明队列
  23.             channel.queueDeclare("routing-queue1", false, false, false, null);
  24.             // 将队列绑定到交换机
  25.             /**
  26.              * 参数1:队列名称
  27.              * 参数2:交换机名称
  28.              * 参数3:路由key
  29.              */
  30.             channel.queueBind("routing-queue1", "routing-exchange", "insert");
  32.             Consumer consumer = new DefaultConsumer(channel) {
  33.                 @Override
  34.                 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  35.                     System.out.println("消费者唯一标识 = " + consumerTag);
  36.                     System.out.println("交换机名称 = " + envelope.getExchange());
  37.                     System.out.println("消息唯一标识 = " + envelope.getDeliveryTag());
  38.                     System.out.println("路由key = " + envelope.getRoutingKey());
  40.                     System.out.println("消费者1消费消息Message = " + new String(body));
  41.                 }
  42.             };
  43.             channel.basicConsume("routing-queue1", true, consumer);
  44.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.         }
  47.     }
  48. }
  1. **消费者2**
  2. package com.qbb.routing;
  4. import com.qbb.utils.MQUtil;
  5. import com.rabbitmq.client.*;
  7. import java.io.IOException;
  9. /**
  10.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  11.  * @version 1.0
  12.  * @date 2022-03-28  20:36
  13.  * @Description:
  14.  */
  15. public class RoutingComsumer2 {
  16.     public static void main(String[] args) {
  17.         try {
  18.             // 获取连接
  19.             Connection connection = MQUtil.getConnection();
  20.             // 获取channel通道
  21.             Channel channel = connection.createChannel();
  22.             // 声明队列
  23.             channel.queueDeclare("routing-queue2", false, false, false, null);
  24.             // 将队列绑定到交换机
  25.             /**
  26.              * 参数1:队列名称
  27.              * 参数2:交换机名称
  28.              * 参数3:路由key
  29.              */
  30.             channel.queueBind("routing-queue2", "routing-exchange", "insert");
  31.             channel.queueBind("routing-queue2", "routing-exchange", "delete");
  32.             channel.queueBind("routing-queue2", "routing-exchange", "update");
  34.             Consumer consumer = new DefaultConsumer(channel) {
  35.                 @Override
  36.                 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  37.                     System.out.println("消费者唯一标识 = " + consumerTag);
  38.                     System.out.println("交换机名称 = " + envelope.getExchange());
  39.                     System.out.println("消息唯一标识 = " + envelope.getDeliveryTag());
  40.                     System.out.println("路由key = " + envelope.getRoutingKey());
  42.                     System.out.println("消费者2消费消息Message = " + new String(body));
  43.                 }
  44.             };
  45.             channel.basicConsume("routing-queue2", true, consumer);
  46.         } catch (Exception e) {
  47.             e.printStackTrace();
  48.         }
  49.     }
  50. }

测试结果:

10.RabbitMQ入门之Topics通配符模式(Java操作RabbitMQ)

Topic 类型与 Direct 相比，都是可以根据RoutingKey把消息路由到不同的队列。只 不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！ Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好 1 个词



1.编写生产者发送消息(发送消息的 routing key 有 3 种： item.insert、 item.update、item.delete)

  1. package com.qbb.topic;
  3. import com.qbb.utils.MQUtil;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  7. /**
  8.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  9.  * @version 1.0
  10.  * @date 2022-03-28  20:39
  11.  * @Description:
  12.  */
  13. public class TopicProducer {
  14.     public static void main(String[] args) {
  15.         try {
  16.             Connection connection = MQUtil.getConnection();
  17.             Channel channel = connection.createChannel();
  18.             // 声明交换机
  19.             /**
  20.              * 参数1:交换机名
  21.              * 参数2:交换机类型
  22.              */
  23.             channel.exchangeDeclare("topic-exchange", "topic");
  25.             // String message = "hello QiuQiu 添加商品";
  26.             // channel.basicPublish("topic-exchange", "item.insert", null, message.getBytes());
  27.             // String message1 = "hello QiuQiu 删除商品";
  28.             // channel.basicPublish("topic-exchange", "item.delete", null, message1.getBytes());
  29.             String message2 = "hello QiuQiu 修改商品";
  30.             channel.basicPublish("topic-exchange", "item.update.do", null, message2.getBytes());
  32.             channel.close();
  33.             connection.close();
  34.         } catch (Exception e) {
  35.             e.printStackTrace();
  36.         }
  37.     }
  38. }

2.编写消费者接收消息

  1. **消费者1**
  2. package com.qbb.topic;
  4. import com.qbb.utils.MQUtil;
  5. import com.rabbitmq.client.*;
  7. import java.io.IOException;
  9. /**
  10.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  11.  * @version 1.0
  12.  * @date 2022-03-28  20:36
  13.  * @Description:routing模式
  14.  */
  15. public class TopicConsumer1 {
  16.     public static void main(String[] args) {
  17.         try {
  18.             // 获取连接
  19.             Connection connection = MQUtil.getConnection();
  20.             // 获取channel通道
  21.             Channel channel = connection.createChannel();
  22.             // 声明队列
  23.             channel.queueDeclare("topic-queue1", false, false, false, null);
  24.             // 将队列绑定到交换机
  25.             /**
  26.              * 参数1:队列名称
  27.              * 参数2:交换机名称
  28.              * 参数3:路由key
  29.              */
  30.             channel.queueBind("topic-queue1", "topic-exchange", "#.insert");
  31.             channel.queueBind("topic-queue1", "topic-exchange", "#.update.#");
  33.             Consumer consumer = new DefaultConsumer(channel) {
  34.                 @Override
  35.                 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  36.                     System.out.println("消费者唯一标识 = " + consumerTag);
  37.                     System.out.println("交换机名称 = " + envelope.getExchange());
  38.                     System.out.println("消息唯一标识 = " + envelope.getDeliveryTag());
  39.                     System.out.println("路由key = " + envelope.getRoutingKey());
  41.                     System.out.println("消费者1消费消息Message = " + new String(body));
  42.                 }
  43.             };
  44.             channel.basicConsume("topic-queue1", true, consumer);
  45.         } catch (Exception e) {
  46.             e.printStackTrace();
  47.         }
  48.     }
  49. }
  1. **消费者2**
  2. package com.qbb.topic;
  4. import com.qbb.utils.MQUtil;
  5. import com.rabbitmq.client.*;
  7. import java.io.IOException;
  9. /**
  10.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  11.  * @version 1.0
  12.  * @date 2022-03-28  20:36
  13.  * @Description:
  14.  */
  15. public class TopicConsumer2 {
  16.     public static void main(String[] args) {
  17.         try {
  18.             // 获取连接
  19.             Connection connection = MQUtil.getConnection();
  20.             // 获取channel通道
  21.             Channel channel = connection.createChannel();
  22.             // 声明队列
  23.             channel.queueDeclare("topic-queue2", false, false, false, null);
  24.             // 将队列绑定到交换机
  25.             /**
  26.              * 参数1:队列名称
  27.              * 参数2:交换机名称
  28.              * 参数3:路由key
  29.              */
  30.             channel.queueBind("topic-queue2", "topic-exchange", "item.*");
  31.             channel.queueBind("topic-queue2", "topic-exchange", "#.delete");
  33.             Consumer consumer = new DefaultConsumer(channel) {
  34.                 @Override
  35.                 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  36.                     System.out.println("消费者唯一标识 = " + consumerTag);
  37.                     System.out.println("交换机名称 = " + envelope.getExchange());
  38.                     System.out.println("消息唯一标识 = " + envelope.getDeliveryTag());
  39.                     System.out.println("路由key = " + envelope.getRoutingKey());
  41.                     System.out.println("消费者2消费消息Message = " + new String(body));
  42.                 }
  43.             };
  44.             channel.basicConsume("topic-queue2", true, consumer);
  45.         } catch (Exception e) {
  46.             e.printStackTrace();
  47.         }
  48.     }
  49. }

测试结果:

Topic 主题模式可以实现 Publish/Subscribe 发布与订阅模式 和 Routing 路 由模式 的功能；只是 Topic 在配置 routing key 的时候可以使用通配符，显得更加灵 活。

11.持久化(避免消息丢失)

为了避免消息丢失,我们可以将消息持久化!如何持久化消息呢?

要将消息持久化，前提是：队列、Exchange 都持久化

1.持久化交换机

  1. /**
  2. * 参数1:交换机名
  3. * 参数2:交换机类型
  4. * 参数3:是否持久化
  5. */
  6. channel.exchangeDeclare("topic-exchange", "topic",true);

2.持久化队列

  1. // 声明队列
  2. channel.queueDeclare("topic-queue1", true, false, false, null);

3.持久化消息

  1. channel.basicPublish("topic-exchange", "item.update.do", MessageProperties.PERSISTENT_TEXT_PLAIN, message2.getBytes());

12.RabbitMQ 工作模式总结

  • 1、简单模式 HelloWorld 一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）
  • 2、工作队列模式 Work Queue 一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）
  • 3、发布订阅模式 Publish/subscribe 需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定，当发送消息到交换机后， 交换机会将消息发送到绑定的队列
  • 4、路由模式 Routing 需要设置类型为 direct 的交换机，交换机和队列进行绑定，并且指定 routing key，当 发送消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列
  • 5、通配符模式 Topic 需要设置类型为 topic 的交换机，交换机和队列进行绑定，并且指定通配符方式的 routing key，当发送消息到交换机后，交换机会根据 routing key 将消息发送到对应 的队列 消息的可靠性投递 RabbitMQ 集群 消息百分百投递（confirm 和 return、消费者确认 ack 机制）

13.Spring 整合 RabbitMQ(简单模式)

前面我们使用java代码操作了RabbitMQ,其实操作起来感觉还是有点繁琐,下面使用Spring来整合RabbitMQ,看看能否有不一样的体验

先写producer消息提供方

1.创建一个maven项目

2.导入相关依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.qbb</groupId>
  8.     <artifactId>spring-mq-producer</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>org.springframework</groupId>
  14.             <artifactId>spring-context</artifactId>
  15.             <version>5.3.16</version>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>org.springframework.amqp</groupId>
  19.             <artifactId>spring-rabbit</artifactId>
  20.             <version>2.4.2</version>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>junit</groupId>
  24.             <artifactId>junit</artifactId>
  25.             <version>4.13.2</version>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework</groupId>
  29.             <artifactId>spring-test</artifactId>
  30.             <version>5.3.16</version>
  31.         </dependency>
  32.     </dependencies>
  33. </project>

3.编写rabbitmq.properties配置文件

  1. rabbitmq.host=192.168.137.72
  2. rabbitmq.port=5672
  3. rabbitmq.username=qbb
  4. rabbitmq.password=qbb
  5. rabbitmq.virtual-host=/

4.编写spring-rabbitmq-producer.xml配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.     <!--加载rabbitmq.properties-->
  8.     <context:property-placeholder location="classpath:rabbitmq.properties"/>
  10.     <!--配置连接工厂-->
  11.     <rabbit:connection-factory
  12.             id="connectionFactory"
  13.             host="${rabbitmq.host}"
  14.             port="${rabbitmq.port}"
  15.             username="${rabbitmq.username}"
  16.             password="${rabbitmq.password}"
  17.             virtual-host="${rabbitmq.virtual-host}"/>
  19.     <!--配置监听器-->
  20.     <bean id="simpleListener" class="com.qbb.listener.SimpleListener"/>
  22.     <!--将监听器放入rabbit容器-->
  23.     <rabbit:listener-container connection-factory="connectionFactory">
  24.         <rabbit:listener ref="simpleListener" queue-names="spring-simple-queue"/>
  25.     </rabbit:listener-container>
  27. </beans>

5.在test测试包下创建测试类

  1. package com.qbb;
  3. import org.junit.Test;
  4. import org.junit.runner.RunWith;
  5. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.test.context.ContextConfiguration;
  8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  10. /**
  11.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  12.  * @version 1.0
  13.  * @date 2022-03-28  23:56
  14.  * @Description:
  15.  */
  16. @RunWith(SpringJUnit4ClassRunner.class)
  17. @ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
  18. public class MQTest {
  20.     @Autowired
  21.     private RabbitTemplate rabbitTemplate;
  23.     @Test
  24.     public void testSimple() {
  25.         rabbitTemplate.convertAndSend("spring-simple-queue", "hello QiuQiu Spring-MQ-Simple");
  26.     }
  27. }

再写consumer消息消费方

1.创建一个maven项目

2.导入相关依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.qbb</groupId>
  8.     <artifactId>spring-mq-producer</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>org.springframework</groupId>
  14.             <artifactId>spring-context</artifactId>
  15.             <version>5.3.16</version>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>org.springframework.amqp</groupId>
  19.             <artifactId>spring-rabbit</artifactId>
  20.             <version>2.4.2</version>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>junit</groupId>
  24.             <artifactId>junit</artifactId>
  25.             <version>4.13.2</version>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework</groupId>
  29.             <artifactId>spring-test</artifactId>
  30.             <version>5.3.16</version>
  31.         </dependency>
  32.     </dependencies>
  33. </project>

3.编写rabbitmq.properties配置文件

  1. rabbitmq.host=192.168.137.72
  2. rabbitmq.port=5672
  3. rabbitmq.username=qbb
  4. rabbitmq.password=qbb
  5. rabbitmq.virtual-host=/

4.编写spring-rabbitmq-producer.xml配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.     <!--加载rabbitmq.properties-->
  8.     <context:property-placeholder location="classpath:rabbitmq.properties"/>
  10.     <!--配置连接工厂-->
  11.     <rabbit:connection-factory
  12.             id="connectionFactory"
  13.             host="${rabbitmq.host}"
  14.             port="${rabbitmq.port}"
  15.             username="${rabbitmq.username}"
  16.             password="${rabbitmq.password}"
  17.             virtual-host="${rabbitmq.virtual-host}"/>
  19.     <!--RabbitAdmin 用于远程创建、管理交换机、队列-->
  20.     <rabbit:admin connection-factory="connectionFactory"/>
  22.     <!--声明队列：
  23.         id 属性方便下面引用(当然 id 属性可以省略，通过 name 属性引用也行)
  24.         name 属性执行创建队列的名称(name 属性不可省略,否则无法定义队列名称)，
  25.         auto-declare 属性为 true 表示不存在则自动创建-->
  26.     <rabbit:queue id="spring-queue" name="spring-queue" auto-declare="true"></rabbit:queue>
  28.     <!--定义 rabbitTemplate 对象操作可以在代码中方便发送消息-->
  29.     <rabbit:template connection-factory="connectionFactory" id="rabbitTemplate"/>
  31.     <!--==================简单模式==================-->
  32.     <rabbit:queue id="spring-simple-queue" name="spring-simple-queue" durable="false" auto-delete="false" auto-declare="true"/>
  33. </beans>

5.创建一个SimpleListener监听类实现MessageListener监听消息

  1. package com.qbb.listener;
  3. import org.springframework.amqp.core.Message;
  4. import org.springframework.amqp.core.MessageListener;
  6. /**
  7.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  8.  * @version 1.0
  9.  * @date 2022-03-29  0:09
  10.  * @Description:简单模式
  11.  */
  12. public class SimpleListener implements MessageListener {
  13.     @Override
  14.     public void onMessage(Message message) {
  15.         System.out.println("消费者唯一标识 =" + message.getMessageProperties().getConsumerTag());
  16.         System.out.println("消息唯一标识 =" + message.getMessageProperties().getDeliveryTag());
  17.         System.out.println("交换机名称 =" + message.getMessageProperties().getReceivedExchange());
  18.         System.out.println("路由key =" + message.getMessageProperties().getReceivedRoutingKey());
  20.         System.out.println("消息 =" + new String(message.getBody()));
  21.     }
  22. }

6.在test测试包下创建测试类

  1. package com.qbb;
  3. import org.junit.Test;
  4. import org.junit.runner.RunWith;
  5. import org.springframework.test.context.ContextConfiguration;
  6. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  8. /**
  9.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  10.  * @version 1.0
  11.  * @date 2022-03-29  0:14
  12.  * @Description:
  13.  */
  14. @RunWith(SpringJUnit4ClassRunner.class)
  15. @ContextConfiguration(locations = "classpath:spring-rabbitmq-consumer.xml")
  16. public class MQTest {
  18.     @Test
  19.     public void test01() {
  20.         while (true) {
  22.         }
  23.     }
  24. }

测试结果:

13.Spring 整合 RabbitMQ(工作队列模式)

1.修改spring-rabbitmq-producer.xml配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.     <!--加载rabbitmq.properties-->
  8.     <context:property-placeholder location="classpath:rabbitmq.properties"/>
  10.     <!--配置连接工厂-->
  11.     <rabbit:connection-factory
  12.             id="connectionFactory"
  13.             host="${rabbitmq.host}"
  14.             port="${rabbitmq.port}"
  15.             username="${rabbitmq.username}"
  16.             password="${rabbitmq.password}"
  17.             virtual-host="${rabbitmq.virtual-host}"/>
  19.     <!--RabbitAdmin 用于远程创建、管理交换机、队列-->
  20.     <rabbit:admin connection-factory="connectionFactory"/>
  22.     <!--声明队列：
  23.         id 属性方便下面引用(当然 id 属性可以省略，通过 name 属性引用也行)
  24.         name 属性执行创建队列的名称(name 属性不可省略,否则无法定义队列名称)，
  25.         auto-declare 属性为 true 表示不存在则自动创建-->
  26.     <rabbit:queue id="spring-queue" name="spring-queue" auto-declare="true"></rabbit:queue>
  28.     <!--定义 rabbitTemplate 对象操作可以在代码中方便发送消息-->
  29.     <rabbit:template connection-factory="connectionFactory" id="rabbitTemplate"/>
  31.     <!--==================简单模式==================-->
  32.     <rabbit:queue id="spring-simple-queue" name="spring-simple-queue" durable="false" auto-delete="false" auto-declare="true"/>
  34.     <!--==================工作队列模式==================-->
  35.     <rabbit:queue id="spring-work-queue" name="spring-work-queue" durable="false" auto-delete="false" auto-declare="true"/>
  36. </beans>

2.修改producer测试类

  1. package com.qbb;
  3. import org.junit.Test;
  4. import org.junit.runner.RunWith;
  5. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.test.context.ContextConfiguration;
  8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  10. /**
  11.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  12.  * @version 1.0
  13.  * @date 2022-03-28  23:56
  14.  * @Description:
  15.  */
  16. @RunWith(SpringJUnit4ClassRunner.class)
  17. @ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
  18. public class MQTest {
  20.     @Autowired
  21.     private RabbitTemplate rabbitTemplate;
  23.     /**
  24.      * 简单模式
  25.      */
  26.     @Test
  27.     public void testSimple() {
  28.         rabbitTemplate.convertAndSend("spring-simple-queue", "hello QiuQiu Spring-MQ-Simple");
  29.     }
  31.     /**
  32.      * 工作队列模式
  33.      */
  34.     @Test
  35.     public void testWorkQueue() {
  36.         for (int i = 0; i < 10; i++) {
  37.             rabbitTemplate.convertAndSend("spring-work-queue", "hello QiuQiu Spring-MQ-WorkQueue"+i);
  38.         }
  39.     }
  40. }

3.修改spring-rabbitmq-consumer.xml配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.     <!--加载rabbitmq.properties-->
  8.     <context:property-placeholder location="classpath:rabbitmq.properties"/>
  10.     <!--配置连接工厂-->
  11.     <rabbit:connection-factory
  12.             id="connectionFactory"
  13.             host="${rabbitmq.host}"
  14.             port="${rabbitmq.port}"
  15.             username="${rabbitmq.username}"
  16.             password="${rabbitmq.password}"
  17.             virtual-host="${rabbitmq.virtual-host}"/>
  19.     <!--配置监听器-->
  20.     <!--简单模式-->
  21.     <bean id="simpleListener" class="com.qbb.listener.SimpleListener"/>
  22.     <!--工作队列模式-->
  23.     <bean id="workQueueListener1" class="com.qbb.listener.WorkQueueListener1"/>
  24.     <bean id="workQueueListener2" class="com.qbb.listener.WorkQueueListener2"/>
  26.     <!--将监听器放入rabbit容器-->
  27.     <rabbit:listener-container connection-factory="connectionFactory">
  28.         <!--简单模式-->
  29.         <rabbit:listener ref="simpleListener" queue-names="spring-simple-queue"/>
  30.         <!--工作队列模式-->
  31.         <rabbit:listener ref="workQueueListener1" queue-names="spring-work-queue"/>
  32.         <rabbit:listener ref="workQueueListener2" queue-names="spring-work-queue"/>
  33.     </rabbit:listener-container>
  35. </beans>

4.创建两个监听类

  1. package com.qbb.listener;
  3. import org.springframework.amqp.core.Message;
  4. import org.springframework.amqp.core.MessageListener;
  6. /**
  7.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  8.  * @version 1.0
  9.  * @date 2022-03-29  0:09
  10.  * @Description:消息队列模式
  11.  */
  12. public class WorkQueueListener2 implements MessageListener {
  13.     @Override
  14.     public void onMessage(Message message) {
  15.         System.out.println("消费者2唯一标识 =" + message.getMessageProperties().getConsumerTag());
  16.         System.out.println("消费者2消息唯一标识 =" + message.getMessageProperties().getDeliveryTag());
  17.         System.out.println("消费者2交换机名称 =" + message.getMessageProperties().getReceivedExchange());
  18.         System.out.println("消费者2路由key =" + message.getMessageProperties().getReceivedRoutingKey());
  20.         System.out.println("消费者2消费的消息 =" + new String(message.getBody()));
  21.     }
  22. }
  24. ------------
  26. package com.qbb.listener;
  28. import org.springframework.amqp.core.Message;
  29. import org.springframework.amqp.core.MessageListener;
  31. /**
  32.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  33.  * @version 1.0
  34.  * @date 2022-03-29  0:09
  35.  * @Description:消息队列模式
  36.  */
  37. public class WorkQueueListener1 implements MessageListener {
  38.     @Override
  39.     public void onMessage(Message message) {
  40.         System.out.println("消费者1唯一标识 =" + message.getMessageProperties().getConsumerTag());
  41.         System.out.println("消费者1消息唯一标识 =" + message.getMessageProperties().getDeliveryTag());
  42.         System.out.println("消费者1交换机名称 =" + message.getMessageProperties().getReceivedExchange());
  43.         System.out.println("消费者1路由key =" + message.getMessageProperties().getReceivedRoutingKey());
  45.         System.out.println("消费者1消费的消息 =" + new String(message.getBody()));
  46.     }
  47. }

执行测试类测试结果:

  1. 消费者1唯一标识 =amq.ctag-Jh86rHgn7_CftQS9Klseew
  2. 消费者1消息唯一标识 =1
  3. 消费者1交换机名称 =
  4. 消费者1路由key =spring-work-queue
  5. 消费者2唯一标识 =amq.ctag-CP-q5LpFxWo9RY4yOpgMGQ
  6. 消费者2消息唯一标识 =1
  7. 消费者2交换机名称 =
  8. 消费者1消费的消息 =hello QiuQiu Spring-MQ-WorkQueue0
  9. 消费者2路由key =spring-work-queue
  10. 消费者2消费的消息 =hello QiuQiu Spring-MQ-WorkQueue1
  11. 消费者2唯一标识 =amq.ctag-CP-q5LpFxWo9RY4yOpgMGQ
  12. 消费者2消息唯一标识 =2
  13. 消费者2交换机名称 =
  14. 消费者2路由key =spring-work-queue
  15. 消费者2消费的消息 =hello QiuQiu Spring-MQ-WorkQueue3
  16. 消费者2唯一标识 =amq.ctag-CP-q5LpFxWo9RY4yOpgMGQ
  17. 消费者2消息唯一标识 =3
  18. 消费者2交换机名称 =
  19. 消费者2路由key =spring-work-queue
  20. 消费者2消费的消息 =hello QiuQiu Spring-MQ-WorkQueue5
  21. 消费者2唯一标识 =amq.ctag-CP-q5LpFxWo9RY4yOpgMGQ
  22. 消费者2消息唯一标识 =4
  23. 消费者2交换机名称 =
  24. 消费者2路由key =spring-work-queue
  25. 消费者2消费的消息 =hello QiuQiu Spring-MQ-WorkQueue7
  26. 消费者2唯一标识 =amq.ctag-CP-q5LpFxWo9RY4yOpgMGQ
  27. 消费者2消息唯一标识 =5
  28. 消费者2交换机名称 =
  29. 消费者2路由key =spring-work-queue
  30. 消费者2消费的消息 =hello QiuQiu Spring-MQ-WorkQueue9
  31. 消费者1唯一标识 =amq.ctag-Jh86rHgn7_CftQS9Klseew
  32. 消费者1消息唯一标识 =2
  33. 消费者1交换机名称 =
  34. 消费者1路由key =spring-work-queue
  35. 消费者1消费的消息 =hello QiuQiu Spring-MQ-WorkQueue2
  36. 消费者1唯一标识 =amq.ctag-Jh86rHgn7_CftQS9Klseew
  37. 消费者1消息唯一标识 =3
  38. 消费者1交换机名称 =
  39. 消费者1路由key =spring-work-queue
  40. 消费者1消费的消息 =hello QiuQiu Spring-MQ-WorkQueue4
  41. 消费者1唯一标识 =amq.ctag-Jh86rHgn7_CftQS9Klseew
  42. 消费者1消息唯一标识 =4
  43. 消费者1交换机名称 =
  44. 消费者1路由key =spring-work-queue
  45. 消费者1消费的消息 =hello QiuQiu Spring-MQ-WorkQueue6
  46. 消费者1唯一标识 =amq.ctag-Jh86rHgn7_CftQS9Klseew
  47. 消费者1消息唯一标识 =5
  48. 消费者1交换机名称 =
  49. 消费者1路由key =spring-work-queue
  50. 消费者1消费的消息 =hello QiuQiu Spring-MQ-WorkQueue8

可以看出10条消息平均分配个两个消费者

14.Spring 整合 RabbitMQ(发布订阅模式,routing(路由模式),topic模式),这里我就把三种情况写一起啦,代码和配置文件中都有详细的注释.不然太长了阅读也不方便

spring-rabbitmq-producer.xml配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.     <!--加载rabbitmq.properties-->
  8.     <context:property-placeholder location="classpath:rabbitmq.properties"/>
  10.     <!--配置连接工厂-->
  11.     <rabbit:connection-factory
  12.             id="connectionFactory"
  13.             host="${rabbitmq.host}"
  14.             port="${rabbitmq.port}"
  15.             username="${rabbitmq.username}"
  16.             password="${rabbitmq.password}"
  17.             virtual-host="${rabbitmq.virtual-host}"/>
  19.     <!--RabbitAdmin 用于远程创建、管理交换机、队列-->
  20.     <rabbit:admin connection-factory="connectionFactory"/>
  22.     <!--声明队列：
  23.         id 属性方便下面引用(当然 id 属性可以省略，通过 name 属性引用也行)
  24.         name 属性执行创建队列的名称(name 属性不可省略,否则无法定义队列名称)，
  25.         auto-declare 属性为 true 表示不存在则自动创建-->
  26.     <rabbit:queue id="spring-queue" name="spring-queue" auto-declare="true"></rabbit:queue>
  28.     <!--定义 rabbitTemplate 对象操作可以在代码中方便发送消息-->
  29.     <rabbit:template connection-factory="connectionFactory" id="rabbitTemplate"/>
  31.     <!--==================简单模式==================-->
  32.     <rabbit:queue id="spring-simple-queue" name="spring-simple-queue" durable="false" auto-delete="false" auto-declare="true"/>
  34.     <!--==================工作队列模式==================-->
  35.     <rabbit:queue id="spring-work-queue" name="spring-work-queue" durable="false" auto-delete="false" auto-declare="true"/>
  37.     <!--==================发布订阅模式==================-->
  38.     <rabbit:queue id="spring-fanout-queue1" name="spring-fanout-queue1" durable="false" auto-delete="false" auto-declare="true"/>
  39.     <rabbit:queue id="spring-fanout-queue2" name="spring-fanout-queue2" durable="false" auto-delete="false" auto-declare="true"/>
  41.     <!--创建交换机-->
  42.     <rabbit:fanout-exchange name="spring-fanout-exchange">
  43.         <!--绑定队列-->
  44.         <rabbit:bindings>
  45.             <rabbit:binding queue="spring-fanout-queue1"/>
  46.             <rabbit:binding queue="spring-fanout-queue2"/>
  47.         </rabbit:bindings>
  48.     </rabbit:fanout-exchange>
  50.     <!--==================routing模式==================-->
  51.     <rabbit:queue id="spring-routing-queue1" name="spring-routing-queue1" durable="false" auto-delete="false" auto-declare="true"/>
  52.     <rabbit:queue id="spring-routing-queue2" name="spring-routing-queue2" durable="false" auto-delete="false" auto-declare="true"/>
  54.     <!--创建交换机-->
  55.     <rabbit:direct-exchange name="spring-routing-exchange">
  56.         <!--绑定队列-->
  57.         <rabbit:bindings>
  58.             <rabbit:binding queue="spring-routing-queue1" key="error"/>
  60.             <rabbit:binding queue="spring-routing-queue2" key="error"/>
  61.             <rabbit:binding queue="spring-routing-queue2" key="info"/>
  62.             <rabbit:binding queue="spring-routing-queue2" key="warning"/>
  63.         </rabbit:bindings>
  64.     </rabbit:direct-exchange>
  66.     <!--==================topic模式==================-->
  67.     <rabbit:queue id="spring-topic-queue1" name="spring-topic-queue1" durable="false" auto-delete="false" auto-declare="true"/>
  68.     <rabbit:queue id="spring-topic-queue2" name="spring-topic-queue2" durable="false" auto-delete="false" auto-declare="true"/>
  70.     <!--创建交换机-->
  71.     <rabbit:topic-exchange name="spring-topic-exchange">
  72.         <!--绑定队列-->
  73.         <rabbit:bindings>
  74.             <rabbit:binding pattern="*.orange.*" queue="spring-topic-queue1"></rabbit:binding>
  76.             <rabbit:binding pattern="*.*.rabbit" queue="spring-topic-queue2"></rabbit:binding>
  77.             <rabbit:binding pattern="lazy.#" queue="spring-topic-queue2"></rabbit:binding>
  78.         </rabbit:bindings>
  79.     </rabbit:topic-exchange>
  81. </beans>

producer生产者的MQTest.java

  1. package com.qbb;
  3. import org.junit.Test;
  4. import org.junit.runner.RunWith;
  5. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.test.context.ContextConfiguration;
  8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  10. /**
  11.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  12.  * @version 1.0
  13.  * @date 2022-03-28  23:56
  14.  * @Description:
  15.  */
  16. @RunWith(SpringJUnit4ClassRunner.class)
  17. @ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
  18. public class MQTest {
  20.     @Autowired
  21.     private RabbitTemplate rabbitTemplate;
  23.     /**
  24.      * 简单模式
  25.      */
  26.     @Test
  27.     public void testSimple() {
  28.         rabbitTemplate.convertAndSend("spring-simple-queue", "hello QiuQiu Spring-MQ-Simple");
  29.     }
  31.     /**
  32.      * 工作队列模式
  33.      */
  34.     @Test
  35.     public void testWorkQueue() {
  36.         for (int i = 0; i < 10; i++) {
  37.             rabbitTemplate.convertAndSend("spring-work-queue", "hello QiuQiu Spring-MQ-WorkQueue" + i);
  38.         }
  39.     }
  41.     /**
  42.      * 发布订阅模式
  43.      */
  44.     @Test
  45.     public void testFanout() {
  46.         rabbitTemplate.convertSendAndReceive("spring-fanout-exchange", "", "hello QiuQiu Spring-MQ-PubSub");
  47.     }
  49.     /**
  50.      * routing模式
  51.      */
  52.     @Test
  53.     public void testRouting() {
  54.         rabbitTemplate.convertSendAndReceive("spring-routing-exchange", "error", "hello QiuQiu Spring-MQ-Routing-AAA");
  55.         rabbitTemplate.convertSendAndReceive("spring-routing-exchange", "info", "hello QiuQiu Spring-MQ-Routing-BBB");
  56.     }
  58.     /**
  59.      * topic模式
  60.      */
  61.     @Test
  62.     public void testTopic() {
  63.         rabbitTemplate.convertSendAndReceive("spring-topic-exchange", "lazy.orange.qiu", "hello QiuQiu Spring-MQ-Topic-AAA");
  64.         rabbitTemplate.convertSendAndReceive("spring-topic-exchange", "qiu.ll.rabbit", "hello QiuQiu Spring-MQ-Topic-BBB");
  65.     }
  66. }

spring-rabbitmq-consumer.xml配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.     <!--加载rabbitmq.properties-->
  8.     <context:property-placeholder location="classpath:rabbitmq.properties"/>
  10.     <!--配置连接工厂-->
  11.     <rabbit:connection-factory
  12.             id="connectionFactory"
  13.             host="${rabbitmq.host}"
  14.             port="${rabbitmq.port}"
  15.             username="${rabbitmq.username}"
  16.             password="${rabbitmq.password}"
  17.             virtual-host="${rabbitmq.virtual-host}"/>
  19.     <!--配置监听器-->
  20.     <!--简单模式-->
  21.     <bean id="simpleListener" class="com.qbb.listener.SimpleListener"/>
  23.     <!--工作队列模式-->
  24.     <bean id="workQueueListener1" class="com.qbb.listener.WorkQueueListener1"/>
  25.     <bean id="workQueueListener2" class="com.qbb.listener.WorkQueueListener2"/>
  27.     <!--发布订阅模式-->
  28.     <bean id="fanoutListener1" class="com.qbb.listener.FanoutListener1"/>
  29.     <bean id="fanoutListener2" class="com.qbb.listener.FanoutListener2"/>
  31.     <!--routing模式-->
  32.     <bean id="routingListener1" class="com.qbb.listener.RoutingListener1"/>
  33.     <bean id="routingListener2" class="com.qbb.listener.RoutingListener2"/>
  35.     <!--topic模式-->
  36.     <bean id="topicListener1" class="com.qbb.listener.TopicListener1"/>
  37.     <bean id="topicListener2" class="com.qbb.listener.TopicListener2"/>
  39.     <!--将监听器放入rabbit容器-->
  40.     <rabbit:listener-container connection-factory="connectionFactory">
  41.         <!--简单模式-->
  42.         <rabbit:listener ref="simpleListener" queue-names="spring-simple-queue"/>
  44.         <!--工作队列模式-->
  45.         <rabbit:listener ref="workQueueListener1" queue-names="spring-work-queue"/>
  46.         <rabbit:listener ref="workQueueListener2" queue-names="spring-work-queue"/>
  48.         <!--发布订阅模式-->
  49.         <rabbit:listener ref="fanoutListener1" queue-names="spring-fanout-queue1"/>
  50.         <rabbit:listener ref="fanoutListener2" queue-names="spring-fanout-queue2"/>
  52.         <!--routing模式-->
  53.         <rabbit:listener ref="routingListener1" queue-names="spring-routing-queue1"/>
  54.         <rabbit:listener ref="routingListener2" queue-names="spring-routing-queue2"/>
  56.         <!--topic模式-->
  57.         <rabbit:listener ref="topicListener1" queue-names="spring-topic-queue1"/>
  58.         <rabbit:listener ref="topicListener2" queue-names="spring-topic-queue2"/>
  59.     </rabbit:listener-container>
  61. </beans>

FanoutListener1监听器

  1. package com.qbb.listener;
  3. import org.springframework.amqp.core.Message;
  4. import org.springframework.amqp.core.MessageListener;
  6. /**
  7.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  8.  * @version 1.0
  9.  * @date 2022-03-29  0:09
  10.  * @Description:发布订阅模式
  11.  */
  12. public class FanoutListener1 implements MessageListener {
  13.     @Override
  14.     public void onMessage(Message message) {
  15.         System.out.println("消费者1唯一标识 =" + message.getMessageProperties().getConsumerTag());
  16.         System.out.println("消费者1消息唯一标识 =" + message.getMessageProperties().getDeliveryTag());
  17.         System.out.println("消费者1交换机名称 =" + message.getMessageProperties().getReceivedExchange());
  18.         System.out.println("消费者1路由key =" + message.getMessageProperties().getReceivedRoutingKey());
  20.         System.out.println("消费者1消费的消息 =" + new String(message.getBody()));
  21.     }
  22. }

FanoutListener2监听器

  1. package com.qbb.listener;
  3. import org.springframework.amqp.core.Message;
  4. import org.springframework.amqp.core.MessageListener;
  6. /**
  7.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  8.  * @version 1.0
  9.  * @date 2022-03-29  0:09
  10.  * @Description:发布订阅模式
  11.  */
  12. public class FanoutListener2 implements MessageListener {
  13.     @Override
  14.     public void onMessage(Message message) {
  15.         System.out.println("消费者2唯一标识 =" + message.getMessageProperties().getConsumerTag());
  16.         System.out.println("消费者2消息唯一标识 =" + message.getMessageProperties().getDeliveryTag());
  17.         System.out.println("消费者2交换机名称 =" + message.getMessageProperties().getReceivedExchange());
  18.         System.out.println("消费者2路由key =" + message.getMessageProperties().getReceivedRoutingKey());
  20.         System.out.println("消费者2消费的消息 =" + new String(message.getBody()));
  21.     }
  22. }

RoutingListener1监听器

  1. package com.qbb.listener;
  3. import org.springframework.amqp.core.Message;
  4. import org.springframework.amqp.core.MessageListener;
  6. /**
  7.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  8.  * @version 1.0
  9.  * @date 2022-03-29  0:09
  10.  * @Description:routing模式
  11.  */
  12. public class RoutingListener1 implements MessageListener {
  13.     @Override
  14.     public void onMessage(Message message) {
  15.         System.out.println("消费者1唯一标识 =" + message.getMessageProperties().getConsumerTag());
  16.         System.out.println("消费者1消息唯一标识 =" + message.getMessageProperties().getDeliveryTag());
  17.         System.out.println("消费者1交换机名称 =" + message.getMessageProperties().getReceivedExchange());
  18.         System.out.println("消费者1路由key =" + message.getMessageProperties().getReceivedRoutingKey());
  20.         System.out.println("消费者1消费的消息 =" + new String(message.getBody()));
  21.     }
  22. }

RoutingListener2监听器

  1. package com.qbb.listener;
  3. import org.springframework.amqp.core.Message;
  4. import org.springframework.amqp.core.MessageListener;
  6. /**
  7.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  8.  * @version 1.0
  9.  * @date 2022-03-29  0:09
  10.  * @Description:routing模式
  11.  */
  12. public class RoutingListener2 implements MessageListener {
  13.     @Override
  14.     public void onMessage(Message message) {
  15.         System.out.println("消费者2唯一标识 =" + message.getMessageProperties().getConsumerTag());
  16.         System.out.println("消费者2消息唯一标识 =" + message.getMessageProperties().getDeliveryTag());
  17.         System.out.println("消费者2交换机名称 =" + message.getMessageProperties().getReceivedExchange());
  18.         System.out.println("消费者2路由key =" + message.getMessageProperties().getReceivedRoutingKey());
  20.         System.out.println("消费者2消费的消息 =" + new String(message.getBody()));
  21.     }
  22. }

TopicListener1监听器

  1. package com.qbb.listener;
  3. import org.springframework.amqp.core.Message;
  4. import org.springframework.amqp.core.MessageListener;
  6. /**
  7.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  8.  * @version 1.0
  9.  * @date 2022-03-29  0:09
  10.  * @Description:topic模式
  11.  */
  12. public class TopicListener1 implements MessageListener {
  13.     @Override
  14.     public void onMessage(Message message) {
  15.         System.out.println("消费者1唯一标识 =" + message.getMessageProperties().getConsumerTag());
  16.         System.out.println("消费者1消息唯一标识 =" + message.getMessageProperties().getDeliveryTag());
  17.         System.out.println("消费者1交换机名称 =" + message.getMessageProperties().getReceivedExchange());
  18.         System.out.println("消费者1路由key =" + message.getMessageProperties().getReceivedRoutingKey());
  20.         System.out.println("消费者1消费的消息 =" + new String(message.getBody()));
  21.     }
  22. }

TopicListener2监听器

  1. package com.qbb.listener;
  3. import org.springframework.amqp.core.Message;
  4. import org.springframework.amqp.core.MessageListener;
  6. /**
  7.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  8.  * @version 1.0
  9.  * @date 2022-03-29  0:09
  10.  * @Description:topic模式
  11.  */
  12. public class TopicListener2 implements MessageListener {
  13.     @Override
  14.     public void onMessage(Message message) {
  15.         System.out.println("消费者2唯一标识 =" + message.getMessageProperties().getConsumerTag());
  16.         System.out.println("消费者2消息唯一标识 =" + message.getMessageProperties().getDeliveryTag());
  17.         System.out.println("消费者2交换机名称 =" + message.getMessageProperties().getReceivedExchange());
  18.         System.out.println("消费者2路由key =" + message.getMessageProperties().getReceivedRoutingKey());
  20.         System.out.println("消费者2消费的消息 =" + new String(message.getBody()));
  21.     }
  22. }

consumer消息消费者的MQTest.java

  1. package com.qbb;
  3. import org.junit.Test;
  4. import org.junit.runner.RunWith;
  5. import org.springframework.test.context.ContextConfiguration;
  6. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  8. /**
  9.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  10.  * @version 1.0
  11.  * @date 2022-03-29  0:14
  12.  * @Description:
  13.  */
  14. @RunWith(SpringJUnit4ClassRunner.class)
  15. @ContextConfiguration(locations = "classpath:spring-rabbitmq-consumer.xml")
  16. public class MQTest {
  18.     @Test
  19.     public void test01() {
  20.         while (true) {
  22.         }
  23.     }
  24. }

发布订阅模式测试据结果:

routing路由模式测试结果:

topic模式测试结果:

RabbitMQ 高级特性

15.消息的可靠性投递

在使用 RabbitMQ 的时候，我们当然希望杜绝任何消息丢失或者投递失败情况。 RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式

  • confirm 确认模式
  • return 退回模式

rabbitmq 整个消息投递的路径为:

producer—>rabbitmq broker—>exchange—>queue—>consumer

l.消息从 producer 到 exchange 则会返回一个 confirmCallback 。

2.消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。

confirm 确认模式

修改spring-rabbitmq-producer.xml

  1. <!--配置连接工厂-->
  2.     <rabbit:connection-factory
  3.             id="connectionFactory"
  4.             host="${rabbitmq.host}"
  5.             port="${rabbitmq.port}"
  6.             username="${rabbitmq.username}"
  7.             password="${rabbitmq.password}"
  8.             virtual-host="${rabbitmq.virtual-host}"
  10. 			添加如下两行设置,开启confirm和return模式
  11.             publisher-returns="true"
  12.             confirm-type="CORRELATED"/>

修改测试类MQTest.java

  1. /**
  2.      * topic模式
  3.      */
  4.     @Test
  5.     public void testTopic() {
  6.         // 发送消息之前设置ConfirmCallBack回调方法
  7.         rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
  8.             /**
  9.              * CorrelationData correlationData
  10.              * boolean ack : 当消费者成功把消息发送给交换机 ack=true 发送失败 ack=false
  11.              * String cause : 消息发送失败的原因
  12.              */
  13.             @Override
  14.             public void confirm(CorrelationData correlationData, boolean ack, String cause) {
  15.                 if (ack) {
  16.                     System.out.println("消息发送成功:cause="+cause);
  17.                 }else {
  18. 			// 发送失败我们可以做其他的补救措施,例如发送给其他的交换机
  19.                     System.out.println("消息发送失败:cause=" + cause);
  20.                 }
  21.             }
  22.         });
  23.         rabbitTemplate.convertSendAndReceive("spring-topic-exchange", "lazy.orange.qiu", "hello QiuQiu Spring-MQ-Topic-AAA");
  24.         // rabbitTemplate.convertSendAndReceive("spring-topic-exchange", "qiu.ll.rabbit", "hello QiuQiu Spring-MQ-Topic-BBB");
  25.     }

上面看到的是发送成功的情况,我们把交换机名字故意写错,看看会有什么效果

  1.  rabbitTemplate.convertSendAndReceive("spring-topic-exchange-111", "lazy.orange.qiu", "hello QiuQiu Spring-MQ-Topic-AAA");

return 退回模式

开启return 退回模式支持,上面我们已经开启了

发送消息之前设置ReturnCallBack回调方法

  1. rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
  2.             @Override
  3.             public void returnedMessage(ReturnedMessage returnedMessage) {
  4. 			// 出错了可以指定发送给其他的queue
  5.                 System.out.println("returnedMessage.getExchange() = " + returnedMessage.getExchange());
  6.                 System.out.println("returnedMessage.getMessage() = " + returnedMessage.getMessage());
  7.                 System.out.println("returnedMessage.getReplyCode() = " + returnedMessage.getReplyCode());
  8.                 System.out.println("returnedMessage.getReplyText() = " + returnedMessage.getReplyText());
  9.                 System.out.println("returnedMessage.getRoutingKey() = " + returnedMessage.getRoutingKey());
  10.             }
  11.         });

设置交换机把消息发送给队列失败时,强制把消息回退给消息发送者(默认为false即丢失消息)

  1.  rabbitTemplate.setMandatory(true);

前面两种模式我们是确保了producer->exchange和exchange->queue的消息可靠性,但是我们消息从queue->consumer我们怎么办证消息一定投递成功呢?下面我们就解决一下这个问题

其实也简单,我们只需要关闭自动ACK,然后再处理完业务逻辑后手动ACK即可

  • 修改spring-rabbitmq-consumer.xml
  1. ...
  2. <bean id="manualAckListener" class="com.qbb.listener.ManualAckListener"/>
  3. ...
  4. <rabbit:listener ref="manualAckListener" queue-names="spring-topic-queue1"/>

  • 实现ChannelAwareMessageListener监听器
  1. package com.qbb.listener;
  3. import com.rabbitmq.client.Channel;
  4. import org.springframework.amqp.core.Message;
  5. import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
  7. import java.io.IOException;
  9. /**
  10.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  11.  * @version 1.0
  12.  * @date 2022-03-29  23:27
  13.  * @Description:
  14.  */
  15. public class ManualAckListener implements ChannelAwareMessageListener {
  16.     @Override
  17.     public void onMessage(Message message, Channel channel) throws Exception {
  18.         try {
  19.             System.out.println("消费者消费的消息为:"+new String(message.getBody()));
  21.             // ....业务逻辑... 此处有可能出现异常从而导致消息无法正常手动确认
  23.             // 手动确认
  24.             channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.             /**
  28.              * 参数1: 消息唯一标识
  29.              * 参数2: 是否重新入队列
  30.              */
  31.             // channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
  32.             /**
  33.              * 参数1: 消息唯一标识
  34.              * 参数2: 不需要多个消费与队列确认,只要有一个消费者消费了就证明消息被消费了
  35.              * 参数3: 是否重新入队列,注意如果设置为true则会出现反复死循环般的消费消息
  36.              */
  37.             channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
  38.         }
  39.     }
  40. }

测试结果:消息即可有正常消费,出现错误了也可以进行响应的补救措施,保证了消息从queue->consumer的可靠性

消息可靠性总结

1.持久化 exchange和queue持久化设置: durable="true",Spring整合RabbitMQ消息本身就是持久化的

2.生产方确认 ConfirmCallBack 和 returnCallBack

3.消费方确认 手动Ack

4.Broker 高可用,搭建集群

RabbitMQ 应用性问题

  • 消息百分百投递

假如在发送的过程中出现了网络抖动或者其他的不可逆因素,如何保证消息不丢失呢?

从上图我们可以将要消费的消息存入一个MSGDB的数据库,给它设置一个状态status=0代表未消费,当出现消费成功则修改状态为status=1,如果出现了网络故障status=0我们编写一个定时任务,指定时间把status=0的消息查询出来再次执行即可

上面的定时任务和存入将消息数据库确实可以解决一些问题,但是同时也带来了消息重复消费的问题,也就是消息幂等性问题,如何解决消息幂等性问题呢?

  • 业务ID
  • 乐观锁

16.消费端限流

修改配置文件

  1. prefetch="1"
  1. package com.qbb.listener;
  3. import com.rabbitmq.client.Channel;
  4. import org.springframework.amqp.core.Message;
  5. import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
  7. /**
  8.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  9.  * @version 1.0
  10.  * @date 2022-03-30  0:40
  11.  * @Description:
  12.  */
  13. public class LimitListener1 implements ChannelAwareMessageListener {
  14.     @Override
  15.     public void onMessage(Message message, Channel channel) throws Exception {
  16.         System.out.println("消费者1消息为:" + new String(message.getBody()));
  18.         channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  19.     }
  20. }
  22. package com.qbb.listener;
  24. import com.rabbitmq.client.Channel;
  25. import org.springframework.amqp.core.Message;
  26. import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
  28. /**
  29.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  30.  * @version 1.0
  31.  * @date 2022-03-30  0:40
  32.  * @Description:
  33.  */
  34. public class LimitListener2 implements ChannelAwareMessageListener {
  35.     @Override
  36.     public void onMessage(Message message, Channel channel) throws Exception {
  37.         System.out.println("消费者2消息为:" + new String(message.getBody()));
  39.         channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  40.     }
  41. }

测试结果

17.TTL消息过期时间

控制台方式操作:添加相应的队列设置过期时间,发送消息测试

代码方式操作之指定所有消息过期时间

  1.  <!--==================TTL-QUEUE==================-->
  2.     <rabbit:queue id="ttl-queue1" name="ttl-queue2" auto-declare="true">
  3.         <rabbit:queue-arguments>
  4.             <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"></entry>
  5.         </rabbit:queue-arguments>
  6.     </rabbit:queue>

代码方式操作之指定某个消息过期时间

  1. @Test
  2.     public void testTTL2() {
  3.         MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
  4.             @Override
  5.             public Message postProcessMessage(Message message) throws AmqpException {
  6.                 message.getMessageProperties().setExpiration("10000");
  7.                 return message;
  8.             }
  9.         };
  10.         rabbitTemplate.convertAndSend("ttl-queue2", (Object) "qiuqiu", messagePostProcessor);
  11.     }

注意:RabbitMQ只会检查队列头部的那个信息是否过期,过期及剔除,队列后面的消息即使过期了也不会剔除

18.死信队列

死信，顾名思义就是无法被消费的消息，字面意思可以这 样理解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被 消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列；

消息成为死信的三种情况:

1.队列消息数量到达限制；比如给队列最大只能存储10条消息，当第11条消息进来的时候存 不下了，第1条消息就被称为死信

2.消费者拒接消费消息，basicNack/basicReject，并且不把消息重新放入原目标队列， requeue=false；

3.原队列存在消息过期设置，消息到达超时时间未被消费；

  1. <!--==================正常QUEUE EXCHANGE==================-->
  2.     <rabbit:queue id="normal-queue" name="normal-queue">
  3.         <rabbit:queue-arguments>
  4.             <!--绑定死信交换机-->
  5.             <entry key="x-dead-letter-exchange" value="dead-exchange"/>
  6.             <!--绑定routing-key-->
  7.             <entry key="x-dead-letter-routing-key" value="b.c"/>
  8.             <!--设置消息容量-->
  9.             <entry key="x-max-length" value="10" value-type="java.lang.Integer"/>
  10.             <!--统一的过期时间-->
  11.             <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"/>
  12.         </rabbit:queue-arguments>
  13.     </rabbit:queue>
  14.     <rabbit:topic-exchange name="normal-exchange">
  15.         <rabbit:bindings>
  16.             <rabbit:binding pattern="a.#" queue="normal-queue"></rabbit:binding>
  17.         </rabbit:bindings>
  18.     </rabbit:topic-exchange>
  20.     <!--==================死信QUEUE EXCHANGE==================-->
  21.     <rabbit:queue id="dead-queue" name="dead-queue"/>
  22.     <rabbit:topic-exchange name="dead-exchange">
  23.         <rabbit:bindings>
  24.             <rabbit:binding pattern="b.#" queue="dead-queue"></rabbit:binding>
  25.         </rabbit:bindings>
  26.     </rabbit:topic-exchange>
  1. @Test
  2.     public void testDeadQueue() {
  3.         for (int i = 0; i < 12; i++) {
  4.             rabbitTemplate.convertAndSend("normal-exchange", "a.qiu","qiuqiu" + i);
  5.         }
  6.     }

19.延迟队列

代码配置方式和上面的一样,就是把正常队列设置了一个消息过期时间

20.SpringBoot整合RabbitMQ

生产者:

到入依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <parent>
  8.         <groupId>org.springframework.boot</groupId>
  9.         <artifactId>spring-boot-starter-parent</artifactId>
  10.         <version>2.6.4</version>
  11.     </parent>
  13.     <groupId>com.qbb</groupId>
  14.     <artifactId>springboot-mq-producer</artifactId>
  15.     <version>1.0-SNAPSHOT</version>
  17.     <dependencies>
  18.         <dependency>
  19.             <groupId>org.springframework.boot</groupId>
  20.             <artifactId>spring-boot-starter-web</artifactId>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-amqp</artifactId>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-starter-test</artifactId>
  29.         </dependency>
  30.     </dependencies>
  32. </project>

编写配置类

  1. package com.qbb.mq.config;
  3. import org.springframework.amqp.core.*;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.boot.SpringBootConfiguration;
  6. import org.springframework.context.annotation.Bean;
  8. /**
  9.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  10.  * @version 1.0
  11.  * @date 2022-03-30  1:56
  12.  * @Description:
  13.  */
  14. @SpringBootConfiguration
  15. public class MQProducerConfig {
  16.     public static final String EXCHANGE_NAME = "boot_topic_exchange";
  17.     public static final String QUEUE_NAME = "boot_queue";
  19.     //1.交换机
  20.     @Bean("bootExchange")
  21.     public Exchange bootExchange() {
  22.         return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
  23.     }
  25.     //2.Queue 队列
  26.     @Bean("bootQueue")
  27.     public Queue bootQueue() {
  28.         return QueueBuilder.durable(QUEUE_NAME).build();
  29.     }
  31.     //3. 队列和交互机绑定关系 Binding
  32.     /* 1. 知道哪个队列 2. 知道哪个交换机 3. routing key */
  33.     @Bean
  34.     public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue, @Qualifier("bootExchange") Exchange exchange) {
  35.         return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
  36.     }
  37. }

测试一下

  1. package com.qbb.mq;
  3. import org.junit.jupiter.api.Test;
  4. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.test.context.SpringBootTest;
  8. /**
  9.  * @author QiuQiu&LL (个人博客:https://www.cnblogs.com/qbbit)
  10.  * @version 1.0
  11.  * @date 2022-03-30  1:58
  12.  * @Description:
  13.  */
  14. @SpringBootTest
  15. public class ProducerTest {
  17.     @Autowired
  18.     private RabbitTemplate rabbitTemplate;
  20.     @Test
  21.     public void test01() {
  22.         rabbitTemplate.convertSendAndReceive("boot_topic_exchange", "boot.qiu", "等我完成目标就来找你...");
  23.     }
  24. }

消费者:

配置监听器类BootMessageListener

  1. @Component
  2. public class BootMessageListener {
  4.     @RabbitListener(queues = "boot_queue")
  5.     public void consumeMessage(Message message) {
  6.         System.out.println("消息为:" + new String(message.getBody()));
  7.     }
  8. }

测试结果

<<<<<<<<<<<<<<<<至此RabbitMQ知识点和常用的一些方式就都概述完毕了>>>>>>>>>>>>>>>>

RabbitMQ入门到进阶(Spring整合RabbitMQ&SpringBoot整合RabbitMQ)的更多相关文章

  1. RabbitMQ入门：在Spring Boot 应用中整合RabbitMQ

    在上一篇随笔中我们认识并安装了RabbitMQ,接下来我们来看下怎么在Spring Boot 应用中整合RabbitMQ. 先给出最终目录结构: 搭建步骤如下: 新建maven工程amqp 修改pom ...

  2. 3、SpringBoot整合之SpringBoot整合JDBC

    SpringBoot整合JDBC 一.创建SpringBoot项目 选择Spring Web.JDBC API.MySQL Driver 二.在pom配置文件中修改JDBC版本,导入lombok &l ...

  3. 1、SpringBoot整合之SpringBoot整合JSP

    SpringBoot整合JSP 一.创建SpringBoot项目,仅选择Web模块即可 二.在POM文件中添加依赖 <!-- 添加servlet依赖模块 --> <dependenc ...

  4. 5、SpringBoot整合之SpringBoot整合MybatisPlus

    SpringBoot整合MybatisPlus 目录(可点击直接跳转,但还是建议按照顺序观看,四部分具有一定的关联性): 实现基础的增删改查 实现自动填充功能 实现逻辑删除 实现分页 首先给出四部分完 ...

  5. 8、SpringBoot整合之SpringBoot整合MongoDB

    SpringBoot整合MongoDB 一.创建项目,选择依赖 仅选择Spring Web.Spring Data MongoDB即可 二.引入相关依赖(非必要) 这里只是为了实体类的创建方便而引入l ...

  6. 9、SpringBoot整合之SpringBoot整合SpringSecurity

    SpringBoot整合SpringSecurity 一.创建项目,选择依赖 选择Spring Web.Thymeleaf即可 二.在pom文件中导入相关依赖 <!-- 导入SpringSecu ...

  7. 2、SpringBoot整合之SpringBoot整合servlet

    SpringBoot整合servlet 一.创建SpringBoot项目,仅选择Web模块即可 二.在POM文件中添加依赖 <!-- 添加servlet依赖模块 --> <depen ...

  8. springboot入门系列（二）：SpringBoot整合Swagger

    上一篇<简单搭建SpringBoot项目>讲了简单的搭建SpringBoot 项目,而 SpringBoot 和 Swagger-ui 搭配在持续交付的前后端开发中意义重大,Swagger ...

  9. RabbitMQ入门：总结

    随着上一篇博文的发布,RabbitMQ的基础内容我也学习完了,RabbitMQ入门系列的博客跟着收官了,以后有机会的话再写一些在实战中的应用分享,多谢大家一直以来的支持和认可. RabbitMQ入门系 ...

随机推荐

  1. 聊聊几个阿里 P8、P9 程序员的故事

    大家好,我是对白. 阿里 P8 程序员年薪百万已经是公开的秘密了,有人关心他们年薪百万,而我更加关注阿里这些 P8.P9 程序员的成长故事,在聊这些大牛的故事之前,跟大家稍微简单聊下阿里技术人等级制度 ...

  2. ESP32-S3 arduino 开发环境搭建

    ESP32-S3 arduino 简要描述 在github上搜索arduino-esp32,找到并打开espressif/arduino-esp32仓库,从master主分支切换到esp32-s3-s ...

  3. monowall

    https://www.cat-home.org/?action=show&id=158

  4. 简单excel饼状图怎么做，bi工具怎么做饼状图

    饼状图是为了在一个整体体现个体所占的比例,比如一块蛋糕每人各分多大份.了解了饼状图的含义,就来学习饼状图怎么做吧. 首先,我们准备excel表格饼状图的初始数据 然后选择excel表格上方的插入,选择 ...

  5. 【C# Parallel】开端

    使用条件 1.必须熟练掌握锁.死锁.task的知识,他是建立这两个的基础上的.task建立在线程和线程池上的. 2.并不是所有代码都适合并行化. 例如,如果某个循环在每次迭代时只执行少量工作,或它在很 ...

  6. 小白学python第2问： 为什么只有int，没有long？

    为什么只有int,没有long? 在python官网开发者指引里面能找到 PEP 237 -- Unifying Long Integers and Integers,这里说明了为什么要统一 int ...

  7. @vue/cli的配置知道多少-publicPath,outputDir,assetsDir,indexPath,filenameHashing,configureWebpack,productionSourceMap

    vue.config.js的简单介绍 vue.config.js 是一个可选的配置文件, 在项目的 (和 package.json 同级的) 根目录中存在这个文件. 默认情况没有这个文件需要我们手动去 ...

  8. 什么是NFT？

    我有一个年轻朋友,最近买了一个数字艺术品,9百多入手,几周后卖掉,赚了7万多,他告诉我这个东西叫NFT. 2021年twitter创始人杰克.多西将自己发布的第一条twitter通过NFT以250万美 ...

  9. 哈工大 计算机系统 实验七 TinyShell

    所有实验文件可见github 计算机系统实验整理 实验报告 实 验(七) 题 目 TinyShell 微壳 计算机科学与技术学院 目 录 第1章 实验基本信息 - 4 - 1.1 实验目的 - 4 - ...

  10. 控制台console不打印信息的解决办法

    一直用控制台调试,突然不知道怎么回事看不到控制台输出的信息了: 需要检查下面几方面的问题: 1:我的就属于第一个问题,不知道怎么搜索的时候就改变了Filter; 2:确保以上选项是勾选的 3:点击设置 ...