devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

高性能消息中间件 RabbitMQ_mq消息性能

作者：你好赵伟 | 2024-06-14 06:24:57

赞

踩

mq消息性能

一、RabbitMQ概念

1.1 MQ是什么

消息队列

MQ全称Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于系统之间的异步通信。

  • 同步通信相当于两个人当面对话，你一言我一语。必须及时回复：

  • 异步通信相当于通过第三方转述对话，可能有消息的延迟，但不需要二人时刻保持联系。

消息

两台计算机间传送的数据单位。消息可以非常简单，例如只包含文本字符串；也可以更复杂，可能包含嵌入对象。

队列

数据结构中概念。在队列中，数据先进先出，后进后出。

 1.2  MQ的优势

应用解耦

在电商平台中，用户下订单需要调用订单系统，此时订单系统还需要调用库存系统、支付系统、物流系统完成业务。此时会产生两个问题：

  1. 如果库存系统出现故障，会造成整个订单系统崩溃。
  2. 如果需求修改，新增了一个X系统，此时必须修改订单系统的代码。

如果在系统中引入MQ，即订单系统将消息先发送到MQ中，MQ再转发到其他系统，则会解决以下问题：

  1. 由于订单系统只发消息给MQ，不直接对接其他系统，如果库存系统出现故障，不影响整个订单。
  2. 如果需求修改，新增了一个X系统，此时无需修改订单系统的代码，只需修改MQ将消息发送给X系统即可。

异步提速

如果订单系统同步访问每个系统，则用户下单等待时长如下：

削峰填谷

假设我们的系统每秒只能承载1000请求，如果请求瞬间增多到每秒5000，则会造成系统崩溃。此时引入mq即可解决该问题

 使用了MQ之后，限制消费消息的速度为1000，这样一来，高峰期产生的数据势必会被积压在MQ中，高峰就被“削”掉了，但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000，直到消费完积压的消息，这就叫做“填谷”。

1.3 MQ的劣势 

  • 系统可用性降低 系统引入的外部依赖越多，系统稳定性越差。一旦MQ宕机，就会对业务造成影响。
  • 系统复杂度提高 MQ的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过MQ进行异步调用。
  • 一致性问题 A系统处理完业务，通过MQ给B、C、D三个系统发消息数据，如果B系统、C系统处理成功，D系统处理失败，则会造成数据处理的不一致。

 1.4 MQ的应用场景

  • 抢红包、秒杀活动、抢火车票等

这些业务场景都是短时间内需要处理大量请求，如果直接连接系统处理业务，会耗费大量资源，有可能造成系统瘫痪。

 而使用MQ后，可以先让用户将请求发送到MQ中，MQ会先保存请求消息，不会占用系统资源，且MQ会进行消息排序，先请求的秒杀成功，后请求的秒杀失败。

  • 消息分发

如电商网站要推送促销信息，该业务耗费时间较多，但对时效性要求不高，可以使用MQ做消息分发。

  • 数据同步

假如我们需要将数据保存到数据库之外，还需要一段时间将数据同步到缓存（如Redis）、搜索引擎（如Elasticsearch）中。此时可以将数据库的数据作为消息发送到MQ中，并同步到缓存、搜索引擎中。

  • 异步处理

在电商系统中，订单完成后，需要及时的通知子系统（进销存系统发货，用户服务积分，发送短信）进行下一步操作。为了保证订单系统的高性能，应该直接返回订单结果，之后让MQ通知子系统做其他非实时的业务操作。这样能保证核心业务的高效及时。

  • 离线处理

在银行系统中，如果要查询近十年的历史账单，这是非常耗时的操作。如果发送同步请求，则会花费大量时间等待响应。此时使用MQ发送异步请求，等到查询出结果后获取结果即可。

 1.5 AMQP协议

 RabbitMQ是由Erlang语言编写的基于AMQP的MQ产品。

AMQP

即Advanced Message Queuing Protocol(高级消息队列协议)，是一个网络协议，专门为消息中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受不同中间件产品，不同开发语言等条件的限制。2006年AMQP规范发布，类比HTTP。

AMQP工作过程

生产者(Publisher)将消息发布到交换机(Exchange)，交换机根据规则将消息分发给交换机绑定的队列(Queue)，队列再将消息投递给订阅了此队列的消费者。

 就好比是报纸印刷厂（Publisher）将印刷出来的报纸交给报社（Exchange），报社再将报纸交给不同的邮递员（Queue），邮递员再将报纸交给用户（Consumer）。

1.6 RabbitMQ工作原理

  • Producer

    消息的生产者。也是一个向交换机发布消息的客户端应用程序。也就是Java代码。

  • Connection

    连接。生产者/消费者和RabbitMQ服务器之间建立的TCP连接。

  • Channel

    信道。是TCP里面的虚拟连接。例如：Connection相当于电缆，Channel相当于独立光纤束，一条TCP连接中可以创建多条信道，增加连接效率。无论是发布消息、接收消息、订阅队列都是通过信道完成的。

  • Broker

    消息队列服务器实体。即RabbitMQ服务器

  • Virtual host

    虚拟主机。出于多租户和安全因素设计的，把AMQP的基本组件划分到一个虚拟的分组中。每个vhost本质上就是一个mini版的RabbitMQ服务器，拥有自己的队列、交换机、绑定和权限机制。当多个不同的用户使用同一个RabbitMQ服务器时，可以划分出多个虚拟主机。RabbitMQ默认的虚拟主机路径是/

  • Exchange

    交换机。用来接收生产者发送的消息，并根据分发规则，将这些消息分发给服务器中的队列中。不同的交换机有不同的分发规则。

  • Queue

    消息队列。用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。消息一直在队列里面，等待消费者链接到这个队列将其取走。

  • Binding

    消息队列和交换机之间的虚拟连接，绑定中包含路由规则，绑定信息保存到交换机的路由表中，作为消息的分发依据。

  • Consumer

    消息的消费者。表示一个从消息队列中取得消息的客户端应用程序。 

（面试）RabbitMQ为什么使用信道而不直接使用TCP连接通信？

TCP连接的创建和销毁开销特别大。创建需要3次握手，销毁需要4次分手。高峰时每秒成千上万条TCP连接的创建会造成资源巨大的浪费。而且操作系统每秒处理TCP连接数也是有限制的，会造成性能瓶颈。而如果一条线程使用一条信道，一条TCP链接可以容纳无限的信道，即使每秒成千上万的请求也不会成为性能的瓶颈。

 二、RabbitMQ安装

 2.1 安装Erlang

RabbitMQ是使用Erlang语言编写的，所以在安装RabbitMQ前需要先安装Erlang环境 .

1、安装Erlang所需的依赖

yum install -y epel-release

2、添加存储库条目

  1. wget https://packages.erlang-solutions.com/erlang-solutions-1.0-1.noarch.rpm 
  2. rpm -Uvh erlang-solutions-1.0-1.noarch.rpm

3、安装Erlang

yum install -y erlang24.2.1

4、查看Erlang是否安装成功

erl -version

2.2 安装RabbitMQ并启动

1、为了外部能够正常访问RabbitMQ服务，先关闭防火墙

  1. # 关闭运行的防火墙
  2. systemctl stop firewalld.service
  3. # 禁止防火墙自启动
  4. systemctl disable firewalld.service

2、RabbitMQ是通过主机名进行访问的，必须给服务器添加主机名

  1. # 修改文件
  2. vim /etc/sysconfig/network
  3. # 添加如下内容
  4. NETWORKING=yes
  5. HOSTNAME=zj
  6.  
  7.  
  8. # 修改文件
  9. vim /etc/hosts
  10. # 添加如下内容
  11. 服务器ip zj

3.使用xftp上传RabbitMQ压缩文件到根目录下

4.安装RabbitMQ

  1. # 解压RabbitMQ
  2. tar xf rabbitmq-server-generic-unix-3.9.13.tar.xz
  3.  
  4.  
  5. # 重命名：
  6. mv rabbitmq_server-3.9.13 rabbitmq
  7.  
  8.  
  9. # 移动文件夹：
  10. mv rabbitmq /usr/local/

5.配置环境变量

  1. # 编辑/etc/profile文件
  2. vim /etc/profile
  3.  
  4.  
  5. #添加如下内容
  6. export PATH=$PATH:/usr/local/rabbitmq/sbin
  7.  
  8.  
  9. # 运行文件，让修改内容生效
  10. source /etc/profile

6.开启管控台插件

rabbitmq-plugins enable rabbitmq_management

7.后台运行

  1. #启动rabbitmq
  2. rabbitmq-server -detached
  3.  
  4.  
  5. #停止rabbitmq
  6. rabbitmqctl stop

8.通过管控台访问RabbitMQ

路径：http://ip地址:15672，用户名：guest，密码：guest

管控台的端口是15672，MQ的端口是5672

 9.此时会提示guest账户只允许本地使用，我们可以配置允许使用guest远程访问

  1. # 创建配置文件夹
  2. mkdir -p /usr/local/rabbitmq/etc/rabbitmq
  3. # 创建配置文件
  4. vim /usr/local/rabbitmq/etc/rabbitmq/rabbitmq.conf
  5. # 添加如下内容
  6. loopback_users=none
  7.  
  8.  
  9. # 重启RabbitMQ
  10. rabbitmqctl stop_app
  11. rabbitmqctl reset
  12. rabbitmqctl start_app

此时就能进入控制台了。

 2.3 账户管理

guest账户默认只允许本地使用，我们可以创建新账户远程访问RabbitMQ（如2.2中），但是不推荐远程使用MQ.

1、创建账户

  1. # 创建账户
  2. rabbitmqctl add_user MQzhang(用户名) MQzhang(密码)

2、给用户授予管理员角色

rabbitmqctl set_user_tags 用户名 administrator

3、给用户授权

  1. # "/"表示虚拟机
  2. # zj表示用户名
  3. # ".*" ".*" ".*" 表示完整权限
  4. rabbitmqctl set_permissions -p "/" MQzhang".*" ".*" ".*"

4、通过管控台访问rabbitmq即可。

2.4 管控台

2.5 Docker安装

 1、关闭RabbitMQ服务

rabbitmqctl stop

2、在Centos7中安装docker

  1. # 安装Docker
  2. curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
  3.  
  4.  
  5. # 启动docker
  6. systemctl start docker

3、拉取镜像

docker pull rabbitmq

4、启动MQ

docker run -d --hostname zj--name rabbit -p 15672:15672 -p 5672:5672 rabbitmq

三、RabbitMQ工作模式

RabbitMQ共有六种工作模式：简单模式（Simple）、工作队列模式（Work Queue）、发布订阅模式（Publish/Subscribe）、路由模式（Routing）、通配符模式（Topics）、远程调用模式（RPC，不常用)

3.1 简单模式

简介

特点

  1. 一个生产者对应一个消费者，通过队列进行消息传递。
  2. 该模式使用direct交换机，direct交换机是RabbitMQ默认交换机。

 项目搭建

接下来我们使用JAVA代码操作RabbitMQ，让其按照简单模式进行工作。 

JMS

由于MQ产品很多，操作方式各有不同，于是JAVA提供了一套规则——JMS，用于操作消息中间件。JMS即Java消息服务（JavaMessage Service）应用程序接口，是一个Java平台中关于面向消息中间件的API。JMS是JavaEE规范中的一种，类比JDBC。很多MQ产品都实现了JMS规范，例如ActiveMQ。RabbitMQ官方并没有实现JMS规范，但是开源社区有JMS的实现包。

1、启动RabbitMQ

  1. # 开启管控台插件
  2. rabbitmq-plugins enable rabbitmq_management
  3. # 启动rabbitmq
  4. rabbitmq-server -detached

2、创建普通maven项目，添加RabbitMQ依赖：

  1. <dependencies>
  2.   <dependency>
  3.     <groupId>com.rabbitmq</groupId>
  4.     <artifactId>amqp-client</artifactId>
  5.     <version>5.14.0</version>
  6.   </dependency>
  7. </dependencies>

3、编写生产者

  1. package com.zj.mq.Simple;
  2.  
  3. import com.rabbitmq.client.Channel;
  4. import com.rabbitmq.client.Connection;
  5. import com.rabbitmq.client.ConnectionFactory;
  6.  
  7. import java.io.IOException;
  8. import java.util.concurrent.TimeoutException;
  9.  
  10. /*生产者*/
  11. public class Producer {
  12.     public static void main(String[] args) throws IOException, TimeoutException {
  13.         //1.创建连接工厂
  14.         ConnectionFactory connectionFactory = new ConnectionFactory();
  15.         connectionFactory.setHost("192.168.66.100");
  16.         connectionFactory.setPort(5672);
  17.         connectionFactory.setUsername("MQzhang");
  18.         connectionFactory.setPassword("MQzhang");
  19.         connectionFactory.setVirtualHost("/");
  20.         //2.创建连接
  21.         Connection connection = connectionFactory.newConnection();
  22.         //3.建立信道
  23.         Channel channel = connection.createChannel();
  24.         //4.创建队列（如果队列已经存在的话则使用该队列，也就是说队列只会创建一次）和交换机（简单模式下使用的是默认交换机direct）
  25.         /* 参数1：队列名
  26.          * 参数2：是否持久化，true表示MQ重启后队列还在。
  27.          * 参数3：是否私有化，false表示所有消费者都可以访问，true表示只有第一次拥有它的消费者才能访问
  28.          * 参数4：是否自动删除，true表示不再使用队列时自动删除队列
  29.          * 参数5：其他额外参数*/
  30.         channel.queueDeclare("simpleQueue",false,false,false,null);
  31.         //5.发送消息
  32.         String msg ="hello rabbitMQ";
  33.         /*
  34.          * 参数1：交换机名，""表示默认交换机
  35.          * 参数2：路由键，简单模式就是队列名
  36.          * 参数3：其他额外参数
  37.          * 参数4：要传递的消息字节数组
  38.          */
  39.         channel.basicPublish("","simpleQueue",null,msg.getBytes());
  40.         //6.关闭资源（信道和连接）
  41.         channel.close();
  42.         connection.close();
  43.         System.out.println("OK");
  44.     }
  45. }

 4.编写消费者

  1. package com.zj.mq.Simple;
  2.  
  3. import com.rabbitmq.client.*;
  4.  
  5. import java.io.IOException;
  6. import java.util.concurrent.TimeoutException;
  7.  
  8. /*消费者*/
  9. public class Consumer {
  10.     public static void main(String[] args) throws IOException, TimeoutException {
  11.         //1.创建连接工厂
  12.         ConnectionFactory connectionFactory = new ConnectionFactory();
  13.         connectionFactory.setHost("192.168.66.100");
  14.         connectionFactory.setPort(5672);
  15.         connectionFactory.setUsername("MQzhang");
  16.         connectionFactory.setPassword("MQzhang");
  17.         connectionFactory.setVirtualHost("/");
  18.         //2.创建连接
  19.         Connection connection = connectionFactory.newConnection();
  20.         //3.创建信道
  21.         Channel channel = connection.createChannel();
  22.         //4.监听队列（一直在连接不会关闭连接）
  23.         /*
  24.         * 参数一：监听的队列名
  25.         * 参数二：是否自动签收（消费完消息后自动告诉MQ消息消费完了），如果设置为false需要手动确认消息，否则MQ会一直发送消息。
  26.         * 参数三：Consumer的实现类，重写该类方法表示接受到消息后如何消费,body就是消息的字节数组。
  27.         * */
  28.         channel.basicConsume("simpleQueue",true,new DefaultConsumer(channel){
  29.             @Override
  30.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  31.                 String message = new String(body, "UTF-8");
  32.                 System.out.println("接受消息为："+message);
  33.             }
  34.         });
  35.     }
  36. }

 消费者随时在监听队列只要队列有消息就会被消费。

3.2 工作队列模式

与简单模式相比，工作队列模式(Work Queue)多了一些消费者，该模式也使用direct交换机，应用于处理消息较多的情况。特点如下：

  1. 一个队列对应多个消费者。
  2. 一条消息只会被一个消费者消费。
  3. 消息队列默认采用轮询的方式将消息平均发送给消费者。

1、编写生产者，并产生大量消息

  1. package com.zj.mq.work;
  2.  
  3. import com.rabbitmq.client.Channel;
  4. import com.rabbitmq.client.Connection;
  5. import com.rabbitmq.client.ConnectionFactory;
  6. import com.rabbitmq.client.MessageProperties;
  7.  
  8. import java.io.IOException;
  9. import java.util.concurrent.TimeoutException;
  10.  
  11. /*生产者*/
  12. public class Producer {
  13.     public static void main(String[] args) throws IOException, TimeoutException {
  14.         //1.创建连接工厂
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.         connectionFactory.setHost("192.168.66.100");
  17.         connectionFactory.setPort(5672);
  18.         connectionFactory.setUsername("MQzhang");
  19.         connectionFactory.setPassword("MQzhang");
  20.         connectionFactory.setVirtualHost("/");
  21.         //2.创建连接
  22.         Connection connection = connectionFactory.newConnection();
  23.         //3.建立信道
  24.         Channel channel = connection.createChannel();
  25.         //4.创建队列（如果队列已经存在的话则使用该队列，也就是说队列只会创建一次）和交换机（简单模式下使用的是默认交换机direct）
  26.         /* 参数1：队列名
  27.          * 参数2：是否持久化，true表示MQ重启后队列还在。
  28.          * 参数3：是否私有化，false表示所有消费者都可以访问，true表示只有第一次拥有它的消费者才能访问
  29.          * 参数4：是否自动删除，true表示不再使用队列时自动删除队列
  30.          * 参数5：其他额外参数*/
  31.         channel.queueDeclare("WorkQueue",false,false,false,null);
  32.         //5.发送大量消息
  33.         for (int i = 0; i < 100; i++) {
  34.             /*
  35.              * 参数1：交换机名，""表示默认交换机
  36.              * 参数2：路由键，简单模式就是队列名
  37.              * 参数3：表示该消息是持久化消息，即保存到内存也会保存到磁盘
  38.              * 参数4：要传递的消息字节数组
  39.              */
  40.             channel.basicPublish("","WorkQueue", MessageProperties.PERSISTENT_TEXT_PLAIN,("这是第"+i+"个消息").getBytes());
  41.         }
  42.  
  43.         //6.关闭资源（信道和连接）
  44.         channel.close();
  45.         connection.close();
  46.     }
  47. }

 2.编写消费者

 编写三个消费者，他们都监听的是一个队列。

  1. package com.zj.mq.work;
  2.  
  3. import com.rabbitmq.client.*;
  4.  
  5. import java.io.IOException;
  6. import java.util.concurrent.TimeoutException;
  7.  
  8. /*消费者*/
  9. public class Consumer1 {
  10.     public static void main(String[] args) throws IOException, TimeoutException {
  11.         //1.创建连接工厂
  12.         ConnectionFactory connectionFactory = new ConnectionFactory();
  13.         connectionFactory.setHost("192.168.66.100");
  14.         connectionFactory.setPort(5672);
  15.         connectionFactory.setUsername("MQzhang");
  16.         connectionFactory.setPassword("MQzhang");
  17.         connectionFactory.setVirtualHost("/");
  18.         //2.创建连接
  19.         Connection connection = connectionFactory.newConnection();
  20.         //3.创建信道
  21.         Channel channel = connection.createChannel();
  22.         //4.监听队列（一直在连接不会关闭连接）
  23.         /*
  24.         * 参数一：监听的队列名
  25.         * 参数二：是否自动签收（消费完消息后自动告诉MQ消息消费完了），如果设置为false需要手动确认消息，否则MQ会一直发送消息。
  26.         * 参数三：Consumer的实现类，重写该类方法表示接受到消息后如何消费,body就是消息的字节数组。
  27.         * */
  28.         channel.basicConsume("WorkQueue",true,new DefaultConsumer(channel){
  29.             @Override
  30.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  31.                 String message = new String(body, "UTF-8");
  32.                 System.out.println("消费者1接受消息为："+message);
  33.             }
  34.         });
  35.     }
  36. }
  1. package com.zj.mq.work;
  2.  
  3. import com.rabbitmq.client.*;
  4.  
  5. import java.io.IOException;
  6. import java.util.concurrent.TimeoutException;
  7.  
  8. /*消费者*/
  9. public class Consumer2 {
  10.     public static void main(String[] args) throws IOException, TimeoutException {
  11.         //1.创建连接工厂
  12.         ConnectionFactory connectionFactory = new ConnectionFactory();
  13.         connectionFactory.setHost("192.168.66.100");
  14.         connectionFactory.setPort(5672);
  15.         connectionFactory.setUsername("MQzhang");
  16.         connectionFactory.setPassword("MQzhang");
  17.         connectionFactory.setVirtualHost("/");
  18.         //2.创建连接
  19.         Connection connection = connectionFactory.newConnection();
  20.         //3.创建信道
  21.         Channel channel = connection.createChannel();
  22.         //4.监听队列（一直在连接不会关闭连接）
  23.         /*
  24.         * 参数一：监听的队列名
  25.         * 参数二：是否自动签收（消费完消息后自动告诉MQ消息消费完了），如果设置为false需要手动确认消息，否则MQ会一直发送消息。
  26.         * 参数三：Consumer的实现类，重写该类方法表示接受到消息后如何消费,body就是消息的字节数组。
  27.         * */
  28.         channel.basicConsume("WorkQueue",true,new DefaultConsumer(channel){
  29.             @Override
  30.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  31.                 String message = new String(body, "UTF-8");
  32.                 System.out.println("消费者2接受消息为："+message);
  33.             }
  34.         });
  35.     }
  36. }
  1. package com.zj.mq.work;
  2.  
  3. import com.rabbitmq.client.*;
  4.  
  5. import java.io.IOException;
  6. import java.util.concurrent.TimeoutException;
  7.  
  8. /*消费者*/
  9. public class Consumer3 {
  10.     public static void main(String[] args) throws IOException, TimeoutException {
  11.         //1.创建连接工厂
  12.         ConnectionFactory connectionFactory = new ConnectionFactory();
  13.         connectionFactory.setHost("192.168.66.100");
  14.         connectionFactory.setPort(5672);
  15.         connectionFactory.setUsername("MQzhang");
  16.         connectionFactory.setPassword("MQzhang");
  17.         connectionFactory.setVirtualHost("/");
  18.         //2.创建连接
  19.         Connection connection = connectionFactory.newConnection();
  20.         //3.创建信道
  21.         Channel channel = connection.createChannel();
  22.         //4.监听队列（一直在连接不会关闭连接）
  23.         /*
  24.         * 参数一：监听的队列名
  25.         * 参数二：是否自动签收（消费完消息后自动告诉MQ消息消费完了），如果设置为false需要手动确认消息，否则MQ会一直发送消息。
  26.         * 参数三：Consumer的实现类，重写该类方法表示接受到消息后如何消费,body就是消息的字节数组。
  27.         * */
  28.         channel.basicConsume("WorkQueue",true,new DefaultConsumer(channel){
  29.             @Override
  30.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  31.                 String message = new String(body, "UTF-8");
  32.                 System.out.println("消费者3接受消息为："+message);
  33.             }
  34.         });
  35.     }
  36. }
  1. 消费者1接受消息为：这是第0个消息
  2. 消费者1接受消息为：这是第3个消息
  3. 消费者1接受消息为：这是第6个消息
  4. 消费者1接受消息为：这是第9个消息
  5. 消费者1接受消息为：这是第12个消息
  6. 消费者1接受消息为：这是第15个消息
  7. 消费者1接受消息为：这是第18个消息
  8. 消费者1接受消息为：这是第21个消息
  9. ……
  10.  
  11.  
  12. 消费者2接受消息为：这是第1个消息
  13. 消费者2接受消息为：这是第4个消息
  14. 消费者2接受消息为：这是第7个消息
  15. 消费者2接受消息为：这是第10个消息
  16. 消费者2接受消息为：这是第13个消息
  17. 消费者2接受消息为：这是第16个消息
  18. 消费者2接受消息为：这是第19个消息
  19. 消费者2接受消息为：这是第22个消息
  20. 消费者2接受消息为：这是第25个消息
  21. ……
  22.  
  23.  
  24. 消费者3接受消息为：这是第2个消息
  25. 消费者3接受消息为：这是第5个消息
  26. 消费者3接受消息为：这是第8个消息
  27. 消费者3接受消息为：这是第11个消息
  28. 消费者3接受消息为：这是第14个消息
  29. 消费者3接受消息为：这是第17个消息
  30. 消费者3接受消息为：这是第20个消息
  31. 消费者3接受消息为：这是第23个消息
  32. 消费者3接受消息为：这是第26个消息
  33. 消费者3接受消息为：这是第29个消息
  34. 消费者3接受消息为：这是第32个消息

3.3 发布订阅模式 

在开发过程中，有一些消息需要不同消费者进行不同的处理，如电商网站的同一条促销信息需要短信发送、邮件发送、站内信发送等。此时可以使用发布订阅模式(Publish/Subscribe) 

特点

  1. 生产者将消息发送给交换机，交换机将消息转发到绑定此交换机的每个队列中。
  2. 工作队列模式的交换机只能将消息发送给一个队列，发布订阅模式的交换机能将消息发送给多个队列。发布订阅模式使用fanout交换机。

 1、编写生产者

  1. package com.zj.mq.publish;
  2.  
  3. import com.rabbitmq.client.BuiltinExchangeType;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  6. import com.rabbitmq.client.ConnectionFactory;
  7.  
  8. import java.io.IOException;
  9. import java.util.concurrent.TimeoutException;
  10.  
  11. /*生产者*/
  12. public class Producer {
  13.     public static void main(String[] args) throws IOException, TimeoutException {
  14.         //1.创建连接工厂
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.         connectionFactory.setHost("192.168.66.100");
  17.         connectionFactory.setPort(5672);
  18.         connectionFactory.setUsername("MQzhang");
  19.         connectionFactory.setPassword("MQzhang");
  20.         connectionFactory.setVirtualHost("/");
  21.         //2.创建连接
  22.         Connection connection = connectionFactory.newConnection();
  23.         //3.建立信道
  24.         Channel channel = connection.createChannel();
  25.         //4.创建交换机fanout
  26.         /*
  27.         * 参数一：交换机名称
  28.         * 参数二：交换机类型
  29.         * 参数三： 交换机是否持久化（关闭控制台是否还存在）*/
  30.         channel.exchangeDeclare("exchangeFanout", BuiltinExchangeType.FANOUT,false);
  31.         //5.创建三个队列(分别模拟邮件发送、短信发送、站内信发送)
  32.         channel.queueDeclare("mailQueue", false,false,false,null);
  33.         channel.queueDeclare("messageQueue", false,false,false,null);
  34.         channel.queueDeclare("stationQueue", false,false,false,null);
  35.         //6.交换机绑定队列
  36.         /*
  37.         * 参数一：队列名称
  38.         * 参数二：交换机名称
  39.         * 参数三：路由关键字，发布订阅模式不存在路由关键字*/
  40.         channel.queueBind("mailQueue","exchangeFanout","");
  41.         channel.queueBind("messageQueue","exchangeFanout","");
  42.         channel.queueBind("stationQueue","exchangeFanout","");
  43.         //7.往交换机发送消息
  44.         for (int i = 0; i < 10; i++) {
  45.             channel.basicPublish("exchangeFanout","",null,("你好，MQ"+i).getBytes());
  46.         }
  47.         //8.关闭资源
  48.         channel.close();
  49.         connection.close();
  50.  
  51.     }
  52. }

 2、站内信消费者(其他同理)

  1. package com.zj.mq.publish;
  2.  
  3. import com.rabbitmq.client.*;
  4. import com.sun.deploy.ui.AboutDialog;
  5.  
  6.  
  7. import java.io.IOException;
  8. import java.util.concurrent.TimeoutException;
  9.  
  10. /*站内信消费者*/
  11. public class ConsumerStation {
  12.     public static void main(String[] args) throws IOException, TimeoutException {
  13.         //1.创建连接工厂
  14.         ConnectionFactory connectionaFactory = new ConnectionFactory();
  15.         connectionaFactory.setHost("192.168.66.100");
  16.         connectionaFactory.setPort(5672);
  17.         connectionaFactory.setUsername("MQzhang");
  18.         connectionaFactory.setPassword("MQzhang");
  19.         connectionaFactory.setVirtualHost("/");
  20.         //2.创建连接
  21.         Connection connection = connectionaFactory.newConnection();
  22.         //3.创建信道
  23.         Channel channel = connection.createChannel();
  24.         //4.监听队列（一直在连接不会关闭连接）
  25.         /*
  26.          * 参数一：监听的队列名
  27.          * 参数二：是否自动签收（消费完消息后自动告诉MQ消息消费完了），如果设置为false需要手动确认消息，否则MQ会一直发送消息。
  28.          * 参数三：Consumer的实现类，重写该类方法表示接受到消息后如何消费,body就是消息的字节数组。
  29.          * */
  30.         channel.basicConsume("stationQueue",true,new DefaultConsumer(channel){
  31.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  32.                 String message = new String(body, "UTF-8");
  33.                 System.out.println("发送站内信:"+message);
  34.             }
  35.         });
  36.     }
  37. }
  1. 发送站内信:你好，MQ0
  2. 发送站内信:你好，MQ1
  3. 发送站内信:你好，MQ2
  4. 发送站内信:你好，MQ3
  5. 发送站内信:你好，MQ4
  6. 发送站内信:你好，MQ5
  7. 发送站内信:你好，MQ6
  8. 发送站内信:你好，MQ7
  9. 发送站内信:你好，MQ8
  10. 发送站内信:你好，MQ9

 当然也能创建多个消费者来监听同一个队列来提高消费速度。

 3.4 路由模式

 使用发布订阅模式时，所有消息都会发送到绑定的队列中（发送到绑定到交换机上的每个队列，队列再发送给消费者），但很多时候，不是所有消息都无差别的发布到所有队列中。比如电商网站的促销活动，双十一大促可能会发布到所有队列；而一些小的促销活动为了节约成本，只发布到站内信队列。此时需要使用路由模式(Routing)完成这一需求。

特点

  1. 每个队列绑定路由关键字RoutingKey
  2. 生产者将带有RoutingKey的消息发送给交换机，交换机根据RoutingKey转发到指定队列。路由模式使用direct交换机。

编写生产者

  1. package com.zj.mq.route;
  2.  
  3. import com.rabbitmq.client.BuiltinExchangeType;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  6. import com.rabbitmq.client.ConnectionFactory;
  7.  
  8. import java.io.IOException;
  9. import java.util.concurrent.TimeoutException;
  10.  
  11. /*生产者*/
  12. public class Producer {
  13.     public static void main(String[] args) throws IOException, TimeoutException {
  14.         //1.创建连接工厂
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.         connectionFactory.setHost("192.168.66.100");
  17.         connectionFactory.setPort(5672);
  18.         connectionFactory.setUsername("MQzhang");
  19.         connectionFactory.setPassword("MQzhang");
  20.         connectionFactory.setVirtualHost("/");
  21.         //2.创建连接
  22.         Connection connection = connectionFactory.newConnection();
  23.         //3.建立信道
  24.         Channel channel = connection.createChannel();
  25.         //4.创建交换机fanout
  26.         /*
  27.         * 参数一：交换机名称
  28.         * 参数二：交换机类型
  29.         * 参数三： 交换机是否持久化（关闭控制台是否还存在）*/
  30.         channel.exchangeDeclare("exchangeRoute", BuiltinExchangeType.DIRECT,false);
  31.         //5.创建三个队列(分别模拟邮件发送、短信发送、站内信发送)
  32.         /* 参数1：队列名
  33.          * 参数2：是否持久化，true表示MQ重启后队列还在。
  34.          * 参数3：是否私有化，false表示所有消费者都可以访问，true表示只有第一次拥有它的消费者才能访问
  35.          * 参数4：是否自动删除，true表示不再使用队列时自动删除队列
  36.          * 参数5：其他额外参数
  37.          * */
  38.         channel.queueDeclare("mailQueue", false,false,false,null);
  39.         channel.queueDeclare("messageQueue", false,false,false,null);
  40.         channel.queueDeclare("stationQueue", false,false,false,null);
  41.         //6.交换机绑定队列
  42.         /*
  43.         * 参数一：队列名称
  44.         * 参数二：交换机名称
  45.         * 参数三：路由关键字,一个队列可以有多个路由关键字
  46.         * */
  47.         channel.queueBind("mailQueue","exchangeRoute","import");
  48.         channel.queueBind("messageQueue","exchangeRoute","normal");
  49.         channel.queueBind("stationQueue","exchangeRoute","import");
  50.         //7.往交换机发送消息,路由关键字是import，表示交换机会将消息发送到带有import关键字的队列。
  51.         channel.basicPublish("exchangeRoute","import",null,("你好，import MQ").getBytes());
  52.         //路由关键字是normal表示交换机会将消息发送到带有normal关键字的队列
  53.         channel.basicPublish("exchangeRoute","normal",null,("你好，normal MQ").getBytes());
  54.         //8.关闭资源
  55.         channel.close();
  56.         connection.close();
  57.  
  58.     }
  59. }

 编写消费者

消费者还是和其他模式的消费者是一样的。这里以mailQuene举例子。

  1. package com.zj.mq.route;
  2.  
  3. import com.rabbitmq.client.*;
  4.  
  5. import java.io.IOException;
  6. import java.util.concurrent.TimeoutException;
  7.  
  8. /*消费者*/
  9. public class Consumer {
  10.     public static void main(String[] args) throws IOException, TimeoutException {
  11.         //1.创建连接工厂
  12.         ConnectionFactory connectionFactory = new ConnectionFactory();
  13.         connectionFactory.setHost("192.168.66.100");
  14.         connectionFactory.setPort(5672);
  15.         connectionFactory.setUsername("MQzhang");
  16.         connectionFactory.setPassword("MQzhang");
  17.         connectionFactory.setVirtualHost("/");
  18.         //2.创建连接
  19.         Connection connection = connectionFactory.newConnection();
  20.         //3.创建信道
  21.         Channel channel = connection.createChannel();
  22.         //4.监听队列（一直在连接不会关闭连接）
  23.         /*
  24.         * 参数一：监听的队列名
  25.         * 参数二：是否自动签收（消费完消息后自动告诉MQ消息消费完了），如果设置为false需要手动确认消息，否则MQ会一直发送消息。
  26.         * 参数三：Consumer的实现类，重写该类方法表示接受到消息后如何消费,body就是消息的字节数组。
  27.         *
  28.         */
  29.         channel.basicConsume("mailQueue",true,new DefaultConsumer(channel){
  30.             @Override
  31.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  32.                 String message = new String(body, "UTF-8");
  33.                 System.out.println("接受消息为："+message);
  34.             }
  35.         });
  36.     }
  37. }

3.5 通配符模式

通配符模式(Topic)是在路由模式的基础上，给队列绑定带通配符的路由关键字，只要消息的RoutingKey能实现通配符匹配，就会将消息转发到该队列。通配符模式比路由模式更灵活，使用topic交换机。

通配符规则：

  1. 消息设置RoutingKey时，RoutingKey由多个单词构成，中间以.分割。
  2. 队列设置RoutingKey时，#可以匹配任意多个单词，*可以匹配任意一个单词。

编写生产者

  1. package com.zj.mq.topic;
  2.  
  3. import com.rabbitmq.client.BuiltinExchangeType;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  6. import com.rabbitmq.client.ConnectionFactory;
  7.  
  8. import java.io.IOException;
  9. import java.util.concurrent.TimeoutException;
  10.  
  11. /*生产者*/
  12. public class Producer {
  13.     public static void main(String[] args) throws IOException, TimeoutException {
  14.         //1.创建连接工厂
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.         connectionFactory.setHost("192.168.66.100");
  17.         connectionFactory.setPort(5672);
  18.         connectionFactory.setUsername("MQzhang");
  19.         connectionFactory.setPassword("MQzhang");
  20.         connectionFactory.setVirtualHost("/");
  21.         //2.创建连接
  22.         Connection connection = connectionFactory.newConnection();
  23.         //3.建立信道
  24.         Channel channel = connection.createChannel();
  25.         //4.创建交换机fanout
  26.         /*
  27.         * 参数一：交换机名称
  28.         * 参数二：交换机类型
  29.         * 参数三： 交换机是否持久化（关闭控制台是否还存在）*/
  30.         channel.exchangeDeclare("exchangeTopic", BuiltinExchangeType.TOPIC,false);
  31.         //5.创建三个队列(分别模拟邮件发送、短信发送、站内信发送)
  32.         channel.queueDeclare("mailQueue", false,false,false,null);
  33.         channel.queueDeclare("messageQueue", false,false,false,null);
  34.         channel.queueDeclare("stationQueue", false,false,false,null);
  35.         //6.交换机绑定队列
  36.         /*
  37.         * 参数一：队列名称
  38.         * 参数二：交换机名称
  39.         * 参数三：路由关键字，【#.mail.#】 表示：mail前后可以匹配多个单词*/
  40.         channel.queueBind("mailQueue","exchangeTopic","#.mail.#");
  41.         channel.queueBind("messageQueue","exchangeTopic","#.message.#");
  42.         channel.queueBind("stationQueue","exchangeTopic","#.station.#");
  43.         //7.往交换机发送消息到三个队列
  44.         channel.basicPublish("exchangeTopic","mail.message.station",null,("你好，MQ").getBytes());
  45.         //8.关闭资源
  46.         channel.close();
  47.         connection.close();
  48.     }
  49. }

 编写消费者

也是和其他模式的消费者是一样的只需要监听消费者。

  1. package com.zj.mq.topic;
  2.  
  3. import com.rabbitmq.client.*;
  4.  
  5. import java.io.IOException;
  6. import java.util.concurrent.TimeoutException;
  7.  
  8. /*消费者*/
  9. public class Consumer {
  10.     public static void main(String[] args) throws IOException, TimeoutException {
  11.         //1.创建连接工厂
  12.         ConnectionFactory connectionFactory = new ConnectionFactory();
  13.         connectionFactory.setHost("192.168.66.100");
  14.         connectionFactory.setPort(5672);
  15.         connectionFactory.setUsername("MQzhang");
  16.         connectionFactory.setPassword("MQzhang");
  17.         connectionFactory.setVirtualHost("/");
  18.         //2.创建连接
  19.         Connection connection = connectionFactory.newConnection();
  20.         //3.创建信道
  21.         Channel channel = connection.createChannel();
  22.         //4.监听队列（一直在连接不会关闭连接）
  23.         /*
  24.         * 参数一：监听的队列名
  25.         * 参数二：是否自动签收（消费完消息后自动告诉MQ消息消费完了），如果设置为false需要手动确认消息，否则MQ会一直发送消息。
  26.         * 参数三：Consumer的实现类，重写该类方法表示接受到消息后如何消费,body就是消息的字节数组。
  27.         *
  28.         */
  29.         channel.basicConsume("mailQueue",true,new DefaultConsumer(channel){
  30.             @Override
  31.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  32.                 String message = new String(body, "UTF-8");
  33.                 System.out.println("接受消息为："+message);
  34.             }
  35.         });
  36.     }
  37. }

四、SpringBoot整合RabbitMQ

 之前我们使用原生JAVA操作RabbitMQ较为繁琐，接下来我们使用SpringBoot整合RabbitMQ，简化代码编写。

1.创建SpringBoot项目，引入RabbitMQ起步依赖（springboot版本是2.7.0）

  1. <!-- RabbitMQ起步依赖 -->
  2. <dependency>
  3.   <groupId>org.springframework.boot</groupId>
  4.   <artifactId>spring-boot-starter-amqp</artifactId>
  5. </dependency>

2.编写配置文件

  1. spring:
  2.   rabbitmq:
  3.     host: 192.168.66.100
  4.     port: 5672
  5.     username: MQzhang
  6.     password: MQzhang
  7.     virtual-host: /
  8.  
  9.  
  10. #日志格式
  11. logging:
  12.   pattern:
  13.     console: '%d{HH:mm:ss.SSS} %clr(%-5level) ---  [%-15thread] %cyan(%-50logger{50}):%msg%n'
  14.

3.创建队列和交换机

 SpringBoot整合RabbitMQ时，需要在配置类创建队列和交换机，写法如下：

  1. package com.zj.config;
  2.  
  3. import org.springframework.amqp.core.*;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7.  
  8. @Configuration
  9. public class RabbitConfig {
  10.  
  11.     private final String EXCHANGE_NAME = "boot_topic_exchange";
  12.     private final String QUEUE_NAME = "boot_queue";
  13.  
  14.  
  15.     // 创建交换机
  16.     @Bean(EXCHANGE_NAME)
  17.     public Exchange getExchange() {
  18.         return ExchangeBuilder
  19.                 .topicExchange(EXCHANGE_NAME) // 交换机类型和名称
  20.                 .durable(true) // 是否持久化
  21.                 .build();
  22.     }
  23.  
  24.  
  25.     // 创建队列
  26.     @Bean(QUEUE_NAME)
  27.     public Queue getMessageQueue() {
  28.         return new Queue(QUEUE_NAME); // 队列名
  29.     }
  30.  
  31.  
  32.     // 交换机绑定队列
  33.     @Bean
  34.     public Binding bindMessageQueue(@Qualifier(EXCHANGE_NAME) Exchange exchange,
  35.                                     @Qualifier(QUEUE_NAME) Queue queue) {
  36.         return BindingBuilder
  37.                 .bind(queue)
  38.                 .to(exchange)
  39.                 .with("#.message.#")
  40.                 .noargs();
  41.     }
  42. }

4.编写生产者 

 SpringBoot整合RabbitMQ时，提供了工具类RabbitTemplate发送消息，编写生产者时只需要注入RabbitTemplate即可发送消息。

  1. package com.zj;
  2.  
  3. import org.junit.jupiter.api.Test;
  4. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  5. import org.springframework.boot.test.context.SpringBootTest;
  6.  
  7. import javax.annotation.Resource;
  8.  
  9. @SpringBootTest
  10. class DemoApplicationTests {
  11.  
  12.  
  13.     @Resource
  14.     public RabbitTemplate rabbitTemplate;
  15.  
  16.     @Test
  17.     public void testProducer(){
  18.         /*
  19.         * 参数一：交换机名称
  20.         * 参数二：路由关键字
  21.         * 参数三：要发送的消息
  22.         */
  23.         rabbitTemplate.convertAndSend("boot_topic_exchange","message","hello MQ");
  24.     }
  25.  
  26. }

 5.编写消费者

 我们编写另一个SpringBoot项目作为RabbitMQ的消费者，因为在同一个项目中的话直接方法调用就可以。

1、创建项目导入依赖。

2、编写配置文件，和生产者的相同

3、编写消费者，监听队列

  1. @Component
  2. public class Consumer {
  3.     // 监听队列
  4.     @RabbitListener(queues = "boot_queue")
  5.     public void listen_message(String message){
  6.         System.out.println("发送短信："+message);
  7.     }
  8. }

4、运行项目。观察管控台队列和控制台

五、消息的可靠性投递

5.1 概念

RabbitMQ消息投递的路径为：

生产者--->交换机--->队列--->消费者

在RabbitMQ工作的过程中，每个环节消息都可能传递失败，那么RabbitMQ是如何监听消息是否成功投递的呢？

  • 确认模式（confirm）可以监听消息是否从生产者成功传递到交换机。
  • 退回模式（return）可以监听消息是否从交换机成功传递到队列。
  • 消费者消息确认（Consumer Ack）可以监听消费者是否成功处理消息。

首先我们准备两个SpringBoot项目，分别代表生产者和消费者，配置文件如下：

  1. spring:
  2.   rabbitmq:
  3.     host: 192.168.66.100
  4.     port: 5672
  5.     username: MQzhang
  6.     password: MQzhang
  7.     virtual-host: /
  8.  
  9.  
  10. #日志格式
  11. logging:
  12.   pattern:
  13.     console: '%d{HH:mm:ss.SSS} %clr(%-5level) ---  [%-15thread] %cyan(%-50logger{50}):%msg%n'
  14.

在生产者的配置类创建交换机和队列：

  1. package com.zj.config;
  2.  
  3. import org.springframework.amqp.core.*;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7.  
  8. @Configuration
  9. public class RabbitConfig {
  10.  
  11.     private final String EXCHANGE_NAME = "boot_topic_exchange";
  12.     private final String QUEUE_NAME = "boot_queue";
  13.  
  14.  
  15.     // 创建交换机
  16.     @Bean(EXCHANGE_NAME)
  17.     public Exchange getExchange() {
  18.         return ExchangeBuilder
  19.                 .topicExchange(EXCHANGE_NAME) // 交换机类型和名称
  20.                 .durable(true) // 是否持久化
  21.                 .build();
  22.     }
  23.  
  24.  
  25.     // 创建队列
  26.     @Bean(QUEUE_NAME)
  27.     public Queue getMessageQueue() {
  28.         return new Queue(QUEUE_NAME); // 队列名
  29.     }
  30.  
  31.  
  32.     // 交换机绑定队列
  33.     @Bean
  34.     public Binding bindMessageQueue(@Qualifier(EXCHANGE_NAME) Exchange exchange,
  35.                                     @Qualifier(QUEUE_NAME) Queue queue) {
  36.         return BindingBuilder
  37.                 .bind(queue)
  38.                 .to(exchange)
  39.                 .with("#.message.#")
  40.                 .noargs();
  41.     }
  42. }

创建生产者

  1. @Component
  2. public class Consumer {
  3.     // 监听队列
  4.     @RabbitListener(queues = "boot_queue")
  5.     public void listen_message(String message){
  6.         System.out.println("发送短信："+message);
  7.     }
  8. }

5.2 确认模式

确认模式（confirm）可以监听消息是否从生产者成功传递到交换机，使用方法如下：

1、生产者配置文件开启确认模式

  1. spring:
  2.   rabbitmq:
  3.     host: 192.168.66.100
  4.     port: 5672
  5.     username: MQzhang
  6.     password: MQzhang
  7.     virtual-host: /
  8.     # 开启确认模式
  9.     publisher-confirm-type: correlated

2、生产者定义确认模式的回调方法，并模拟向不存在的交换机aaa发送消息。

  1. package com.zj;
  2.  
  3. import org.junit.jupiter.api.Test;
  4. import org.springframework.amqp.rabbit.connection.CorrelationData;
  5. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  6. import org.springframework.boot.test.context.SpringBootTest;
  7.  
  8. import javax.annotation.Resource;
  9.  
  10. @SpringBootTest
  11. class DemoApplicationTests {
  12.  
  13.  
  14.     @Resource
  15.     public RabbitTemplate rabbitTemplate;
  16.  
  17.     @Test
  18.     public void testProducer(){
  19.  
  20.         //定义确认模式的回调方法，当消息向交换机发送后会调用confirm方法。
  21.         rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
  22.  
  23.             /**
  24.              * @param correlationData 相关配置信息
  25.              * @param ack  交换机是否收到消息
  26.              * @param cause  失败原因
  27.              */
  28.             @Override
  29.             public void confirm(CorrelationData correlationData, boolean ack, String cause) {
  30.                   if(ack){
  31.                       System.out.println("消息接受成功");
  32.                   }else {
  33.                       System.out.println("消息接受失败："+cause);
  34.                       //做一些处理让消息再次发送
  35.                   }
  36.  
  37.             }
  38.         });
  39.  
  40.         rabbitTemplate.convertAndSend("aaa","message","hello MQ");
  41.     }
  42.  
  43. }

3、运行结果

消息接受失败：channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no exchange 'aaa' in vhost '/', class-id=60, method-id=40)

5.3 退回模式

退回模式（return）可以监听消息是否从交换机成功传递到队列，使用方法如下：

 1、生产者配置文件开启退回模式

  1. spring:
  2.   rabbitmq:
  3.     host: 192.168.66.100
  4.     port: 5672
  5.     username: MQzhang
  6.     password: MQzhang
  7.     virtual-host: /
  8.     # 开启确认模式
  9.     publisher-confirm-type: correlated
  10.       # 开启回退模式
  11.     publisher-returns: true

2、生产者定义退回模式的回调方法，模拟向不存在的队列bbb发送消息。

  1.  
  2. @SpringBootTest
  3. class DemoApplicationTests {
  4.  
  5.  
  6.     @Resource
  7.     public RabbitTemplate rabbitTemplate;
  8.  
  9.     @Test
  10.     public void testProducer(){
  11.  
  12.         //定义退回模式的回调方法，只有交换机将消息发送到队列失败后才会执行该方法。
  13.          rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
  14.              /**
  15.               *
  16.               * @param returnedMessage 失败后将失败信息封装到该参数
  17.               */
  18.              @Override
  19.              public void returnedMessage(ReturnedMessage returnedMessage) {
  20.                  System.out.println("消息对象："+returnedMessage);
  21.                  System.out.println("错误码:"+returnedMessage.getReplyCode());
  22.                  System.out.println("错误信息:"+returnedMessage.getReplyText());
  23.                  System.out.println("交换机:"+returnedMessage.getExchange());
  24.                  System.out.println("路由键:"+returnedMessage.getRoutingKey());
  25.  
  26.                  //处理消息……
  27.              }
  28.          });
  29.  
  30.         rabbitTemplate.convertAndSend("boot_topic_exchange","bbb","hello MQ");
  31.     }
  32. }
  1. 消息对象：ReturnedMessage [message=(Body:'hello MQ' MessageProperties [headers={}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, deliveryTag=0]), replyCode=312, replyText=NO_ROUTE, exchange=boot_topic_exchange, routingKey=bbb]
  2. 错误码:312
  3. 错误信息:NO_ROUTE
  4. 交换机:boot_topic_exchange
  5. 路由键:bbb

5.4 Ack手动签收

在RabbitMQ中，消费者接收到消息后会向队列发送确认签收的消息，只有确认签收的消息才会被移除队列。这种机制称为消费者消息确认（Consumer Acknowledge，简称Ack）。类似快递员派送快递也需要我们签收，否则一直存在于快递公司的系统中。

消息分为自动确认和手动确认。自动确认指消息只要被消费者接收到，无论是否成功处理消息，则自动签收，并将消息从队列中移除。但是在实际开发中，收到消息后可能业务处理出现异常，那么消息就会丢失。此时需要设置手动签收，即在业务处理成功再通知签收消息，如果出现异常，则拒签消息，让消息依然保留在队列当中。

  • 自动确认：spring.rabbitmq.listener.simple.acknowledge="none"
  • 手动确认：spring.rabbitmq.listener.simple.acknowledge="manual"

 1.消费者配置开启手动签收

  1. spring:
  2.   rabbitmq:
  3.     host: 192.168.66.100
  4.     port: 5672
  5.     username: MQzhang
  6.     password: MQzhang
  7.     virtual-host: /
  8.       # 开启手动签收
  9.     listener:
  10.       simple:
  11.         acknowledge-mode: manual

2、消费者处理消息时定义手动签收和拒绝签收的情况

  1. package com.zj.consumer;
  2.  
  3. import com.rabbitmq.client.Channel;
  4. import org.springframework.amqp.core.Message;
  5. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  6. import org.springframework.stereotype.Component;
  7.  
  8. import java.io.IOException;
  9.  
  10.  
  11. @Component
  12. public class ACKConsumer {
  13.  
  14.     // 监听队列
  15.     /**
  16.      *
  17.      * @param message  消息对象
  18.      * @param channel   信道对象，用于手动接受消息
  19.      */
  20.     @RabbitListener(queues = "boot_queue")
  21.     public void listen_message(Message message, Channel channel) throws IOException {
  22.         //deliveryTag:消息投递序号，每次投递该值都会+1.
  23.         long deliveryTag = message.getMessageProperties().getDeliveryTag();
  24.         try {
  25.             //签收消息
  26.             /*
  27.              * 参数一：消息投递序号
  28.              * 参数二：一次是否可以签收多条消息
  29.              */
  30.             channel.basicAck(deliveryTag,true);
  31.         }catch (Exception e){
  32.              //拒签消息
  33.             /*
  34.              * 参数一：消息投递序号
  35.              * 参数二：一次是否可以签收多条消息
  36.              * 参数三：拒签后消息是否重回队列（处在队列中的消息会不断的再向消费者发送消息）
  37.              */
  38.             channel.basicNack(deliveryTag,true,true);
  39.             System.out.println("消息消费失败");
  40.         }
  41.  
  42.     }
  43. }

六、RabbitMQ高级特性

6.1 消费端限流

之前我们说MQ可以对请求进行“削峰填谷”，即通过消费端限流的方式限制消息的拉取速度，达到保护消费端的目的。

消费端限流的写法如下：

1.生产者批量发送消息

  1. @SpringBootTest
  2. class DemoApplicationTests {
  3.  
  4.  
  5.     @Resource
  6.     public RabbitTemplate rabbitTemplate;
  7.  
  8.     @Test
  9.     public void testSendBatch() {
  10.         // 发送十条消息
  11.         for (int i = 0; i < 100; i++) {
  12.             rabbitTemplate.convertAndSend("boot_topic_exchange", "message", "send message..."+i);
  13.         }
  14.     }
  15. }

2.消费端配置限流机制

  1. spring:
  2.   rabbitmq:
  3.     host: 192.168.66.100
  4.     port: 5672
  5.     username: MQzhang
  6.     password: MQzhang
  7.     virtual-host: /
  8.     listener:
  9.       simple:
  10.         # 限流机制必须开启手动签收
  11.         acknowledge-mode: manual
  12.         # 消费端最多拉取20条消息消费，签收后不满20条才会继续拉取消息。
  13.         prefetch: 20
  14.

3、消费者接受消息

  1. package com.zj.consumer;
  2.  
  3. import com.rabbitmq.client.Channel;
  4. import org.springframework.amqp.core.Message;
  5. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  6. import org.springframework.stereotype.Component;
  7.  
  8. import java.io.IOException;
  9.  
  10. @Component
  11. public class OosConsumer {
  12.     @RabbitListener(queues = "boot_queue")
  13.     public void listenMessage(Message message, Channel channel) throws IOException, InterruptedException {
  14.         //1.获取消息
  15.         System.out.println("当前时间："+new String(message.getBody()));
  16.         //2.模拟业务处理
  17.         Thread.sleep(2000);
  18.         //3.签收消息
  19.         long deliveryTag = message.getMessageProperties().getDeliveryTag();
  20.         channel.basicAck(deliveryTag,true);
  21.     }
  22. }

20230619

6.2 限流实现不公平分发

在RabbitMQ中，多个消费者监听同一条队列，则队列默认采用的轮询分发。但是在某种场景下这种策略并不是很好，例如消费者1处理任务的速度非常快，而其他消费者处理速度却很慢。此时如果采用公平分发，则消费者1有很大一部分时间处于空闲状态。此时可以采用不公平分发，即谁处理的快，谁处理的消息多。

 使用方法如下：

1.生产者批量发送消息

  1.  
  2. @SpringBootTest
  3. class DemoApplicationTests {
  4.  
  5.  
  6.     @Resource
  7.     public RabbitTemplate rabbitTemplate;
  8.  
  9.     @Test
  10.     public void testSendBatch() {
  11.         // 发送十条消息
  12.         for (int i = 0; i < 10; i++) {
  13.             rabbitTemplate.convertAndSend("boot_topic_exchange", "message", "send message..."+i);
  14.         }
  15.     }
  16. }

2.消费端配置不公平分发

  1. spring:
  2.   rabbitmq:
  3.     host: 192.168.66.100
  4.     port: 5672
  5.     username: MQzhang
  6.     password: MQzhang
  7.     virtual-host: /
  8.     listener:
  9.       simple:
  10.         # 限流机制必须开启手动签收
  11.         acknowledge-mode: manual
  12.         # 消费端最多拉取1条消息消费，这样谁处理的快谁拉取下一条消息，实现了不公平分发
  13.         prefetch: 1

3、编写两个消费者消费相同的队列信息

  1. package com.zj.consumer;
  2.  
  3. import com.rabbitmq.client.Channel;
  4. import org.springframework.amqp.core.Message;
  5. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  6. import org.springframework.stereotype.Component;
  7.  
  8. @Component
  9. public class UnfairConsumer {
  10.     // 消费者1
  11.     @RabbitListener(queues = "boot_queue")
  12.     public void listenMessage1(Message message, Channel channel) throws Exception {
  13.         //1.获取消息
  14.         System.out.println("消费者1:"+new String(message.getBody(),"UTF-8"));
  15.         //2. 处理业务逻辑
  16.         Thread.sleep(500); // 消费者1处理快
  17.         //3. 手动签收
  18.         channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);
  19.     }
  20.  
  21.  
  22.     // 消费者2
  23.     @RabbitListener(queues = "boot_queue")
  24.     public void listenMessage2(Message message, Channel channel) throws Exception {
  25.         //1.获取消息
  26.         System.out.println("消费者2:"+new String(message.getBody(),"UTF-8"));
  27.         //2. 处理业务逻辑
  28.         Thread.sleep(3000);// 消费者2处理慢
  29.         //3. 手动签收
  30.         channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);
  31.     }
  32. }
  1. 消费者2:send message...1
  2. 消费者1:send message...0
  3. 19:53:21.676 INFO  ---  [main           ] com.zj.DemoApplication                            :Started DemoApplication in 0.867 seconds (JVM running for 1.259)
  4. 消费者1:send message...3
  5. 消费者1:send message...4
  6. 消费者1:send message...2
  7. 消费者1:send message...5
  8. 消费者1:send message...6
  9. 消费者2:send message...7
  10. 消费者1:send message...8
  11. 消费者1:send message...9

发现消费者1消费的要比消费者2消费的多。能者多劳。

6.3 设置队列所有消息存活时间

 RabbitMQ可以设置消息的存活时间（Time To Live，简称TTL），当消息到达存活时间后还没有被消费，会被移出队列。RabbitMQ可以对队列的所有消息设置存活时间，也可以对某条消息设置存活时间。

1、在创建队列时设置其存活时间：

  1.     // 创建队列
  2.     @Bean(QUEUE_NAME)
  3.     public Queue getMessageQueue() {
  4.         return QueueBuilder
  5.                 .durable(QUEUE_NAME)// 队列名
  6.                 .ttl(10000)      //队列存活时间10s单位毫秒
  7.                 .build();
  8.     }

2、生产者生产消息

  1. @SpringBootTest
  2. class DemoApplicationTests {
  3.  
  4.  
  5.     @Resource
  6.     public RabbitTemplate rabbitTemplate;
  7.  
  8.     @Test
  9.     public void testSendBatch() {
  10.         // 发送十条消息
  11.         for (int i = 0; i < 10; i++) {
  12.             rabbitTemplate.convertAndSend("boot_topic_exchange", "message", "send message..."+i);
  13.         }
  14.     }
  15. }

十秒后，未被消费的消息会被移除。

6.4 设置单条消息存活时间

1、在消息发送的时候设置发送时间

  1.     /*发送消息并设置消息的存活时间*/
  2.     @Test
  3.     public void testSend() {
  4.         //1.创建消息属性
  5.         MessageProperties messageProperties = new MessageProperties();
  6.  
  7.         //2.设置存活时间,单位毫秒
  8.         messageProperties.setExpiration("10000");
  9.  
  10.         //3.创建消息对象
  11.         Message message = new Message(("send message……").getBytes(), messageProperties);
  12.  
  13.         //4.发送消息
  14.         rabbitTemplate.convertAndSend("boot_topic_exchange","message",message);
  15.     }

注意：

  1. 如果设置了单条消息的存活时间，也设置了队列的存活时间，以时间短的为准。

  2. 消息过期后，并不会马上移除消息，只有消息消费到队列顶端时，才会移除该消息。

6.5 优先级队列

假设在电商系统中有一个订单催付的场景，即客户在一段时间内未付款会给用户推送一条短信提醒，但是系统中分为大型商家和小型商家。比如像苹果，小米这样大商家一年能给我们创造很大的利润，所以在订单量大时，他们的订单必须得到优先处理，此时就需要为不同的消息设置不同的优先级，此时我们要使用优先级队列。

 优先级队列用法如下：

1、设置队列的优先级

  1.     // 创建队列
  2.     @Bean(QUEUE_NAME)
  3.     public Queue getMessageQueue() {
  4.         return QueueBuilder
  5.                 .durable(QUEUE_NAME)// 队列名
  6.                // .ttl(10000)      //队列中消息存活时间10s单位毫秒
  7.                 .maxPriority(10)  //设置队列的优先级越大优先级越高，最大255，推荐最大不超过10
  8.                 .build();
  9.     }

2、编写生产者发送有优先级的消息

  1. @SpringBootTest
  2. class DemoApplicationTests {
  3.  
  4.  
  5.     @Resource
  6.     public RabbitTemplate rabbitTemplate;
  7.  
  8.  
  9.     @Test
  10.     public void testSend() {
  11.         for (int i = 0; i < 10; i++) {
  12.             if (i == 5) { // i为5时消息的优先级较高
  13.                 //1.创建消息属性
  14.                 MessageProperties messageProperties = new MessageProperties();
  15.                 //2.设置消息优先级
  16.                 messageProperties.setPriority(9);
  17.                 //3.创建消息对象
  18.                 Message message = new Message(("send message……" + i).getBytes(), messageProperties);
  19.                 rabbitTemplate.convertAndSend("boot_topic_exchange","message",message);
  20.             }else {
  21.                 rabbitTemplate.convertAndSend("boot_topic_exchange","message","send message……" + i);
  22.             }
  23.         }
  24.     }
  25. }

3、编写消费者测试是否是第五条消息最先被消费

  1. package com.zj.consumer;
  2.  
  3. import com.rabbitmq.client.Channel;
  4. import org.springframework.amqp.core.Message;
  5. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  6. import org.springframework.stereotype.Component;
  7.  
  8. import java.io.IOException;
  9.  
  10.  
  11. @Component
  12. public class Consumer {
  13.     // 监听队列
  14.     @RabbitListener(queues = "boot_queue")
  15.     public void listen_message(Message message, Channel channel) throws IOException {
  16.        //1.获取消息
  17.         System.out.println(new String(message.getBody()));
  18.         //2.手动签收
  19.         channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);
  20.     }
  21. }
  1.   .   ____          _            __ _ _
  2.  /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
  3. ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
  4.  \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  5.   '  |____| .__|_| |_|_| |_\__, | / / / /
  6.  =========|_|==============|___/=/_/_/_/
  7.  :: Spring Boot ::                (v2.7.0)
  9. 17:47:14.858 INFO  ---  [main           ] com.zj.DemoApplication                            :Starting DemoApplication using Java 1.8.0_341 on ZHANGJIN with PID 26080 (D:\Java\code\springbootcode\sb_rabbitMQ_consumer\target\classes started by 张锦 in D:\Java\code\springbootcode\sb_rabbitMQ)
  10. 17:47:14.858 INFO  ---  [main           ] com.zj.DemoApplication                            :No active profile set, falling back to 1 default profile: "default"
  11. 17:47:15.482 INFO  ---  [main           ] o.s.a.rabbit.connection.CachingConnectionFactory  :Attempting to connect to: [192.168.66.100:5672]
  12. 17:47:15.498 INFO  ---  [main           ] o.s.a.rabbit.connection.CachingConnectionFactory  :Created new connection: rabbitConnectionFactory#2f2bf0e2:0/SimpleConnection@27f0ad19 [delegate=amqp://MQzhang@192.168.66.100:5672/, localPort= 53985]
  13. 17:47:15.529 INFO  ---  [main           ] com.zj.DemoApplication                            :Started DemoApplication in 0.893 seconds (JVM running for 1.338)
  14. send message……5
  15. send message……0
  16. send message……1
  17. send message……2
  18. send message……3
  19. send message……4
  20. send message……6
  21. send message……7
  22. send message……8
  23. send message……9

第五条消息首先被消费。

七、RabbitMQ死信队列

7.1 概念

在MQ中，当消息成为死信（Dead message）后，消息中间件可以将其从当前队列发送到另一个队列中，这个队列就是死信队列。而在RabbitMQ中，由于有交换机的概念，实际是将死信发送给了死信交换机（Dead Letter Exchange，简称DLX）。死信交换机和死信队列和普通的没有区别。

消息成为死信的情况：

  1. 队列消息长度到达限制。
  2. 消费者拒签消息，并且不把消息重新放入原队列。
  3. 消息到达存活时间未被消费。

 7.2 代码实现

1、创建死信交换机和死信队列

  1. package com.zj.config;
  2.  
  3. import org.springframework.amqp.core.*;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7.  
  8. @Configuration
  9. public class RabbitConfig {
  10.  
  11.     //死信交换机和死信队列
  12.     private final String DEAD_EXCHANGE = "dead_exchange";
  13.     private final String DEAD_QUEUE = "dead_queue";
  14.  
  15.  
  16.     //普通交换机和普通队列
  17.     private final String NORMAL_EXCHANGE = "normal_exchange";
  18.     private final String NORMAL_QUEUE = "normal_queue";
  19.  
  20.  
  21.     // 创建死信交换机
  22.     @Bean(DEAD_EXCHANGE)
  23.     public Exchange deadExchange(){
  24.         return ExchangeBuilder
  25.                 .topicExchange(DEAD_EXCHANGE) //死信交换机类型和名称
  26.                 .durable(false)   //是否持久化
  27.                 .build();
  28.     }
  29.  
  30.     // 创建死信队列
  31.     @Bean(DEAD_QUEUE)
  32.     public Queue deadQueue(){
  33.         return QueueBuilder
  34.                 .durable(DEAD_QUEUE)   //死信队列名称
  35.                 .build();
  36.     }
  37.  
  38.     // 死信交换机绑定死信队列
  39.     @Bean
  40.     public Binding bindDeadQueue(@Qualifier(DEAD_EXCHANGE) Exchange exchange,
  41.                                  @Qualifier(DEAD_QUEUE) Queue queue){
  42.          return BindingBuilder
  43.                  .bind(queue)
  44.                  .to(exchange)
  45.                  .with("dead")     //交换机路由键
  46.                  .noargs();
  47.     }
  48.  
  49.     //创建普通交换机
  50.     @Bean(NORMAL_EXCHANGE)
  51.     public Exchange normalExchange(){
  52.         return ExchangeBuilder
  53.                 .topicExchange(NORMAL_EXCHANGE) //普通交换机类型和名称
  54.                 .durable(false)   //是否持久化
  55.                 .build();
  56.     }
  57.     //创建普通队列
  58.     @Bean(NORMAL_QUEUE)
  59.     public Queue normalQueue(){
  60.         return QueueBuilder
  61.                 .durable(NORMAL_QUEUE)   //普通信队列名称
  62.                 .deadLetterExchange(DEAD_EXCHANGE)  //绑定死信交换机，因为队列中的无法消费的信息会被放到死信交换机上。
  63.                 .deadLetterRoutingKey("dead")   //死信队列路由关键字
  64.                 .ttl(10000)  //消息存活时间
  65.                 .maxLength(10)  //消息最大长度
  66.                 .build();
  67.     }
  68.     //普通交换机绑定普通对列
  69.     @Bean
  70.     public Binding bindNormalQueue(@Qualifier(NORMAL_EXCHANGE) Exchange exchange,
  71.                                  @Qualifier(NORMAL_QUEUE) Queue queue){
  72.         return BindingBuilder
  73.                 .bind(queue)
  74.                 .to(exchange)
  75.                 .with("normal")
  76.                 .noargs();
  77.     }
  78. }

2.创建生产者发送消息（测试存活时间过期变成死信）

  1.     @Test
  2.     public void testSend() {
  3.         //存活时间过期或者超过消息的长度时消息会变成死信队列，消息被消费者退回后队列没有签收消息会变成死信
  4.         //1.存活时间过期
  5.         rabbitTemplate.convertAndSend("normal_exchange","normal","普通队列消息");
  6.     }

十秒后

消息全部去了死信队列。

2.创建生产者（超过队列长度变成死信）

  1. @SpringBootTest
  2. class DemoApplicationTests {
  3.  
  4.  
  5.     @Resource
  6.     public RabbitTemplate rabbitTemplate;
  7.  
  8.  
  9.     @Test
  10.     public void testSend() {
  11.         //存活时间过期或者超过消息的长度时消息会变成死信队列，消息被消费者退回后队列没有签收消息会变成死信
  12.         //1.存活时间过期
  13. //        rabbitTemplate.convertAndSend("normal_exchange","normal","普通队列消息");
  14.         //2.超过队列长度变成死信
  15.         for (int i = 0; i < 20; i++) {
  16.             rabbitTemplate.convertAndSend("normal_exchange","normal","普通队列消息");
  17.         }
  18.     }
  19. }

因为设置了普通队列的长度，所以超出队列长度的那部分就去了死信队列。也设置了队列的存活时间，因此普通队列的消息在10秒后变成了死信。

 2.创建生产者和消费者（超过队列长度变成死信）

  1. @SpringBootTest
  2. class DemoApplicationTests {
  3.  
  4.  
  5.     @Resource
  6.     public RabbitTemplate rabbitTemplate;
  7.  
  8.  
  9.     @Test
  10.     public void testSend() {
  11.         //存活时间过期或者超过消息的长度时消息会变成死信队列，消息被消费者退回后队列没有签收消息会变成死信
  12.         //1.生产者拒签消息，消息变成死信。
  13.         rabbitTemplate.convertAndSend("normal_exchange","normal","普通队列消息");
  14.     }
  15. }
  16.  
  17.  
  18.  
  19.  
  20. @Component
  21. public class Consumer {
  22.  
  23.     // 监听队列
  24.     @RabbitListener(queues = "normal_queue")
  25.     public void listen_message(Message message, Channel channel) throws IOException {
  26.        //拒签消息
  27.         channel.basicNack(message.getMessageProperties().getDeliveryTag(),true,false);
  28.     }
  29. }

拒签消息，消息变成了死信。

 八、RabbitMQ延迟队列

8.1 概念

延迟队列，即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费。

例如：用户下单后，30分钟后查询订单状态，未支付则会取消订单。

 但RabbitMQ中并未提供延迟队列功能，我们可以使用死信队列实现延迟队列的效果。

8.2 死信队列实现延迟队列

 1.创建SpringBoot订单模块，添加SpringMVC、RabbitMQ、lombok依赖。

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-amqp</artifactId>
  4. </dependency>
  5. <dependency>
  6.   <groupId>org.springframework.boot</groupId>
  7.   <artifactId>spring-boot-starter-web</artifactId>
  8. </dependency>
  9. <dependency>
  10.   <groupId>org.projectlombok</groupId>
  11.   <artifactId>lombok</artifactId>
  12. </dependency>

2.编写配置文件

  1. spring:
  2.   rabbitmq:
  3.     host: 192.168.66.100
  4.     port: 5672
  5.     username: MQzhang
  6.     password: MQzhang
  7.     virtual-host: /
  8.    
  9.  
  10.  
  11. #日志格式
  12. logging:
  13.   pattern:
  14.     console: '%d{HH:mm:ss.SSS} %clr(%-5level) ---  [%-15thread] %cyan(%-50logger{50}):%msg%n'
  15.

 3.创建队列和交换机

  1. package com.zj.config;
  2.  
  3. import org.springframework.amqp.core.*;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7.  
  8. @Configuration
  9. public class RabbitConfig {
  10.     // 订单交换机和队列
  11.     private final String ORDER_EXCHANGE = "order_exchange";
  12.     private final String ORDER_QUEUE = "order_queue";
  13.     // 过期订单交换机和队列（死信交换机和死信队列）
  14.     private final String EXPIRE_EXCHANGE = "expire_exchange";
  15.     private final String EXPIRE_QUEUE = "expire_queue";
  16.  
  17.     // 过期订单交换机
  18.     @Bean(EXPIRE_EXCHANGE)
  19.     public Exchange deadExchange(){
  20.         return ExchangeBuilder
  21.                 .topicExchange(EXPIRE_EXCHANGE)
  22.                 .durable(false)
  23.                 .build();
  24.     }
  25.     // 过期订单队列
  26.     @Bean(EXPIRE_QUEUE)
  27.     public Queue deadQueue(){
  28.         return QueueBuilder
  29.                 .durable(EXPIRE_QUEUE)
  30.                 .build();
  31.     }
  32.     // 将过期订单队列绑定到交换机
  33.     @Bean
  34.     public Binding bindDeadQueue(@Qualifier(EXPIRE_EXCHANGE) Exchange exchange,@Qualifier(EXPIRE_QUEUE) Queue queue){
  35.         return BindingBuilder
  36.                 .bind(queue)
  37.                 .to(exchange)
  38.                 .with("expire_routing")
  39.                 .noargs();
  40.     }
  41.  
  42.     // 订单交换机
  43.     @Bean(ORDER_EXCHANGE)
  44.     public Exchange normalExchange(){
  45.         return ExchangeBuilder
  46.                 .topicExchange(ORDER_EXCHANGE)
  47.                 .durable(false)
  48.                 .build();
  49.     }
  50.  
  51.     // 订单队列
  52.     @Bean(ORDER_QUEUE)
  53.     public Queue normalQueue(){
  54.         return QueueBuilder
  55.                 .durable(ORDER_QUEUE)
  56.                 .ttl(10000) // 存活时间为10s,模拟30min
  57.                 .deadLetterExchange(EXPIRE_EXCHANGE) // 绑定死信交换机
  58.                 .deadLetterRoutingKey("expire_routing") // 死信交换机的路由关键字
  59.                 .build();
  60.     }
  61.     // 将订单队列绑定到交换机
  62.     @Bean
  63.     public Binding bindNormalQueue(@Qualifier(ORDER_EXCHANGE) Exchange exchange,
  64.                                    @Qualifier(ORDER_QUEUE) Queue queue){
  65.         return BindingBuilder
  66.                 .bind(queue)
  67.                 .to(exchange)
  68.                 .with("order_routing")
  69.                 .noargs();
  70.     }
  71. }

4.编写下单的控制器方法，下单后向订单交换机发送消息

  1. @RestController
  2. public class OrderController {
  3.  
  4.     @Resource
  5.     private RabbitTemplate rabbitTemplate;
  6.  
  7.     //下单
  8.     @GetMapping("/place/{id}")
  9.     public String placeOrder(@PathVariable("id") String id){
  10.         System.out.println("处理订单数据");
  11.         //将订单id发送到订单队列
  12.         rabbitTemplate.convertAndSend("order_exchange","order_routing",id);
  13.         return "下单成功，修改库存。";
  14.     }
  15. }

 5.编写监听死信队列的消费者

  1. @Component
  2. public class Consumer {
  3.  
  4.     // 监听过期队列
  5.     @RabbitListener(queues = "expire_queue")
  6.     public void listen_message(String id)  {
  7.         System.out.println("查询订单号为："+id+"的订单，如果已支付无需处理，未支付回退库存。 ");
  8.     }
  9. }

8.3 插件实现延迟队列

 在使用死信队列实现延迟队列时，会遇到一个问题：RabbitMQ只会移除队列顶端的过期消息，如果第一个消息的存活时长较长，而第二个消息的存活时长较短，则第二个消息并不会及时执行。

RabbitMQ虽然本身不能使用延迟队列，但官方提供了延迟队列插件，安装后可直接使用延迟队列。

1、使用xftpj将延迟插件上传到虚拟机

2.安装插件

  1. # 将插件放入RabbitMQ插件目录中
  2. mv rabbitmq_delayed_message_exchange-3.9.0.ez /usr/local/rabbitmq/plugins/
  3. # 启用插件
  4. rabbitmq-plugins enable rabbitmq_delayed_message_exchange

3.重启RabbitMQ服务

  1. #停止rabbitmq
  2. rabbitmqctl stop
  3.  
  4.  
  5. #启动rabbitmq
  6. rabbitmq-server restart -detached

 此时登录管控台可以看到交换机类型多了延迟消息：

 4、创建延迟交换机和延迟队列

  1. package com.zj.config;
  2.  
  3.  
  4. import org.springframework.amqp.core.*;
  5. import org.springframework.beans.factory.annotation.Qualifier;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8.  
  9. import java.util.HashMap;
  10.  
  11. @Configuration
  12. public class RabbitConfig {
  13.  
  14.     // 创建延迟交换机和延迟队列
  15.     private final String DELAYED_EXCHANGE = "delayed_exchange";
  16.     private final String DELAYED_QUEUE = "delayed_queue";
  17.  
  18.     // 延迟交换机，ExchangeBuilder只能创建普通的交换机例如：topic、direct、fanout交换机。要创建延迟交换机只能创建自定义交换机。
  19.     @Bean(DELAYED_EXCHANGE)
  20.     public Exchange deadExchange(){
  21.         HashMap<String, Object> args = new HashMap<>();
  22.         args.put("x-delayed-type","topic"); //topic:延迟交换机的实际类型。
  23.         return new CustomExchange(DELAYED_EXCHANGE,"x-delayed-message",false,true,args);
  24.     }
  25.     // 延迟队列
  26.     @Bean(DELAYED_QUEUE)
  27.     public Queue deadQueue(){
  28.         return QueueBuilder
  29.                 .durable(DELAYED_QUEUE)
  30.                 .build();
  31.     }
  32.  
  33.     // 将延迟队列绑定到延迟交换机
  34.     @Bean
  35.     public Binding bindExchangeQueue(@Qualifier(DELAYED_EXCHANGE) Exchange exchange,
  36.                                      @Qualifier(DELAYED_QUEUE) Queue queue){
  37.         return BindingBuilder
  38.                 .bind(queue)
  39.                 .to(exchange)
  40.                 .with("delayed-routing")
  41.                 .noargs();
  42.     }
  43.     
  44. }

5.编写下单的控制器方法

  1. package com.zj.controller;
  2.  
  3. import org.springframework.amqp.AmqpException;
  4. import org.springframework.amqp.core.Message;
  5. import org.springframework.amqp.core.MessagePostProcessor;
  6. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  7. import org.springframework.web.bind.annotation.GetMapping;
  8. import org.springframework.web.bind.annotation.PathVariable;
  9. import org.springframework.web.bind.annotation.RestController;
  10.  
  11. import javax.annotation.Resource;
  12.  
  13. @RestController
  14. public class OrderController {
  15.  
  16.     @Resource
  17.     private RabbitTemplate rabbitTemplate;
  18.  
  19.     //下单
  20.     @GetMapping("/place/{id}")
  21.     public String placeOrder(@PathVariable("id") String id){
  22.         System.out.println("处理订单数据");
  23.         //设置消息的延迟时间为10s
  24.         MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
  25.  
  26.             @Override
  27.             public Message postProcessMessage(Message message) throws AmqpException {
  28.                 message.getMessageProperties().setDelay(10000);
  29.                 return message;
  30.             }
  31.         };
  32.  
  33.         rabbitTemplate.convertAndSend("delayed_exchange","delayed-routing",id,messagePostProcessor);
  34.         return "下单成功，修改库存。";
  35.     }
  36. }

6.编写延迟队列的消费者

  1. package com.zj.consumer;
  2.  
  3. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  4. import org.springframework.stereotype.Component;
  5.  
  6.  
  7. @Component
  8. public class Consumer {
  9.  
  10.     // 监听延迟队列
  11.     @RabbitListener(queues = "delayed_queue")
  12.     public void listen_message(String id)  {
  13.         System.out.println("查询订单号为："+id+"的订单，如果已支付无需处理，未支付回退库存。 ");
  14.     }
  15. }

7、下单测试

 延迟队列中没有消息是因为消费者将消息消费了。

 九、RabbitMQ集群（暂略）

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/716789
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号