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

RabbitMQ详细教程以及SpringBoot集成RabbitMQ_rabbitmq springboot

作者：空白诗007 | 2024-08-18 04:37:49

赞

踩

rabbitmq springboot

目录

一、RabbitMQ简介

1.1、RabbitMQ主流的原因

1.2、RabbitMQ特点

1.3、常见MQ对比

1.3.1、ActiveMQ

1.3.2、RabbitMQ

1.3.3、RocketMQ

1.3.4、Kafka

1.4、AMQP协议

1.4.1、AMQP协议介绍

1.4.2、AMQP协议图解​编辑 

1.4.3、AMQP协议的核心概念- Exchange

1.5、Exchange详细解析

1.5.1、Exchange的作用

1.5.2、Exchange四种类型详解

1.5.3、总结

1.6、RabbitMQ快速安装

1.6.1、windows安装

1.6.2、Mac安装RabbitMQ

1.6.3、linux安装RabbitMQ

1.6.4、网页端管理工具介绍

1.6.5、命令行管理(rabbitmq安装目录的sbin目录下)

二、RabbitMQ基本用法 

2.1、队列和交换机绑定

2.1.1、Java代码测试配置队列和交换机绑定

2.2、生产者发送消息

2.2.1、direct模式

2.2.2、fanout模式

2.2.3、topic模式

2.3、消费者消费消息

2.3.1、direct模式

2.3.2、fanout模式

2.3.3、topic模式

三、RabbitMQ高级特性

3.1、RabbitMQ如何保证消息的可靠性

3.2、 发送端确认机制

3.2.1、三种确认机制及其实现方式

3.3、消息返回机制。

3.3.1、开启消息返回

3.4、消费端限流机制（RabbitMQ-QoS）。

3.5、消费端确认机制。

3.5.1、消费端自动ACK（默认情况）

3.5.2、消费端手动ACK

3.5.3、重回队列

3.6、消息过期机制。

3.6.1、TTL介绍

3.6.2、如何找到适合自己的TTL

3.6.3、设置单条消息的过期时间

3.6.4、设置队列中所有消息的过期时间

3.7、死信队列。

3.7.1、死信队列应用场景

3.7.2、什么是死信队列

3.7.3 、消息怎么变成死信

3.7.4、死信队列设置方法

3.7.5、死信队列示例代码 

3.8、总结

3.8.1、善用RabbitMQ高级特性

3.8.2、慎用RabbitMQ高级特性

3.8.3、善用RabbitMQ管控台

四、SpringBoot集成RabbitMQ

 4.1、Spring AMQP四大特性

4.1.1、异步消息监听容器。

4.1.2、原生提供RabbitTemplate,方便收发消息。

4.1.3、原生提供RabbitAdmin,方便队列、交换机声明。

4.1.4、Spring Boot Config 原生支持RabbitMQ。

4.2、利用RabbitAdmin快速配置Rabbit服务

4.2.1、RabbitAdmin

4.2.2、RabbitAdmin功能

4.2.3、代码实现 

4.3、利用RabbitTemplate快速消息发送

4.3.1、RabbitTemplate简介

4.3.2、配置RabbitTemplate

4.3.3、RabbitTemplate发送消息

4.3.4、RabbitTemplate实现发送端确认、消息返回

4.3.5、SimpleMessageListenerContainer接收消息

4.3.6、利用MessageListenerAdapter自定义消息监听

4.3.7、利用MessageConverter高效处理消息

4.3.8、利用RabbitListener快速实现消息处理器

4.3.9、SpringBoot配置rabbitmq

五、RabbitMQ集群高可用

5.1、RabbitMQ集群高可用好处

5.2、RabbitMQ集群搭建

5.2.1、RabbitMQ集群搭建概述

5.2.2、集群架构拓扑 ​编辑

5.2.3、RabbitMQ集群搭建步骤

一、RabbitMQ简介

1.1、RabbitMQ主流的原因

RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。

1.2、RabbitMQ特点

RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。RabbitMQ的可靠性是非常好的，数据能够保证百分之百的不丢失。可以使用镜像队列，它的稳定性非常好。所以说在我们互联网的金融行业。对数据的稳定性和可靠性要求都非常高的情况下，我们都会选择RabbitMQ。当然没有kafka性能好，但是要比AvtiveMQ性能要好很多。也可以自己做一些性能的优化。 

RabbitMQ可以构建异地双活架构，包括每一个节点存储方式可以采用磁盘或者内存的方式。

1.3、常见MQ对比

1.3.1、ActiveMQ

它的单机吞吐量是万级，一些小的项目已经够用了，但对于高并发的互联网项目完全不够看。在高可用上，使用的主从架构的实现。在消息可靠性上，有较低的概率会丢失数据。社区活跃度低，迭代慢。

1.3.2、RabbitMQ

它的单机吞吐量也是万级，对于需要支持特别高的并发的情况，它是无法担当重任的。在高可用上，它使用的是镜像集群模式，可以保证高可用。在消息可靠性上，它是可以保证数据不丢失的，这也是它的一大优点。同时它也支持一些消息中间件的高级功能，如：消息重试、死信队列等。社区活跃度高，应用广泛。

1.3.3、RocketMQ

教程地址：Rocket详细教程_爱学习的zhangzhang的博客-CSDN博客_rocket使用

它是阿里开源的消息中间件，久经沙场，非常靠谱。它支持高吞吐量，能达到10万级，能承受互联网项目高并发的挑战。在高可用上，它使用的是分布式架构，可以搭建大规模集群，性能很高。在消息可靠性上，通过配置，可以保证数据的绝对不丢失。同时它支持大量的高级功能，如：延迟消息、事务消息、消息回溯、死信队列等等。它非常适合应用于java系统架构中，因为它使用java语言开发的，我们可以去阅读源码了解更深的底层原理。目前来看，它没有什么特别的缺点，可以支持高并发下的技术挑战，可以基于它实现分布式事务，大型互联网公司和中小型公司都可以选择使用它来作为消息中间件使用，如果我来做技术选型，我首选的中间件就是它。社区活跃度高，更新快。

1.3.4、Kafka

kafka的吞吐量被公认为中间件中的翘楚，单机可以支持十几万的并发，相当强悍。在高可用上同样支持分布式集群部署。在消息可靠性上，如果保证异步的性能，可能会出现消息丢失的情况，因为它保存消息时是先存到磁盘缓冲区的，如果机器出现故障，缓冲区的数据是可能丢失的。它的功能非常的单一，就是消息的接收与发送，因此不适合应用于许多场景。它在行业内主要应用于大数据领域，使用它进行用户行为日志的采集和计算，来实现比如“猜你喜欢”的功能。所以，如果没有大数据的需求，一般不会选择它。

1.4、AMQP协议

1.4.1、AMQP协议介绍

AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有RabbitMQ               

1.4.2、AMQP协议图解 

Broker： 接受和分发消息的应用，RabbitMQ就是MessageBroker。

Virtual Host：虚拟Broker，将多个单元隔离开。

Connection：publisher/consumer和broker之间的TCP连接。

Channel：connection内部建立的逻辑连接，通常每个线程创建单独的channel。

RoutingKey：路由键，用来指示消息的路由转发，相当于快递的地址。

Exchange：交换机，相当于快递的分拨中心。

Queue：消息队列，消息最终被送到这里等待consumer取走。

Binding：exchange和queue之间的虚拟连接，用于message的分发依据。

1.4.3、AMQP协议的核心概念- Exchange

在AMQP协议或者是RabbitMQ实现中，最核心的组件是Exchange，Exchange承担RabbitMQ的核心功能-路由转发，Exchange有多个种类，配置多变。

1.5、Exchange详细解析

1.5.1、Exchange的作用

  1. Exchange是AMQP协议和RabbitMQ的核心组件。
  2. Exchange的功能是根据绑定关系和路由键为消息提供路由，将消息转发至相应的队列 。
  3. Exchange有四种类型：Direct/Topic/Fanout/Headers，其中Headers使用很少，以前三种为主。

1.5.2、Exchange四种类型详解

Direct Exchange：Message中的Routing Key如果和Binding Key一致，Direct Exchange则将message发到对应的queue中。

 Fanout Exchange：每个发到Fanout Exchange的message都会分发到所有绑定的queue上去。

  1. Topit Exchange：根据Routing Key及通配规则，Topic Exchange将消息分发到目标Queue中。
  2. 全匹配：与Direct类似。
  3. Binding Key中的 #：匹配任意个数的word。
  4. Binding Key中的 *：匹配任意一个word。

 举例子：

1.5.3、总结

  1. AMQP协议直接决定了RabbitMQ的内部结构和外部行为。
  2. 对于发送者来说，将消息发送给特定的Exchange。
  3. 消息经过Exchange路由后，到达具体队列。
  4. 消费者将消息从监听的队列中取走。
  5. Exchange主要有三种类型：Direct/Topic/Fanout。
  6. Direct（直接路由）：Routing Key = Binding Key，容易配置和使用。
  7. Fanout（广播路由）：群发绑定的所有队列，适用于消息广播。
  8. Topic（话题路由）：功能较为复杂，但能降级为Direct，建议优先使用，为以后拓展留余地。

1.6、RabbitMQ快速安装

1.6.1、windows安装

1、下载安装Erlang OTP(Open Telecom Platform)：Downloads - Erlang/OTPThe official home of the Erlang Programming Languageicon-default.png?t=N7T8https://www.erlang.org/downloads

2、下载并安装RabbitMQ：Messaging that just works — RabbitMQicon-default.png?t=N7T8https://www.rabbitmq.com/Get Started ->DownLoad+Installation ->Windows Installer ->Using the official installer

3、安装完成后，查看系统服务中会出现RabbitMQ。 

1.6.2、Mac安装RabbitMQ

1、使用brew工具安装，会自动安装OTP依赖。

brew install rabbitmq

2、启动/关闭rabbitmq

  1. ## 启动rabbitmq
  2. brew services start rabbitmq
  3.  
  4. ## 关闭rabbitmq
  5. brew services stop rabbitmq

3、浏览器访问地址，账号/密码默认guest

4、开启消息追踪（查看历史消息）

  1. # 查看所有安装插件列表
  2. rabbitmq-plugins list
  3. # 开启插件
  4. rabbitmq-plugins enable rabbitmq_tracing
  5. # 开启插件
  6. rabbitmqctl trace_on
  7. # 添加trace给我们的虚拟主机地址 myhost
  8. rabbitmqctl trace_on -p myhost

添加完成后我们的网页控制台下面将多出一个trace交换机,后续所有该虚拟地址下的消息都会在该交换机上进行记录。 

登录rabbitmq控制台，在Admin>Tracing 目录下添加trace追踪文件信息。添加完成后右侧出现相应的追踪信息文件。

1.6.3、linux安装RabbitMQ

1、使用docker安装（开发环境使用docker简单安装配置）

docker run -it --rm --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:3-management

2、生产环境安装RabbitMQ

1.6.4、网页端管理工具介绍

1、启动（在rabbitmq的sbin目录）

rabbitmq-plugins enable rabbitmq_management

2、浏览器访问：127.0.0.1:15672，账号/密码默认guest

1.6.5、命令行管理(rabbitmq安装目录的sbin目录下)

口诀：

        想看什么就List什么。

        想清空什么就purge什么。

        想删除什么就Delete什么。

        一切问题记得使用 --help什么。

1、查看相关的命令

  1. 查看状态：
  2. rabbitmqctl status
  3. 查看绑定：
  4. rabbitmqctl list_bindings
  5. 查看channel：
  6. rabbitmqctl list_channels
  7. 查看connection：
  8. rabbitmqctl list_connections
  9. 查看消费者：
  10. rabbitmqctl list_consumers
  11. 查看交换机：
  12. rabbitmqctl list_exchanges

 2、队列相关的命令

  1. 查看队列：
  2. rabbitmqctl list_queues
  3. 删除队列：
  4. rabbitmqctl list_queues
  5. 清空队列：
  6. rabbitmqctl list_queues

3、用户相关的命令

  1. 新建用户：
  2. rabbitmqctl add_user
  3. 修改用户密码：
  4. rabbitmqctl change_password
  5. 删除用户：
  6. rabbitmqctl delete_user
  7. 查看用户：
  8. rabbitmqctl list_users
  9. 设置用户角色： 
  10. rabbitmqctl set_user_tags

4、应用启停相关的命令

  1. 启动应用：
  2. rabbitmqctl start_app
  3. 关闭应用：
  4. rabbitmqctl stop_app ，保留Erlang虚拟机（暂停）
  5. 关闭应用：
  6. rabbitmqctl stop_app ，并关闭Erlang虚拟机

5、集群相关的命令

  1. 加入集群
  2. rabbitmqctl join_cluster
  3. 离开集群
  4. rabbitmqctl reset

6、镜像队列相关的命令

  1. 设置镜像队列：
  2. rabbitmqctl sync_queue
  3. 取消镜像队列：
  4. rabbitmqctl cancel_sync_queue

二、RabbitMQ基本用法 

2.1、队列和交换机绑定

  1. @Slf4j
  2. @Service
  3. public class OrderMessageService {
  4.     
  5.  
  6.     /**
  7.      * 设置 交换机、队列、交换机和队列绑定
  8.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  9.      *
  10.      * @throws IOException
  11.      * @throws TimeoutException
  12.      * @throws InterruptedException
  13.      */
  14.     @Async
  15.     public void handleMessage() throws IOException, TimeoutException, InterruptedException {
  16.         log.info("start linstening message");
  17.         ConnectionFactory connectionFactory = new ConnectionFactory();
  18.  
  19.         connectionFactory.setHost("localhost");
  20.  
  21.         try (Connection connection = connectionFactory.newConnection();
  22.              Channel channel = connection.createChannel()) {
  23.  
  24.             /*---------------------交换机 初始化----------------------*/
  25.             channel.exchangeDeclare(
  26.                     "exchange.order.restaurant",  //exchange名称。
  27.                     BuiltinExchangeType.DIRECT, //exchange类型。 DIRECT("direct"), FANOUT("fanout"), TOPIC("topic"), HEADERS("headers");
  28.                     true,   //是否持久化。
  29.                     false,  //空闲了，是否删除交换机。
  30.                     null);  //特殊的属性，没有传递null。
  31.  
  32.  
  33.             /*---------------------队列初始化---------------------*/
  34.             channel.queueDeclare(
  35.                     "queue.order",  //queue的名称。
  36.                     true,   //是否持久化。
  37.                     false,  //是否是connection独占。
  38.                     false,  //空闲了，是否删除队列。
  39.                     null);  //特殊的属性，没有传递null。
  40.  
  41.  
  42.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  43.             channel.queueBind(
  44.                     "queue.order", //队列名称
  45.                     "exchange.order.restaurant",    //exchange名称
  46.                     "key.order"); //Routing key名称。
  47.  
  48.             
  49.         }
  50.     }
  51. }

2.1.1、Java代码测试配置队列和交换机绑定

  1.     /**
  2.      * 调用设置 交换机、队列、交换机和队列绑定方法
  3.      * @param args
  4.      * @throws IOException
  5.      * @throws InterruptedException
  6.      * @throws TimeoutException
  7.      */
  8.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  9.         handleMessage();
  10.     }

2.2、生产者发送消息

三种模式不清楚可参考：1.5.2、Exchange四种类型详解

2.2.1、direct模式

  1. public class OrderService {
  2.  
  3.     /**
  4.      * 测试生产消息
  5.      * @throws IOException
  6.      * @throws InterruptedException
  7.      * @throws TimeoutException
  8.      */
  9.     public static void testSendMessage() throws IOException, TimeoutException {
  10.         //log.info("发送消息");
  11.         ConnectionFactory connectionFactory = new ConnectionFactory();
  12.         connectionFactory.setHost("localhost");
  13.  
  14.         try (Connection connection = connectionFactory.newConnection();
  15.              Channel channel = connection.createChannel()) {
  16.             String messageToSend = "test two";
  17.             //direct模式，routing key必须一致才可以被消费
  18.             channel.basicPublish("exchange.order.test.two", "key.order", null, messageToSend.getBytes());
  19.         }
  20.     }
  21.  
  22.     public static void main(String[] args) throws IOException, TimeoutException {
  23.         testSendMessage();
  24.     }
  25. }

2.2.2、fanout模式

  1. public class OrderService {
  2.  
  3.     /**
  4.      * 测试生产消息
  5.      * @throws IOException
  6.      * @throws InterruptedException
  7.      * @throws TimeoutException
  8.      */
  9.     public static void testSendMessage() throws IOException, TimeoutException {
  10.         //log.info("发送消息");
  11.         ConnectionFactory connectionFactory = new ConnectionFactory();
  12.         connectionFactory.setHost("localhost");
  13.  
  14.         try (Connection connection = connectionFactory.newConnection();
  15.              Channel channel = connection.createChannel()) {
  16.             String messageToSend = "test two";
  17.             //fanout模式，routing key不一致也可以被消费
  18.             channel.basicPublish("exchange.order.test.two", "key.order1", null, messageToSend.getBytes());
  19.         }
  20.     }
  21.  
  22.     public static void main(String[] args) throws IOException, TimeoutException {
  23.         testSendMessage();
  24.     }
  25. }

2.2.3、topic模式

  1. public class OrderService {
  2.  
  3.     /**
  4.      * 测试生产消息
  5.      * @throws IOException
  6.      * @throws InterruptedException
  7.      * @throws TimeoutException
  8.      */
  9.     public static void testSendMessage() throws IOException, TimeoutException {
  10.         //log.info("发送消息");
  11.         ConnectionFactory connectionFactory = new ConnectionFactory();
  12.         connectionFactory.setHost("localhost");
  13.  
  14.         try (Connection connection = connectionFactory.newConnection();
  15.              Channel channel = connection.createChannel()) {
  16.             String messageToSend = "test two";
  17.             channel.basicPublish("exchange.order.test.four", "key.order.test", null, messageToSend.getBytes());
  18.         }
  19.     }
  20.  
  21.     public static void main(String[] args) throws IOException, TimeoutException {
  22.         testSendMessage();
  23.     }
  24. }

2.3、消费者消费消息

三种模式不清楚可参考：1.5.2、Exchange四种类型详解

2.3.1、direct模式

  1. public class OrderMessageService {
  2.  
  3.  
  4.     /**
  5.      * 设置 交换机、队列、交换机和队列绑定
  6.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  7.      *
  8.      * @throws IOException
  9.      * @throws TimeoutException
  10.      * @throws InterruptedException
  11.      */
  12.     public static void handleMessage() throws IOException, TimeoutException {
  13.         log.info("start linstening message");
  14.         ConnectionFactory connectionFactory = new ConnectionFactory();
  15.  
  16.         connectionFactory.setHost("localhost");
  17.  
  18.         try (Connection connection = connectionFactory.newConnection();
  19.              Channel channel = connection.createChannel()) {
  20.  
  21.             /*---------------------交换机 初始化----------------------*/
  22.             channel.exchangeDeclare(
  23.                     "exchange.order.test.two",  //exchange名称。
  24.                     BuiltinExchangeType.DIRECT, //exchange类型。 DIRECT("direct"), FANOUT("fanout"), TOPIC("topic"), HEADERS("headers");
  25.                     true,   //是否持久化。
  26.                     false,  //空闲了，是否删除交换机。
  27.                     null);  //特殊的属性，没有传递null。
  28.  
  29.  
  30.             /*---------------------队列初始化---------------------*/
  31.             channel.queueDeclare(
  32.                     "queue.order",  //queue的名称。
  33.                     true,   //是否持久化。
  34.                     false,  //是否是connection独占。
  35.                     false,  //空闲了，是否删除队列。
  36.                     null);  //特殊的属性，没有传递null。
  37.  
  38.  
  39.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  40.             channel.queueBind(
  41.                     "queue.order", //队列名称
  42.                     "exchange.order.test.two",    //exchange名称
  43.                     "key.order"); //Routing key名称。
  44.  
  45.  
  46.             channel.basicConsume("queue.order",true, new DefaultConsumer(channel){
  47.                 @Override
  48.                 public void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties, byte[] body) throws IOException{
  49.                     //5.处理消息
  50.                     String message = new String(body);
  51.                     log.info("deliverCallback:messageBody:{}", message);
  52.                 }
  53.             });
  54.             while (true){
  55.                 Thread.sleep(100000);
  56.             }
  57.         }
  58.     }
  59.  
  60.  
  61.  
  62.     /**
  63.      * 调用设置 交换机、队列、交换机和队列绑定方法
  64.      * @param args
  65.      * @throws IOException
  66.      * @throws InterruptedException
  67.      * @throws TimeoutException
  68.      */
  69.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  70.         handleMessage();
  71.     }
  72.  
  73.  
  74.  
  75. }

2.3.2、fanout模式

  1. public class OrderMessageService {
  2.  
  3.  
  4.     /**
  5.      * 设置 交换机、队列、交换机和队列绑定
  6.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  7.      *
  8.      * @throws IOException
  9.      * @throws TimeoutException
  10.      * @throws InterruptedException
  11.      */
  12.     public static void handleMessage() throws IOException, TimeoutException {
  13.         log.info("start linstening message");
  14.         ConnectionFactory connectionFactory = new ConnectionFactory();
  15.  
  16.         connectionFactory.setHost("localhost");
  17.  
  18.         try (Connection connection = connectionFactory.newConnection();
  19.              Channel channel = connection.createChannel()) {
  20.  
  21.             /*---------------------交换机 初始化----------------------*/
  22.             channel.exchangeDeclare(
  23.                     "exchange.order.test.two",  //exchange名称。
  24.                     BuiltinExchangeType.DIRECT, //exchange类型。 DIRECT("direct"), FANOUT("fanout"), TOPIC("topic"), HEADERS("headers");
  25.                     true,   //是否持久化。
  26.                     false,  //空闲了，是否删除交换机。
  27.                     null);  //特殊的属性，没有传递null。
  28.  
  29.  
  30.             /*---------------------队列初始化---------------------*/
  31.             channel.queueDeclare(
  32.                     "queue.order",  //queue的名称。
  33.                     true,   //是否持久化。
  34.                     false,  //是否是connection独占。
  35.                     false,  //空闲了，是否删除队列。
  36.                     null);  //特殊的属性，没有传递null。
  37.  
  38.  
  39.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  40.             channel.queueBind(
  41.                     "queue.order", //队列名称
  42.                     "exchange.order.test.two",    //exchange名称
  43.                     "key.order"); //Routing key名称。
  44.  
  45.  
  46.             channel.basicConsume("queue.order",true, new DefaultConsumer(channel){
  47.                 @Override
  48.                 public void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties, byte[] body) throws IOException{
  49.                     //5.处理消息
  50.                     String message = new String(body);
  51.                     log.info("deliverCallback:messageBody:{}", message);
  52.                 }
  53.             });
  54.             while (true){
  55.                 Thread.sleep(100000);
  56.             }
  57.         }
  58.     }
  59.  
  60.  
  61.  
  62.     /**
  63.      * 调用设置 交换机、队列、交换机和队列绑定方法
  64.      * @param args
  65.      * @throws IOException
  66.      * @throws InterruptedException
  67.      * @throws TimeoutException
  68.      */
  69.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  70.         handleMessage();
  71.     }
  72.  
  73.  
  74.  
  75. }

2.3.3、topic模式

  1. public class OrderMessageService {
  2.  
  3.  
  4.     /**
  5.      * 设置 交换机、队列、交换机和队列绑定
  6.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  7.      *
  8.      * @throws IOException
  9.      * @throws TimeoutException
  10.      * @throws InterruptedException
  11.      */
  12.     public static void handleMessage() throws IOException, TimeoutException, InterruptedException {
  13.         log.info("start linstening message");
  14.         ConnectionFactory connectionFactory = new ConnectionFactory();
  15.  
  16.         connectionFactory.setHost("localhost");
  17.  
  18.         try (Connection connection = connectionFactory.newConnection();
  19.              Channel channel = connection.createChannel()) {
  20.  
  21.             /*---------------------交换机 初始化----------------------*/
  22.             channel.exchangeDeclare(
  23.                     "exchange.order.test.four",  //exchange名称。
  24.                     BuiltinExchangeType.TOPIC, //exchange类型。 DIRECT("direct"), FANOUT("fanout"), TOPIC("topic"), HEADERS("headers");
  25.                     true,   //是否持久化。
  26.                     false,  //空闲了，是否删除交换机。
  27.                     null);  //特殊的属性，没有传递null。
  28.  
  29.  
  30.             /*---------------------队列初始化---------------------*/
  31.             channel.queueDeclare(
  32.                     "queue.order",  //queue的名称。
  33.                     true,   //是否持久化。
  34.                     false,  //是否是connection独占。
  35.                     false,  //空闲了，是否删除队列。
  36.                     null);  //特殊的属性，没有传递null。
  37.  
  38.  
  39.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  40.             channel.queueBind(
  41.                     "queue.order", //队列名称
  42.                     "exchange.order.test.four",    //exchange名称
  43.                     "key.order.test"); //Routing key名称。key.# ,key.order.*,key.order.test 都可消费
  44.  
  45.  
  46.             channel.basicConsume("queue.order",true, new DefaultConsumer(channel){
  47.                 @Override
  48.                 public void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties, byte[] body) throws IOException{
  49.                     //5.处理消息
  50.                     String message = new String(body);
  51.                     log.info("deliverCallback:messageBody:{}", message);
  52.                 }
  53.             });
  54.             while (true){
  55.                 Thread.sleep(100000);
  56.             }
  57.         }
  58.     }
  59.  
  60.  
  61.  
  62.     /**
  63.      * 调用设置 交换机、队列、交换机和队列绑定方法
  64.      * @param args
  65.      * @throws IOException
  66.      * @throws InterruptedException
  67.      * @throws TimeoutException
  68.      */
  69.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  70.         handleMessage();
  71.     }
  72.  
  73.  
  74.  
  75. }

三、RabbitMQ高级特性

3.1、RabbitMQ如何保证消息的可靠性

  1. 发送端确认机制。
  2. 消息返回机制。
  3. 消费端限流机制。
  4. 消费端确认机制。
  5. 消息过期机制。
  6. 死信队列。

3.2、 发送端确认机制

3.2.1、三种确认机制及其实现方式

单条同步确认：

  1. 配置channel，开启确认模式：channel.confirmSelect()。
  2. 每发送一条消息，调用channel.waitForConfirms()方法，等待确认。返回true/false（ure表示成功，false表示失败）

生产者代码示例

  1.     /**
  2.      * 测试生产消息
  3.      * @throws IOException
  4.      * @throws InterruptedException
  5.      * @throws TimeoutException
  6.      */
  7.     public static void testSendMessage() throws IOException, TimeoutException, InterruptedException {
  8.         log.info("发送消息");
  9.         ConnectionFactory connectionFactory = new ConnectionFactory();
  10.         connectionFactory.setHost("localhost");
  11.  
  12.         try (Connection connection = connectionFactory.newConnection();
  13.              Channel channel = connection.createChannel()) {
  14.             channel.confirmSelect(); //开启发送端确认机制
  15.             String messageToSend = "test";
  16.             channel.basicPublish("exchange.order.test", "key.order", null, messageToSend.getBytes());
  17.             log.info("message is send");
  18.             if (channel.waitForConfirms()) { //调用channel.waitForConfirms()方法，等待确认。返回true/false（ure表示成功，false表示失败）
  19.                 log.info("RabbitMQ confirm success");
  20.             }else {
  21.                 log.info("RabbitMQ confirm error");
  22.  
  23.             }
  24.         }
  25.     }
  26.  
  27.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  28.         testSendMessage();
  29.     }

多条同步确认：

  1. 配置channel，开启确认模式：channel.confirmSelect()。
  2. 发送多条消息后，调用channel.waitForConfirms()方法，等待确认。返回true/false（ture表示成功，false不是所有消息都失败，只是表示发送的多条消息其中有失败的）

生产者代码示例

  1.     /**
  2.      * 测试生产消息
  3.      * @throws IOException
  4.      * @throws InterruptedException
  5.      * @throws TimeoutException
  6.      */
  7.     public static void testSendMessage() throws IOException, TimeoutException, InterruptedException {
  8.         log.info("发送消息");
  9.         ConnectionFactory connectionFactory = new ConnectionFactory();
  10.         connectionFactory.setHost("localhost");
  11.  
  12.         try (Connection connection = connectionFactory.newConnection();
  13.              Channel channel = connection.createChannel()) {
  14.             channel.confirmSelect(); //开启发送端确认机制
  15.             String messageToSend = "test";
  16.             for (int i = 0; i < 10; i++) {
  17.                 channel.basicPublish("exchange.order.test", "key.order", null, messageToSend.getBytes());
  18.                 log.info("message is send");
  19.             }
  20.             if (channel.waitForConfirms()) { //调用channel.waitForConfirms()方法，等待确认。返回true/false（ure表示成功，false表示失败）
  21.                 log.info("RabbitMQ confirm success");
  22.             }else {
  23.                 log.info("RabbitMQ confirm error");
  24.  
  25.             }
  26.         }
  27.     }
  28.  
  29.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  30.         testSendMessage();
  31.     }

异步确认： 

  1. 配置channel，开启确认模式：channel.confirmSelect()。
  2. 在channel上添加监听：addConfirmListener，发送消息后，会回调此方法，通知是否发送成功。
  3. 异步确认有可能是单条，也有可能是多条，取决于MQ。

生产者代码示例： 

  1. /**
  2.      * 测试生产消息
  3.      * @throws IOException
  4.      * @throws InterruptedException
  5.      * @throws TimeoutException
  6.      */
  7.     public static void testSendMessage() throws IOException, TimeoutException, InterruptedException {
  8.         log.info("发送消息");
  9.         ConnectionFactory connectionFactory = new ConnectionFactory();
  10.         connectionFactory.setHost("localhost");
  11.  
  12.         try (Connection connection = connectionFactory.newConnection();
  13.              Channel channel = connection.createChannel()) {
  14.             channel.confirmSelect(); //开启发送端确认机制
  15.             ConfirmListener confirmListener = new ConfirmListener() {
  16.                 //消息发送成功了调用
  17.                 @Override
  18.                 public void handleAck(long l, boolean b) throws IOException {
  19.  
  20.                     log.info("消息发送成功 Ack deliveryTag [{}],multiple[{}]",l,b);
  21.                 }
  22.  
  23.                 //消息发送失败了调用
  24.                 @Override
  25.                 public void handleNack(long l, boolean b) throws IOException {
  26.                     log.info("Nack deliveryTag [{}],multiple[{}]",l,b);
  27.  
  28.                 }
  29.             };
  30.             channel.addConfirmListener(confirmListener);
  31.             String messageToSend = "test";
  32.             for (int i = 0; i < 10; i++) {
  33.                 channel.basicPublish("exchange.order.test", "key.order", null, messageToSend.getBytes());
  34.                 log.info("message is send");
  35.             }
  36.             Thread.sleep(1000000);
  37.         }
  38.     }
  39.  
  40.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  41.         testSendMessage();
  42.     }

3.3、消息返回机制。

3.3.1、开启消息返回

  1. 在RabbitMQ基础配置中有一个关键配置项：Mandatory。
  2. Mandatory若为false，RabbitMQ将直接丢弃无法路由消息。
  3. Mandatory若为true，RabbitMQ才会处理无法路由消息。
  4. 消息发送后，中间件会对消息进行路由，若队列中没有发现目标队列，中间件会通知发送方，channel.addReturnListener()方法 ，传递的ReturnListener对象或者ReturnCallback对象 会被调用（ReturnListener是消息返回对象的属性当作参数传递，ReturnCallback是传递得是消息返回对象，可以自行get/set）。

示例代码（在网页控制台 中unbind exchange bindings 对应的队列后执行）：

  1.   /**
  2.      * 测试生产消息
  3.      * @throws IOException
  4.      * @throws InterruptedException
  5.      * @throws TimeoutException
  6.      */
  7.     public static void testSendMessage() throws IOException, TimeoutException, InterruptedException {
  8.         log.info("发送消息");
  9.         ConnectionFactory connectionFactory = new ConnectionFactory();
  10.         connectionFactory.setHost("localhost");
  11.  
  12.         try (Connection connection = connectionFactory.newConnection();
  13.              Channel channel = connection.createChannel()) {
  14.             //消息发送失败 返回告知发送方调用的方法
  15.             channel.addReturnListener(new ReturnListener() {
  16.                 @Override
  17.                 public void handleReturn(int i, String s, String s1, String s2, AMQP.BasicProperties basicProperties, byte[] bytes) throws IOException {
  18.                     log.info("Message Return : replyCode:[{}],replyText:[{}],exchange:[{}],routingKey:[{}],properties[{}],body[{}]"
  19.                             ,i,s,s1,s2,basicProperties,bytes);
  20.                 }
  21.             });
  22.             消息发送失败 返回告知发送方调用的方法（传递的对象）
  23.             //channel.addReturnListener(new ReturnCallback() {
  24.             //    @Override
  25.             //    public void handle(Return aReturn) {
  26.             //        log.info("Message Return : aReturn");
  27.             //
  28.             //    }
  29.             //});
  30.  
  31.             String messageToSend = "test";
  32.                 channel.basicPublish("exchange.order.test", "key.order", true,null, messageToSend.getBytes());
  33.                 log.info("message is send");
  34.  
  35.             Thread.sleep(1000000);
  36.         }
  37.     }
  38.  
  39.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  40.         testSendMessage();
  41.     }

3.4、消费端限流机制（RabbitMQ-QoS）。

使用场景：

业务高峰期，可能出现发送端与接口端性能不一致，大量的消息被同时推送给接收端，造成接收端服务崩溃。需要使用RabbitMQ消费端限流机制，限制消息推送速度，保障接收端服务稳定。

QoS介绍：

QoS功能保证了在一定数目的消息未被确认前，不消费新的消息。

QoS功能的前提是不使用自动确认。

QoS原理:

QoS原理是当消费端有一定数量的消息未被ACK确定时，RabbitMQ不给消费端推送新的消息。

RabbitMQ使用QoS机制实现了消费端限流。

消费端限流机制参数设置

  1. prefetchCount：针对一个消费端最多推送多少未确认消息。
  2. global：true:针对整个消费端限流；false:针对当前channel；。
  3. prefetchSize：0（单个消息大小限制，一般为0）。
  4. prefetchSize与global两项，RabbitMQ暂时未实现。

代码示例：

生产者：

  1. public class OrderService {
  2.  
  3.     /**
  4.      * 测试生产消息
  5.      * @throws IOException
  6.      * @throws InterruptedException
  7.      * @throws TimeoutException
  8.      */
  9.     public  void testSendMessage() throws IOException, TimeoutException {
  10.         log.info("发送消息");
  11.         ConnectionFactory connectionFactory = new ConnectionFactory();
  12.         connectionFactory.setHost("localhost");
  13.  
  14.         try (Connection connection = connectionFactory.newConnection();
  15.              Channel channel = connection.createChannel()) {
  16.             String messageToSend = "test";
  17.             for (int i = 0; i < 10; i++) {
  18.                 channel.basicPublish("exchange.order.test", "key.order", null, messageToSend.getBytes());
  19.  
  20.             }
  21.         }
  22.     }
  23.  
  24.     public static void main(String[] args) throws IOException, TimeoutException {
  25.         new OrderService().testSendMessage();
  26.     }
  27. }

消费者：

  1. public class OrderMessageService {
  2.     Channel channel;
  3.  
  4.  
  5.     /**
  6.      * 设置 交换机、队列、交换机和队列绑定
  7.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  8.      *
  9.      * @throws IOException
  10.      * @throws TimeoutException
  11.      * @throws InterruptedException
  12.      */
  13.     public void handleMessage() throws IOException, TimeoutException, InterruptedException {
  14.         log.info("start linstening message");
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.  
  17.         connectionFactory.setHost("localhost");
  18.  
  19.         try (Connection connection = connectionFactory.newConnection();
  20.              Channel channel = connection.createChannel()) {
  21.             this.channel=channel;
  22.             /*---------------------交换机 初始化----------------------*/
  23.             channel.exchangeDeclare(
  24.                     "exchange.order.test",  //exchange名称。
  25.                     BuiltinExchangeType.DIRECT, //exchange类型。
  26.                     true,   //是否持久化。
  27.                     false,  //空闲了，是否删除交换机。
  28.                     null);  //特殊的属性，没有传递null。
  29.  
  30.  
  31.             /*---------------------队列初始化---------------------*/
  32.             channel.queueDeclare(
  33.                     "queue.order",  //queue的名称。
  34.                     true,   //是否持久化。
  35.                     false,  //是否是connection独占。
  36.                     false,  //空闲了，是否删除队列。
  37.                     null);  //特殊的属性，没有传递null。
  38.  
  39.  
  40.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  41.             channel.queueBind(
  42.                     "queue.order", //队列名称
  43.                     "exchange.order.test",    //exchange名称
  44.                     "key.order"); //Routing key名称。
  45.  
  46.             //设置消费端限流
  47.             channel.basicQos(2);//表示同时可以有两条消息在处理中，没有被消费者确认消息。
  48.             channel.basicConsume("queue.order", false, deliverCallback,consumerTag->{});
  49.             while (true) {
  50.                 Thread.sleep(10000);
  51.             }
  52.         }
  53.     }
  54.     DeliverCallback deliverCallback = ((consumerTag, message) -> {
  55.         String messageBody = new String(message.getBody());
  56.         log.info("接收到的信息：[{}]", messageBody);
  57.         try {
  58.             Thread.sleep(3000);
  59.         } catch (InterruptedException e) {
  60.             throw new RuntimeException(e);
  61.         }
  62.         //手动确认消息 multiple参数 false 单条接收  true 多条接收
  63.         channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
  64.  
  65.     });
  66.  
  67.  
  68.     /**
  69.      * 调用设置 交换机、队列、交换机和队列绑定方法
  70.      *
  71.      * @param args
  72.      * @throws IOException
  73.      * @throws InterruptedException
  74.      * @throws TimeoutException
  75.      */
  76.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  77.         new OrderMessageService().handleMessage();
  78.     }
  79.  
  80.  
  81.  
  82. }

运行截图

3.5、消费端确认机制。

3.5.1、消费端自动ACK（默认情况）

解释：消费端收到消息后，会自动签收消息。

3.5.2、消费端手动ACK

解释：消费端收到消息后，不会自动签收消息，需要我们在业务代码中显式签收消息。

手动ACK类型

  1. 单条手动ACK(推荐)：multiple=false

  2. 多条手动ACK：multiple=true

代码示例

生产者：

  1. public class OrderService {
  2.  
  3.     /**
  4.      * 测试生产消息
  5.      * @throws IOException
  6.      * @throws InterruptedException
  7.      * @throws TimeoutException
  8.      */
  9.     public  void testSendMessage() throws IOException, TimeoutException {
  10.         log.info("发送消息");
  11.         ConnectionFactory connectionFactory = new ConnectionFactory();
  12.         connectionFactory.setHost("localhost");
  13.  
  14.         try (Connection connection = connectionFactory.newConnection();
  15.              Channel channel = connection.createChannel()) {
  16.             String messageToSend = "test";
  17.  
  18.             channel.basicPublish("exchange.order.test", "key.order", null, messageToSend.getBytes());
  19.         }
  20.     }
  21.  
  22.     public static void main(String[] args) throws IOException, TimeoutException {
  23.         new OrderService().testSendMessage();
  24.     }
  25. }

消费者：

  1. public class OrderMessageService {
  2.     Channel channel;
  3.  
  4.  
  5.     /**
  6.      * 设置 交换机、队列、交换机和队列绑定
  7.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  8.      *
  9.      * @throws IOException
  10.      * @throws TimeoutException
  11.      * @throws InterruptedException
  12.      */
  13.     public void handleMessage() throws IOException, TimeoutException, InterruptedException {
  14.         log.info("start linstening message");
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.  
  17.         connectionFactory.setHost("localhost");
  18.  
  19.         try (Connection connection = connectionFactory.newConnection();
  20.              Channel channel = connection.createChannel()) {
  21.             this.channel=channel;
  22.             /*---------------------交换机 初始化----------------------*/
  23.             channel.exchangeDeclare(
  24.                     "exchange.order.test",  //exchange名称。
  25.                     BuiltinExchangeType.DIRECT, //exchange类型。
  26.                     true,   //是否持久化。
  27.                     false,  //空闲了，是否删除交换机。
  28.                     null);  //特殊的属性，没有传递null。
  29.  
  30.  
  31.             /*---------------------队列初始化---------------------*/
  32.             channel.queueDeclare(
  33.                     "queue.order",  //queue的名称。
  34.                     true,   //是否持久化。
  35.                     false,  //是否是connection独占。
  36.                     false,  //空闲了，是否删除队列。
  37.                     null);  //特殊的属性，没有传递null。
  38.  
  39.  
  40.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  41.             channel.queueBind(
  42.                     "queue.order", //队列名称
  43.                     "exchange.order.test",    //exchange名称
  44.                     "key.order"); //Routing key名称。
  45.  
  46.  
  47.             channel.basicConsume("queue.order", false, deliverCallback,consumerTag->{});
  48.             while (true) {
  49.                 Thread.sleep(10000);
  50.             }
  51.         }
  52.     }
  53.     DeliverCallback deliverCallback = ((consumerTag, message) -> {
  54.         String messageBody = new String(message.getBody());
  55.         log.info("接收到的信息：[{}]", messageBody);
  56.         //手动确认消息
  57.         channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
  58.  
  59.     });
  60.  
  61.  
  62.     /**
  63.      * 调用设置 交换机、队列、交换机和队列绑定方法
  64.      *
  65.      * @param args
  66.      * @throws IOException
  67.      * @throws InterruptedException
  68.      * @throws TimeoutException
  69.      */
  70.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  71.         new OrderMessageService().handleMessage();
  72.     }
  73.  
  74.  
  75.  
  76. }

运行截图

3.5.3、重回队列

若设置了重回队列，消息被NACK之后，会返回队列末尾，等待进一步被处理。一般不建议开启重回队列，因为第一次处理异常的消息，再次处理，基本上也是异常。

生产者：

  1. public class OrderService {
  2.  
  3.     /**
  4.      * 测试生产消息
  5.      * @throws IOException
  6.      * @throws InterruptedException
  7.      * @throws TimeoutException
  8.      */
  9.     public  void testSendMessage() throws IOException, TimeoutException {
  10.         log.info("发送消息");
  11.         ConnectionFactory connectionFactory = new ConnectionFactory();
  12.         connectionFactory.setHost("localhost");
  13.  
  14.         try (Connection connection = connectionFactory.newConnection();
  15.              Channel channel = connection.createChannel()) {
  16.             String messageToSend = "test";
  17.  
  18.             channel.basicPublish("exchange.order.test", "key.order", null, messageToSend.getBytes());
  19.         }
  20.     }
  21.  
  22.     public static void main(String[] args) throws IOException, TimeoutException {
  23.         new OrderService().testSendMessage();
  24.     }
  25. }

消费者：

  1. public class OrderMessageService {
  2.     Channel channel;
  3.  
  4.  
  5.     /**
  6.      * 设置 交换机、队列、交换机和队列绑定
  7.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  8.      *
  9.      * @throws IOException
  10.      * @throws TimeoutException
  11.      * @throws InterruptedException
  12.      */
  13.     public void handleMessage() throws IOException, TimeoutException, InterruptedException {
  14.         log.info("start linstening message");
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.  
  17.         connectionFactory.setHost("localhost");
  18.  
  19.         try (Connection connection = connectionFactory.newConnection();
  20.              Channel channel = connection.createChannel()) {
  21.             this.channel=channel;
  22.             /*---------------------交换机 初始化----------------------*/
  23.             channel.exchangeDeclare(
  24.                     "exchange.order.test",  //exchange名称。
  25.                     BuiltinExchangeType.DIRECT, //exchange类型。
  26.                     true,   //是否持久化。
  27.                     false,  //空闲了，是否删除交换机。
  28.                     null);  //特殊的属性，没有传递null。
  29.  
  30.  
  31.             /*---------------------队列初始化---------------------*/
  32.             channel.queueDeclare(
  33.                     "queue.order",  //queue的名称。
  34.                     true,   //是否持久化。
  35.                     false,  //是否是connection独占。
  36.                     false,  //空闲了，是否删除队列。
  37.                     null);  //特殊的属性，没有传递null。
  38.  
  39.  
  40.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  41.             channel.queueBind(
  42.                     "queue.order", //队列名称
  43.                     "exchange.order.test",    //exchange名称
  44.                     "key.order"); //Routing key名称。
  45.  
  46.  
  47.             channel.basicConsume("queue.order", false, deliverCallback,consumerTag->{});
  48.             while (true) {
  49.                 Thread.sleep(10000);
  50.             }
  51.         }
  52.     }
  53.     DeliverCallback deliverCallback = ((consumerTag, message) -> {
  54.         String messageBody = new String(message.getBody());
  55.         log.info("接收到的信息：[{}]", messageBody);
  56.         //重回队列
  57.         channel.basicNack(message.getEnvelope().getDeliveryTag(),false,true);
  58.  
  59.     });
  60.  
  61.  
  62.     /**
  63.      * 调用设置 交换机、队列、交换机和队列绑定方法
  64.      *
  65.      * @param args
  66.      * @throws IOException
  67.      * @throws InterruptedException
  68.      * @throws TimeoutException
  69.      */
  70.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  71.         new OrderMessageService().handleMessage();
  72.     }
  73.  
  74.  
  75.  
  76. }

运行截图：

3.6、消息过期机制。

3.6.1、TTL介绍

  1. RabbitMQ的过期时间称为TTL(Time to Live)，生存时间。
  2. RabbitMQ的过期时间分为消息TTL和队列TTL。
  3. 消息TTL设置了单条消息的过期时间。

  4. 队列TTL设置队列中所有消息的过期时间。

3.6.2、如何找到适合自己的TTL

TTL的设置主要考虑技术架构与业务，TTL应该明显长于服务的平均重启时间。建议TTL长于业务高峰期时间。 

3.6.3、设置单条消息的过期时间

生产者： 
  1. public class OrderService {
  2.  
  3.     /**
  4.      * 测试生产消息
  5.      * @throws IOException
  6.      * @throws InterruptedException
  7.      * @throws TimeoutException
  8.      */
  9.     public  void testSendMessage() throws IOException, TimeoutException {
  10.         log.info("发送消息");
  11.         ConnectionFactory connectionFactory = new ConnectionFactory();
  12.         connectionFactory.setHost("localhost");
  13.  
  14.         try (Connection connection = connectionFactory.newConnection();
  15.              Channel channel = connection.createChannel()) {
  16.             String messageToSend = "test";
  17.             //设置消息过期时间
  18.             AMQP.BasicProperties properties=new AMQP.BasicProperties().builder().expiration("15000").build();
  19.             channel.basicPublish("exchange.order.test", "key.order", properties, messageToSend.getBytes());
  20.         }
  21.     }
  22.  
  23.     public static void main(String[] args) throws IOException, TimeoutException {
  24.         new OrderService().testSendMessage();
  25.     }
  26. }

消费者：

  1. public class OrderMessageService {
  2.     Channel channel;
  3.  
  4.  
  5.     /**
  6.      * 设置 交换机、队列、交换机和队列绑定
  7.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  8.      *
  9.      * @throws IOException
  10.      * @throws TimeoutException
  11.      * @throws InterruptedException
  12.      */
  13.     public void handleMessage() throws IOException, TimeoutException, InterruptedException {
  14.         log.info("start linstening message");
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.  
  17.         connectionFactory.setHost("localhost");
  18.  
  19.         try (Connection connection = connectionFactory.newConnection();
  20.              Channel channel = connection.createChannel()) {
  21.             this.channel=channel;
  22.             /*---------------------交换机 初始化----------------------*/
  23.             channel.exchangeDeclare(
  24.                     "exchange.order.test",  //exchange名称。
  25.                     BuiltinExchangeType.DIRECT, //exchange类型。
  26.                     true,   //是否持久化。
  27.                     false,  //空闲了，是否删除交换机。
  28.                     null);  //特殊的属性，没有传递null。
  29.  
  30.  
  31.             /*---------------------队列初始化---------------------*/
  32.             channel.queueDeclare(
  33.                     "queue.order",  //queue的名称。
  34.                     true,   //是否持久化。
  35.                     false,  //是否是connection独占。
  36.                     false,  //空闲了，是否删除队列。
  37.                     null);  //特殊的属性，没有传递null。
  38.  
  39.  
  40.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  41.             channel.queueBind(
  42.                     "queue.order", //队列名称
  43.                     "exchange.order.test",    //exchange名称
  44.                     "key.order"); //Routing key名称。
  45.  
  46.             //设置消费端限流
  47.             channel.basicQos(2);//表示同时可以有两条消息在处理中，没有被消费者确认消息。
  48.             channel.basicConsume("queue.order", false, deliverCallback,consumerTag->{});
  49.             while (true) {
  50.                 Thread.sleep(10000);
  51.             }
  52.         }
  53.     }
  54.     DeliverCallback deliverCallback = ((consumerTag, message) -> {
  55.         String messageBody = new String(message.getBody());
  56.         log.info("接收到的信息：[{}]", messageBody);
  57.         try {
  58.             Thread.sleep(3000);
  59.         } catch (InterruptedException e) {
  60.             throw new RuntimeException(e);
  61.         }
  62.         //手动确认消息 multiple参数 false 单条接收  true 多条接收
  63.         channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
  64.  
  65.     });
  66.  
  67.  
  68.     /**
  69.      * 调用设置 交换机、队列、交换机和队列绑定方法
  70.      *
  71.      * @param args
  72.      * @throws IOException
  73.      * @throws InterruptedException
  74.      * @throws TimeoutException
  75.      */
  76.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  77.         new OrderMessageService().handleMessage();
  78.     }
  79.  
  80.  
  81.  
  82. }

运行截图

3.6.4、设置队列中所有消息的过期时间

生产者：

  1. public class OrderService {
  2.  
  3.     /**
  4.      * 测试生产消息
  5.      * @throws IOException
  6.      * @throws InterruptedException
  7.      * @throws TimeoutException
  8.      */
  9.     public  void testSendMessage() throws IOException, TimeoutException {
  10.         log.info("发送消息");
  11.         ConnectionFactory connectionFactory = new ConnectionFactory();
  12.         connectionFactory.setHost("localhost");
  13.  
  14.         try (Connection connection = connectionFactory.newConnection();
  15.              Channel channel = connection.createChannel()) {
  16.             String messageToSend = "test";
  17.             //设置消息过期时间
  18.             //AMQP.BasicProperties properties=new AMQP.BasicProperties().builder().expiration("15000").build();
  19.             channel.basicPublish("exchange.order.test", "key.order", null, messageToSend.getBytes());
  20.         }
  21.     }
  22.  
  23.     public static void main(String[] args) throws IOException, TimeoutException {
  24.         new OrderService().testSendMessage();
  25.     }
  26. }

消费者：

  1. public class OrderMessageService {
  2.     Channel channel;
  3.  
  4.  
  5.     /**
  6.      * 设置 交换机、队列、交换机和队列绑定
  7.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  8.      *
  9.      * @throws IOException
  10.      * @throws TimeoutException
  11.      * @throws InterruptedException
  12.      */
  13.     public void handleMessage() throws IOException, TimeoutException, InterruptedException {
  14.         log.info("start linstening message");
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.  
  17.         connectionFactory.setHost("localhost");
  18.  
  19.         try (Connection connection = connectionFactory.newConnection();
  20.              Channel channel = connection.createChannel()) {
  21.             this.channel=channel;
  22.             /*---------------------交换机 初始化----------------------*/
  23.             channel.exchangeDeclare(
  24.                     "exchange.order.test",  //exchange名称。
  25.                     BuiltinExchangeType.DIRECT, //exchange类型。
  26.                     true,   //是否持久化。
  27.                     false,  //空闲了，是否删除交换机。
  28.                     null);  //特殊的属性，没有传递null。
  29.             //设置队列中消息的过期时间
  30.             Map<String, Object>  args=new HashMap<>(16);
  31.             args.put("x-message-ttl",15000);
  32.             /*---------------------队列初始化---------------------*/
  33.             channel.queueDeclare(
  34.                     "queue.order",  //queue的名称。
  35.                     true,   //是否持久化。
  36.                     false,  //是否是connection独占。
  37.                     false,  //空闲了，是否删除队列。
  38.                     args);  //特殊的属性，没有传递null。
  39.  
  40.  
  41.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  42.             channel.queueBind(
  43.                     "queue.order", //队列名称
  44.                     "exchange.order.test",    //exchange名称
  45.                     "key.order"); //Routing key名称。
  46.  
  47.             //设置消费端限流
  48.             channel.basicQos(2);//表示同时可以有两条消息在处理中，没有被消费者确认消息。
  49.             channel.basicConsume("queue.order", false, deliverCallback,consumerTag->{});
  50.             while (true) {
  51.                 Thread.sleep(10000);
  52.             }
  53.         }
  54.     }
  55.     DeliverCallback deliverCallback = ((consumerTag, message) -> {
  56.         String messageBody = new String(message.getBody());
  57.         log.info("接收到的信息：[{}]", messageBody);
  58.         try {
  59.             Thread.sleep(3000);
  60.         } catch (InterruptedException e) {
  61.             throw new RuntimeException(e);
  62.         }
  63.         //手动确认消息 multiple参数 false 单条接收  true 多条接收
  64.         channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
  65.  
  66.     });
  67.  
  68.  
  69.     /**
  70.      * 调用设置 交换机、队列、交换机和队列绑定方法
  71.      *
  72.      * @param args
  73.      * @throws IOException
  74.      * @throws InterruptedException
  75.      * @throws TimeoutException
  76.      */
  77.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  78.         new OrderMessageService().handleMessage();
  79.     }
  80.  
  81.  
  82.  
  83. }

3.7、死信队列。

3.7.1、死信队列应用场景

消息被设置了过期时间，过期后会直接被丢弃。直接被丢弃的消息，无法对系统运行异常发出警报，需要使用RabbitMQ死信队列，收集过期消息，以供分析。

3.7.2、什么是死信队列

  1. 死信队列：队列被配置了DLX属性（Dead-Letter-Exchange）
  2. 当一个消息变成死信后，能重新被发布到另一个Exchange，这个Exchange也是一个普通交换机。
  3. 死信被死信交换机路由后，一般进入一个估计队列。

3.7.3 、消息怎么变成死信

  1. 消息被拒绝（reject/nack）并且requeue=false。rejected
  2. 消息过期（TTL到期）。expired
  3. 队列达到最大长度。maxlen

3.7.4、死信队列设置方法

设置转发、接收死信的交换机和队列：

  1. Exchange：dlx.exchange。
  2. Queue：dlx.queue
  3. RoutingKey：#

在需要设置死信的队列加入参数：

  1. x-dead-letter-exchange=dlx.exchange

3.7.5、死信队列示例代码 

消息过期示例：发送消息，不启动死信队列消费者，启动处理死信队列路由的消息的消费者

生产者：

  1. public class OrderService {
  2.  
  3.     /**
  4.      * 测试生产消息
  5.      * @throws IOException
  6.      * @throws InterruptedException
  7.      * @throws TimeoutException
  8.      */
  9.     public  void testSendMessage() throws IOException, TimeoutException {
  10.         log.info("发送消息");
  11.         ConnectionFactory connectionFactory = new ConnectionFactory();
  12.         connectionFactory.setHost("localhost");
  13.  
  14.         try (Connection connection = connectionFactory.newConnection();
  15.              Channel channel = connection.createChannel()) {
  16.             String messageToSend = "test";
  17.             //设置消息过期时间
  18.             //AMQP.BasicProperties properties=new AMQP.BasicProperties().builder().expiration("15000").build();
  19.             channel.basicPublish("exchange.order.test", "key.order", null, messageToSend.getBytes());
  20.         }
  21.     }
  22.  
  23.     public static void main(String[] args) throws IOException, TimeoutException {
  24.         new OrderService().testSendMessage();
  25.     }
  26. }

消费者（死信队列）：

  1. public class OrderMessageService {
  2.     Channel channel;
  3.  
  4.  
  5.     /**
  6.      * 设置 交换机、队列、交换机和队列绑定
  7.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  8.      *
  9.      * @throws IOException
  10.      * @throws TimeoutException
  11.      * @throws InterruptedException
  12.      */
  13.     public void handleMessage() throws IOException, TimeoutException, InterruptedException {
  14.         log.info("start linstening message");
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.  
  17.         connectionFactory.setHost("localhost");
  18.  
  19.         try (Connection connection = connectionFactory.newConnection();
  20.              Channel channel = connection.createChannel()) {
  21.             this.channel=channel;
  22.             /*---------------------交换机 初始化----------------------*/
  23.             channel.exchangeDeclare(
  24.                     "exchange.order.test",  //exchange名称。
  25.                     BuiltinExchangeType.DIRECT, //exchange类型。
  26.                     true,   //是否持久化。
  27.                     false,  //空闲了，是否删除交换机。
  28.                     null);  //特殊的属性，没有传递null。
  29.             Map<String, Object>  args=new HashMap<>(16);
  30.             //设置队列中所有消息的过期时间
  31.             args.put("x-message-ttl",15000);
  32.             //设置队列为死信队列
  33.             args.put("x-dead-letter-exchange","exchange.dlx");
  34.             设置队列最大长度
  35.             //args.put("x-max-length",5);
  36.             /*---------------------队列初始化---------------------*/
  37.             channel.queueDeclare(
  38.                     "queue.order",  //queue的名称。
  39.                     true,   //是否持久化。
  40.                     false,  //是否是connection独占。
  41.                     false,  //空闲了，是否删除队列。
  42.                     args);  //特殊的属性，没有传递null。
  43.  
  44.  
  45.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  46.             channel.queueBind(
  47.                     "queue.order", //队列名称
  48.                     "exchange.order.test",    //exchange名称
  49.                     "key.order"); //Routing key名称。
  50.  
  51.             //设置消费端限流
  52.             //channel.basicQos(2);//表示同时可以有两条消息在处理中，没有被消费者确认消息。
  53.             channel.basicConsume("queue.order", false, deliverCallback,consumerTag->{});
  54.             while (true) {
  55.                 Thread.sleep(10000);
  56.             }
  57.         }
  58.     }
  59.     DeliverCallback deliverCallback = ((consumerTag, message) -> {
  60.         String messageBody = new String(message.getBody());
  61.         log.info("接收到的信息：[{}]", messageBody);
  62.         try {
  63.             Thread.sleep(3000);
  64.         } catch (InterruptedException e) {
  65.             throw new RuntimeException(e);
  66.         }
  67.         重回队列
  68.         //channel.basicNack(message.getEnvelope().getDeliveryTag(),false,true);
  69.         //手动确认消息 multiple参数 false 单条接收  true 多条接收
  70.         channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
  71.  
  72.     });
  73.  
  74.  
  75.     /**
  76.      * 调用设置 交换机、队列、交换机和队列绑定方法
  77.      *
  78.      * @param args
  79.      * @throws IOException
  80.      * @throws InterruptedException
  81.      * @throws TimeoutException
  82.      */
  83.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  84.         new OrderMessageService().handleMessage();
  85.     }
  86.  
  87.  
  88.  
  89. }

处理死信队列路由的消息的消费者：

  1. public class OrderDlxMessageService {
  2.     Channel channel;
  3.  
  4.  
  5.     /**
  6.      * 设置 交换机、队列、交换机和队列绑定
  7.      * 在那个服务处理那个队列，配置别的服务的交换机和绑定关系。
  8.      *
  9.      * @throws IOException
  10.      * @throws TimeoutException
  11.      * @throws InterruptedException
  12.      */
  13.     public void handleMessage() throws IOException, TimeoutException, InterruptedException {
  14.         log.info("start linstening message");
  15.         ConnectionFactory connectionFactory = new ConnectionFactory();
  16.  
  17.         connectionFactory.setHost("localhost");
  18.  
  19.         try (Connection connection = connectionFactory.newConnection();
  20.              Channel channel = connection.createChannel()) {
  21.             this.channel=channel;
  22.             /*---------------------交换机 初始化----------------------*/
  23.             channel.exchangeDeclare(
  24.                     "exchange.dlx",  //exchange名称。
  25.                     BuiltinExchangeType.TOPIC, //exchange类型。
  26.                     true,   //是否持久化。
  27.                     false,  //空闲了，是否删除交换机。
  28.                     null);  //特殊的属性，没有传递null。
  29.  
  30.             /*---------------------队列初始化---------------------*/
  31.             channel.queueDeclare(
  32.                     "exchange.dlx.queue.order",  //queue的名称。
  33.                     true,   //是否持久化。
  34.                     false,  //是否是connection独占。
  35.                     false,  //空闲了，是否删除队列。
  36.                     null);  //特殊的属性，没有传递null。
  37.  
  38.  
  39.             /*---------------------队列、交换机绑定 queue  exchange Bind restaurant---------------------*/
  40.             channel.queueBind(
  41.                     "exchange.dlx.queue.order", //队列名称
  42.                     "exchange.dlx",    //exchange名称
  43.                     "#"); //Routing key名称。
  44.  
  45.             设置消费端限流
  46.             //channel.basicQos(2);//表示同时可以有两条消息在处理中，没有被消费者确认消息。
  47.             channel.basicConsume("exchange.dlx.queue.order", false, deliverCallback,consumerTag->{});
  48.             while (true) {
  49.                 Thread.sleep(10000);
  50.             }
  51.         }
  52.     }
  53.     DeliverCallback deliverCallback = ((consumerTag, message) -> {
  54.         String messageBody = new String(message.getBody());
  55.         log.info("死信接收到的信息：[{}]", messageBody);
  56.         try {
  57.             Thread.sleep(3000);
  58.         } catch (InterruptedException e) {
  59.             throw new RuntimeException(e);
  60.         }
  61.         //手动确认消息 multiple参数 false 单条接收  true 多条接收
  62.         channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
  63.  
  64.     });
  65.  
  66.  
  67.     /**
  68.      * 调用设置 交换机、队列、交换机和队列绑定方法
  69.      *
  70.      * @param args
  71.      * @throws IOException
  72.      * @throws InterruptedException
  73.      * @throws TimeoutException
  74.      */
  75.     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
  76.         new OrderDlxMessageService().handleMessage();
  77.     }
  78.  
  79.  
  80.  
  81. }

 运行截图

 

3.8、总结

3.8.1、善用RabbitMQ高级特性

  1. 对于RabbitMQ的高级特性，要善加利用。
  2. 接收端消息确认，死信队列是非常常用的特性。

3.8.2、慎用RabbitMQ高级特性

  1. 不要无限追求高级，用上所有RabbitMQ的高级特性。
  2. 重回队列、发送端确认是不常用的特性，谨慎使用。

3.8.3、善用RabbitMQ管控台

  1. 管控台时RabbitMQ调试的利器。
  2. RabbitMQ高级特性多数都涉及交换机，队列的属性配置，可以在管控台确认配置是否生效。
  3. RabbitMQ高级特性很多都可以在控制台进行试验。 

四、SpringBoot集成RabbitMQ

 4.1、Spring AMQP四大特性

  1. 异步消息监听容器。
  2. 原生提供RabbitTemplate,方便收发消息。
  3. 原生提供RabbitAdmin,方便队列、交换机声明。
  4. Spring Boot Config 原生支持RabbitMQ。

4.1.1、异步消息监听容器。

  1. 原始实现：自己实现线程池，会调方法，并注册回调方法。
  2. SpringBoot：自动实现可配置的线程池，并自动注册回调方法，只需要实现回调方法。

4.1.2、原生提供RabbitTemplate,方便收发消息。

  1. 相比basicPublish，功能更加强大，能自动实现消息转换等功能。

4.1.3、原生提供RabbitAdmin,方便队列、交换机声明。

  1. 声明时提供队列、交换机、绑定关系的注册方法。
  2. 甚至不需要显式的注册代码。

4.1.4、Spring Boot Config 原生支持RabbitMQ。

  1. 充分发挥SpringBoot约定大于配置的特性。
  2. 可以隐式建立Connection、Channel。

4.2、利用RabbitAdmin快速配置Rabbit服务

4.2.1、RabbitAdmin

  1. RabbitAdmin类用来管理RabbitMQ

4.2.2、RabbitAdmin功能

  1. declareExchange：创建交换机。
  2. deleteExchange：删除交换机。
  3. declareQueue：创建队列。
  4. deleteQueue：删除队列。
  5. purgeQueue：清空队列。
  6. declareBinding：新建绑定关系。
  7. removeBinding：删除绑定关系。
  8. getQueueProperties：查询队列属性。

4.2.3、代码实现 

导入pom.xml

  1. <!-- springboot整合rabbitmq依赖 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-amqp</artifactId>
  5. </dependency>

使用RabbitAdmin创建队列、交换机、交换机绑定对垒（spring amqp封装了之前的声明写法）

  1. @Configuration
  2. public class RabbitConfig {
  3.     
  4.     /**
  5.      * 初始化rabbitmq
  6.      */
  7.     @Autowired
  8.     public void initRabbitmq() {
  9.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
  10.         connectionFactory.setHost("127.0.0.1");
  11.         connectionFactory.setPort(5672);
  12.         RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
  13.         Exchange exchange = new DirectExchange("springboot.rabbitmq-exchange");
  14.         rabbitAdmin.declareExchange(exchange);
  15.         Queue queue = new Queue("springboot.rabbitmq-queue");
  16.         rabbitAdmin.declareQueue(queue);
  17.         Binding binding = new Binding("springboot.rabbitmq-queue",
  18.                 Binding.DestinationType.QUEUE, "springboot.rabbitmq-exchange",
  19.                 "key.springboot.order", null);
  20.         rabbitAdmin.declareBinding(binding);
  21.     }
  22. }

利用RabbitAdmin简化配置Rabbit服务流程 （RabbitAdmin声明式配置）

  1. 将Exchange、Queue、Binding声明为Bean。
  2. 再将RabbitAdmin声明为Bean。
  3. Exchange、Queue、Binding即可自动创建。

RabbitAdmin声明式配置的优点

  1. 将声明和创建工作分开，解耦多人工作。
  2. 不需显示声明，减少代码量，减少Bug。

代码示例：

  1. @Configuration
  2. public class RabbitConfig {
  3.  
  4.  
  5.  
  6.     @Bean
  7.     public Exchange exchange1() {
  8.         return new DirectExchange("springboot.rabbitmq-exchange");
  9.     }
  10.  
  11.     @Bean
  12.     public Queue queue1() {
  13.         return new Queue("springboot.rabbitmq-queue");
  14.     }
  15.  
  16.     @Bean
  17.     public Binding binding1() {
  18.         return new Binding("springboot.rabbitmq-queue",
  19.                 Binding.DestinationType.QUEUE, "springboot.rabbitmq-exchange",
  20.                 "key.springboot.order", null);
  21.     }
  22.  
  23.     @Bean
  24.     public ConnectionFactory connectionFactory() {
  25.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
  26.         connectionFactory.setHost("127.0.0.1");
  27.         connectionFactory.setPort(5672);
  28.         connectionFactory.setPassword("guest");
  29.         connectionFactory.setUsername("guest");
  30.         connectionFactory.createConnection();
  31.         return connectionFactory;
  32.     }
  33.  
  34.     @Bean
  35.     public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
  36.         RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
  37.         rabbitAdmin.setAutoStartup(true);
  38.         return rabbitAdmin;
  39.     }
  40. }

运行截图

4.3、利用RabbitTemplate快速消息发送

4.3.1、RabbitTemplate简介

  1. RabbitTemplate与RestTemplate类似，使用了模版方法设计模式。
  2. RabbitTemplate提供了丰富的功能，方便消息收发。
  3. RabbitTemplate可以显式传入配置也可以隐式声明配置。

4.3.2、配置RabbitTemplate

  1. @Slf4j
  2. @Configuration
  3. public class RabbitConfig {
  4.  
  5.  
  6.  
  7.     @Bean
  8.     public Exchange exchange1() {
  9.         return new DirectExchange("springboot.rabbitmq-exchange");
  10.     }
  11.  
  12.     @Bean
  13.     public Queue queue1() {
  14.         return new Queue("springboot.rabbitmq-queue");
  15.     }
  16.  
  17.     @Bean
  18.     public Binding binding1() {
  19.         return new Binding("springboot.rabbitmq-queue",
  20.                 Binding.DestinationType.QUEUE, "springboot.rabbitmq-exchange",
  21.                 "key.springboot.order", null);
  22.     }
  23.  
  24.     @Bean
  25.     public ConnectionFactory connectionFactory() {
  26.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
  27.         connectionFactory.setHost("127.0.0.1");
  28.         connectionFactory.setPort(5672);
  29.         connectionFactory.setPassword("guest");
  30.         connectionFactory.setUsername("guest");
  31.         connectionFactory.createConnection();
  32.         return connectionFactory;
  33.     }
  34.  
  35.     @Bean
  36.     public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
  37.         RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
  38.         rabbitAdmin.setAutoStartup(true);
  39.         return rabbitAdmin;
  40.     }
  41.     @Bean
  42.     public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
  43.         return new RabbitTemplate(connectionFactory);
  44.     }
  45. }

4.3.3、RabbitTemplate发送消息

  1. @Service
  2. @Slf4j
  3. public class OrderTemplateService {
  4.     @Autowired
  5.     private RabbitTemplate rabbitTemplate;
  6.  
  7.     /**
  8.      * 测试生产消息
  9.      * @throws IOException
  10.      * @throws InterruptedException
  11.      * @throws TimeoutException
  12.      */
  13.     public  void testSendMessage()  {
  14.         log.info("发送消息");
  15.         //新方式发送消息
  16.         String messageToSend = "test";
  17.         //MessageProperties messageProperties=new MessageProperties();
  18.         //messageProperties.setExpiration("1500");
  19.         //Message message=new Message(messageToSend.getBytes(),messageProperties);
  20.         //消息体需要是Message对象
  21.         //rabbitTemplate.send("exchange.order.test", "key.order", message);
  22.         //消息体需要是Object类型（自动转换后发送）
  23.         rabbitTemplate.convertAndSend("exchange.order.test", "key.order", messageToSend);
  24.     }
  25.  
  26. }

4.3.4、RabbitTemplate实现发送端确认、消息返回

修改配置RabbitConfig中的connectionFactory配置(开启发送端确认、消息返回)，配置rabbitTemplate设置发送端确认、消息返回)

  1. @Slf4j
  2. @Configuration
  3. public class RabbitConfig {
  4.  
  5.  
  6.  
  7.     @Bean
  8.     public Exchange exchange1() {
  9.         return new DirectExchange("springboot.rabbitmq-exchange");
  10.     }
  11.  
  12.     @Bean
  13.     public Queue queue1() {
  14.         return new Queue("springboot.rabbitmq-queue");
  15.     }
  16.  
  17.     @Bean
  18.     public Binding binding1() {
  19.         return new Binding("springboot.rabbitmq-queue",
  20.                 Binding.DestinationType.QUEUE, "springboot.rabbitmq-exchange",
  21.                 "key.springboot.order", null);
  22.     }
  23.  
  24.     @Bean
  25.     public ConnectionFactory connectionFactory() {
  26.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
  27.         connectionFactory.setHost("127.0.0.1");
  28.         connectionFactory.setPort(5672);
  29.         connectionFactory.setPassword("guest");
  30.         connectionFactory.setUsername("guest");
  31.         //开启发送端确认
  32.         connectionFactory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);//SIMPLE=简单的;CORRELATED=相关的;NONE=关闭b;
  33.         //开启消息返回
  34.         connectionFactory.setPublisherReturns(true);
  35.         connectionFactory.createConnection();
  36.         return connectionFactory;
  37.     }
  38.  
  39.     @Bean
  40.     public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
  41.         RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
  42.         rabbitAdmin.setAutoStartup(true);
  43.         return rabbitAdmin;
  44.     }
  45.     @Bean
  46.     public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
  47.         RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
  48.  
  49.         rabbitTemplate.setMandatory(true);
  50.         //消息返回
  51.         rabbitTemplate.setReturnCallback((message, i, s, s1, s2) -> {
  52.             log.info("消息返回实现，message：{},replyCode：{},replyText：{},exchange：{},routingKey：{}", message, i, s, s1, s2);
  53.         });
  54.         //发送端确认
  55.         rabbitTemplate.setConfirmCallback((correlationData, b, s) -> {
  56.             log.info("发送端确认，correlationData：{},ack：{},cause：{}", correlationData, b, s);
  57.  
  58.         });
  59.         return rabbitTemplate;
  60.     }
  61. }

发送消息（设置消息id，可以追溯哪一条确认了）

  1. @Service
  2. @Slf4j
  3. public class OrderTemplateService {
  4.     @Autowired
  5.     private RabbitTemplate rabbitTemplate;
  6.  
  7.     /**
  8.      * 测试生产消息
  9.      * @throws IOException
  10.      * @throws InterruptedException
  11.      * @throws TimeoutException
  12.      */
  13.     public  void testSendMessage()  {
  14.         log.info("发送消息");
  15.         //新方式发送消息
  16.         String messageToSend = "test";
  17.         //MessageProperties messageProperties=new MessageProperties();
  18.         //messageProperties.setExpiration("1500");
  19.         //Message message=new Message(messageToSend.getBytes(),messageProperties);
  20.         //消息体需要是Message对象
  21.         //rabbitTemplate.send("exchange.order.test", "key.order", message);
  22.         //消息体需要是Object类型（自动转换后发送）
  23.         //发送消息时，指定消息id;消息确认时，接收指定消息id
  24.         CorrelationData correlationData=new CorrelationData();
  25.         correlationData.setId("12388891231239192");
  26.         rabbitTemplate.convertAndSend("exchange.order.test", "key.order", messageToSend,correlationData);
  27.     }
  28.  
  29. }

运行结果（消息返回测试，可以设置个没有的RoutingKey）

4.3.5、SimpleMessageListenerContainer接收消息

RabbitConfig

  1. @Slf4j
  2. @Configuration
  3. public class RabbitConfig {
  4.  
  5.  
  6.  
  7.     @Bean
  8.     public Exchange exchange1() {
  9.         return new DirectExchange("springboot.rabbitmq-exchange");
  10.     }
  11.  
  12.     @Bean
  13.     public Queue queue1() {
  14.         return new Queue("springboot.rabbitmq-queue");
  15.     }
  16.  
  17.     @Bean
  18.     public Binding binding1() {
  19.         return new Binding("springboot.rabbitmq-queue",
  20.                 Binding.DestinationType.QUEUE, "springboot.rabbitmq-exchange",
  21.                 "key.springboot.order", null);
  22.     }
  23.  
  24.     @Bean
  25.     public ConnectionFactory connectionFactory() {
  26.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
  27.         connectionFactory.setHost("127.0.0.1");
  28.         connectionFactory.setPort(5672);
  29.         connectionFactory.setPassword("guest");
  30.         connectionFactory.setUsername("guest");
  31.         //开启发送端确认
  32.         connectionFactory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);//SIMPLE=简单的;CORRELATED=相关的;NONE=关闭b;
  33.         //开启消息返回
  34.         connectionFactory.setPublisherReturns(true);
  35.         connectionFactory.createConnection();
  36.         return connectionFactory;
  37.     }
  38.  
  39.     @Bean
  40.     public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
  41.         RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
  42.         rabbitAdmin.setAutoStartup(true);
  43.         return rabbitAdmin;
  44.     }
  45.  
  46.     @Bean
  47.     public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
  48.         RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
  49.  
  50.         rabbitTemplate.setMandatory(true);
  51.         //消息返回
  52.         rabbitTemplate.setReturnCallback((message, i, s, s1, s2) -> {
  53.             log.info("消息返回实现，message：{},replyCode：{},replyText：{},exchange：{},routingKey：{}", message, i, s, s1, s2);
  54.         });
  55.         //发送端确认
  56.         rabbitTemplate.setConfirmCallback((correlationData, b, s) -> {
  57.             log.info("发送端确认，correlationData：{},ack：{},cause：{}", correlationData, b, s);
  58.  
  59.         });
  60.         return rabbitTemplate;
  61.     }
  62.  
  63.     @Bean
  64.     public SimpleMessageListenerContainer messageListenerContainer(ConnectionFactory connectionFactory) {
  65.         SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
  66.         //针对哪些队列（参数为可变参数）
  67.         simpleMessageListenerContainer.setQueueNames("springboot.rabbitmq-queue");
  68.         //同时有多少个消费者线程在消费这个队列，相当于线程池的线程数字。
  69.         simpleMessageListenerContainer.setConcurrentConsumers(3);
  70.         //最大的消费者线程数
  71.         simpleMessageListenerContainer.setMaxConcurrentConsumers(5);
  72.         //设置消息确认方式    NONE=不确认,MANUAL=手动确认,AUTO=自动确认;
  73.         //自动确认
  74.         //simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.AUTO);
  75.         //simpleMessageListenerContainer.setMessageListener(message -> log.info("springboot.rabbitmq-queue接收到的消息：[{}]", message));
  76.         //手动确认(单条确认)
  77.         simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.MANUAL);
  78.         simpleMessageListenerContainer.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {
  79.             log.info("springboot.rabbitmq-queue接收到的消息：[{}]", message);
  80.             channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  81.         });
  82.         //消费端限流
  83.         simpleMessageListenerContainer.setPrefetchCount(1);
  84.         return simpleMessageListenerContainer;
  85.     }
  86. }

 消息发送

  1. @Service
  2. @Slf4j
  3. public class OrderTemplateService {
  4.     @Autowired
  5.     private RabbitTemplate rabbitTemplate;
  6.  
  7.     /**
  8.      * 测试生产消息
  9.      * @throws IOException
  10.      * @throws InterruptedException
  11.      * @throws TimeoutException
  12.      */
  13.     public  void testSendMessage()  {
  14.         log.info("发送消息");
  15.         //新方式发送消息
  16.         String messageToSend = "test";
  17.         //MessageProperties messageProperties=new MessageProperties();
  18.         //messageProperties.setExpiration("1500");
  19.         //Message message=new Message(messageToSend.getBytes(),messageProperties);
  20.         //消息体需要是Message对象
  21.         //rabbitTemplate.send("exchange.order.test", "key.order", message);
  22.         //消息体需要是Object类型（自动转换后发送）
  23.         //发送消息时，指定消息id;消息确认时，接收指定消息id
  24.         CorrelationData correlationData=new CorrelationData();
  25.         correlationData.setId("12388891231239192");
  26.         rabbitTemplate.convertAndSend("springboot.rabbitmq-exchange",
  27.                 "key.springboot.order", messageToSend,correlationData);
  28.     }
  29.  
  30. }

运行截图

4.3.6、利用MessageListenerAdapter自定义消息监听

生产者

  1. @Service
  2. @Slf4j
  3. public class OrderTemplateService {
  4.     @Autowired
  5.     private RabbitTemplate rabbitTemplate;
  6.  
  7.     /**
  8.      * 测试生产消息
  9.      * @throws IOException
  10.      * @throws InterruptedException
  11.      * @throws TimeoutException
  12.      */
  13.     public  void testSendMessage()  {
  14.         log.info("发送消息");
  15.         //新方式发送消息
  16.         String messageToSend = "test";
  17.         //MessageProperties messageProperties=new MessageProperties();
  18.         //messageProperties.setExpiration("1500");
  19.         //Message message=new Message(messageToSend.getBytes(),messageProperties);
  20.         //消息体需要是Message对象
  21.         //rabbitTemplate.send("exchange.order.test", "key.order", message);
  22.         //消息体需要是Object类型（自动转换后发送）
  23.         //发送消息时，指定消息id;消息确认时，接收指定消息id
  24.         CorrelationData correlationData=new CorrelationData();
  25.         correlationData.setId("12388891231239192");
  26.         rabbitTemplate.convertAndSend("springboot.rabbitmq-exchange",
  27.                 "key.springboot.order", messageToSend,correlationData);
  28.     }
  29.  
  30. }

配置类RabbitConfig

  1. @Slf4j
  2. @Configuration
  3. public class RabbitConfig {
  4.  
  5.  
  6.     @Resource
  7.     public OrderTemplateMessageService orderTemplateMessageService;
  8.     @Bean
  9.     public Exchange exchange1() {
  10.         return new DirectExchange("springboot.rabbitmq-exchange");
  11.     }
  12.  
  13.     @Bean
  14.     public Queue queue1() {
  15.         return new Queue("springboot.rabbitmq-queue");
  16.     }
  17.  
  18.     @Bean
  19.     public Binding binding1() {
  20.         return new Binding("springboot.rabbitmq-queue",
  21.                 Binding.DestinationType.QUEUE, "springboot.rabbitmq-exchange",
  22.                 "key.springboot.order", null);
  23.     }
  24.  
  25.     @Bean
  26.     public ConnectionFactory connectionFactory() {
  27.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
  28.         connectionFactory.setHost("127.0.0.1");
  29.         connectionFactory.setPort(5672);
  30.         connectionFactory.setPassword("guest");
  31.         connectionFactory.setUsername("guest");
  32.         //开启发送端确认
  33.         connectionFactory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);//SIMPLE=简单的;CORRELATED=相关的;NONE=关闭b;
  34.         //开启消息返回
  35.         connectionFactory.setPublisherReturns(true);
  36.         connectionFactory.createConnection();
  37.         return connectionFactory;
  38.     }
  39.  
  40.     @Bean
  41.     public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
  42.         RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
  43.         rabbitAdmin.setAutoStartup(true);
  44.         return rabbitAdmin;
  45.     }
  46.  
  47.     @Bean
  48.     public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
  49.         RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
  50.  
  51.         rabbitTemplate.setMandatory(true);
  52.         //消息返回
  53.         rabbitTemplate.setReturnCallback((message, i, s, s1, s2) -> {
  54.             log.info("消息返回实现，message：{},replyCode：{},replyText：{},exchange：{},routingKey：{}", message, i, s, s1, s2);
  55.         });
  56.         //发送端确认
  57.         rabbitTemplate.setConfirmCallback((correlationData, b, s) -> {
  58.             log.info("发送端确认，correlationData：{},ack：{},cause：{}", correlationData, b, s);
  59.  
  60.         });
  61.         return rabbitTemplate;
  62.     }
  63.  
  64.     @Bean
  65.     public SimpleMessageListenerContainer messageListenerContainer(ConnectionFactory connectionFactory) {
  66.         SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
  67.         //针对哪些队列（参数为可变参数）
  68.         simpleMessageListenerContainer.setQueueNames("springboot.rabbitmq-queue");
  69.         //同时有多少个消费者线程在消费这个队列，相当于线程池的线程数字。
  70.         simpleMessageListenerContainer.setConcurrentConsumers(3);
  71.         //最大的消费者线程数
  72.         simpleMessageListenerContainer.setMaxConcurrentConsumers(5);
  73.         //设置消息确认方式    NONE=不确认,MANUAL=手动确认,AUTO=自动确认;
  74.         //自动确认
  75.         //simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.AUTO);
  76.         //simpleMessageListenerContainer.setMessageListener(message -> log.info("springboot.rabbitmq-queue接收到的消息：[{}]", message));
  77.         //手动确认(单条确认)
  78.         //simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.MANUAL);
  79.         //simpleMessageListenerContainer.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {
  80.         //    log.info("springboot.rabbitmq-queue接收到的消息：[{}]", message);
  81.         //    //orderTemplateMessageService.handleMessage(message.getBody());
  82.         //    channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  83.         //});
  84.         //监听
  85.         MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(orderTemplateMessageService);
  86.         //解决接收到消息处理业务类方法名称不为handleMessage且需要调用，因为MessageListenerAdapter会调用参数类中的handleMessage方法名称的方法。
  87.         Map<String,String> methodMap=new HashMap<>(16);
  88.         methodMap.put("springboot.rabbitmq-queue","handleMessage");
  89.         messageListenerAdapter.setQueueOrTagToMethodName(methodMap);
  90.         simpleMessageListenerContainer.setMessageListener(messageListenerAdapter);
  91.  
  92.         //消费端限流
  93.         simpleMessageListenerContainer.setPrefetchCount(1);
  94.         return simpleMessageListenerContainer;
  95.     }
  96. }

实现业务类

  1. @Slf4j
  2. @Service
  3. public class OrderTemplateMessageService {
  4.     public void handleMessage(String messageBody) {
  5.         log.info("messageBody:[{}]",messageBody);
  6.     }
  7.  
  8. }

运行截图

4.3.7、利用MessageConverter高效处理消息

配置类RabbitConfig

  1. package com.zhang.config;
  2.  
  3. import com.zhang.dto.MessageVO;
  4. import com.zhang.rabbittemplate.OrderTemplateMessageService;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.amqp.core.*;
  7. import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
  8. import org.springframework.amqp.rabbit.connection.ConnectionFactory;
  9. import org.springframework.amqp.rabbit.core.RabbitAdmin;
  10. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  11. import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
  12. import org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter;
  13. import org.springframework.amqp.support.converter.ClassMapper;
  14. import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
  15. import org.springframework.context.annotation.Bean;
  16. import org.springframework.context.annotation.Configuration;
  17.  
  18. import javax.annotation.Resource;
  19. import java.util.HashMap;
  20. import java.util.Map;
  21.  
  22.  
  23. @Slf4j
  24. @Configuration
  25. public class RabbitConfig {
  26.  
  27.  
  28.     @Resource
  29.     public OrderTemplateMessageService orderTemplateMessageService;
  30.     @Bean
  31.     public Exchange exchange1() {
  32.         return new DirectExchange("springboot.rabbitmq-exchange");
  33.     }
  34.  
  35.     @Bean
  36.     public Queue queue1() {
  37.         return new Queue("springboot.rabbitmq-queue");
  38.     }
  39.  
  40.     @Bean
  41.     public Binding binding1() {
  42.         return new Binding("springboot.rabbitmq-queue",
  43.                 Binding.DestinationType.QUEUE, "springboot.rabbitmq-exchange",
  44.                 "key.springboot.order", null);
  45.     }
  46.  
  47.     @Bean
  48.     public ConnectionFactory connectionFactory() {
  49.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
  50.         connectionFactory.setHost("127.0.0.1");
  51.         connectionFactory.setPort(5672);
  52.         connectionFactory.setPassword("guest");
  53.         connectionFactory.setUsername("guest");
  54.         //开启发送端确认
  55.         connectionFactory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);//SIMPLE=简单的;CORRELATED=相关的;NONE=关闭b;
  56.         //开启消息返回
  57.         connectionFactory.setPublisherReturns(true);
  58.         connectionFactory.createConnection();
  59.         return connectionFactory;
  60.     }
  61.  
  62.     @Bean
  63.     public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
  64.         RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
  65.         rabbitAdmin.setAutoStartup(true);
  66.         return rabbitAdmin;
  67.     }
  68.  
  69.     @Bean
  70.     public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
  71.         RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
  72.  
  73.         rabbitTemplate.setMandatory(true);
  74.         //消息返回
  75.         rabbitTemplate.setReturnCallback((message, i, s, s1, s2) -> {
  76.             log.info("消息返回实现，message：{},replyCode：{},replyText：{},exchange：{},routingKey：{}", message, i, s, s1, s2);
  77.         });
  78.         //发送端确认
  79.         rabbitTemplate.setConfirmCallback((correlationData, b, s) -> {
  80.             log.info("发送端确认，correlationData：{},ack：{},cause：{}", correlationData, b, s);
  81.  
  82.         });
  83.         return rabbitTemplate;
  84.     }
  85.  
  86.     @Bean
  87.     public SimpleMessageListenerContainer messageListenerContainer(ConnectionFactory connectionFactory) {
  88.         SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
  89.         //针对哪些队列（参数为可变参数）
  90.         simpleMessageListenerContainer.setQueueNames("springboot.rabbitmq-queue");
  91.         //同时有多少个消费者线程在消费这个队列，相当于线程池的线程数字。
  92.         simpleMessageListenerContainer.setConcurrentConsumers(3);
  93.         //最大的消费者线程数
  94.         simpleMessageListenerContainer.setMaxConcurrentConsumers(5);
  95.         //设置消息确认方式    NONE=不确认,MANUAL=手动确认,AUTO=自动确认;
  96.         //自动确认
  97.         //simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.AUTO);
  98.         //simpleMessageListenerContainer.setMessageListener(message -> log.info("springboot.rabbitmq-queue接收到的消息：[{}]", message));
  99.         //手动确认(单条确认)
  100.         //simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.MANUAL);
  101.         //simpleMessageListenerContainer.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {
  102.         //    log.info("springboot.rabbitmq-queue接收到的消息：[{}]", message);
  103.         //    //orderTemplateMessageService.handleMessage(message.getBody());
  104.         //    channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  105.         //});
  106.         //监听
  107.         MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(orderTemplateMessageService);
  108.         //解决接收到消息处理业务类方法名称不为handleMessage且需要调用，因为MessageListenerAdapter会调用参数类中的handleMessage方法名称的方法。
  109.         //Map<String,String> methodMap=new HashMap<>(16);
  110.         //methodMap.put("springboot.rabbitmq-queue","handleMessage");
  111.         //messageListenerAdapter.setQueueOrTagToMethodName(methodMap);
  112.         // MessageConverter用来在收发消息时自动转换消息
  113.         Jackson2JsonMessageConverter messageConverter = new Jackson2JsonMessageConverter();
  114.         messageConverter.setClassMapper(new ClassMapper() {
  115.             @Override
  116.             public void fromClass(Class<?> aClass, MessageProperties messageProperties) {
  117.  
  118.             }
  119.  
  120.             @Override
  121.             public Class<?> toClass(MessageProperties messageProperties) {
  122.                 // OrderMessageDTO为接收消息的类型
  123.                 return MessageVO.class;
  124.             }
  125.         });
  126.  
  127.  
  128.         // 根据消息里面的属性判断属于哪个java类(不推荐：因为各个微服务之间可能不都是java，也可能是go语言)
  129.         /*Jackson2JavaTypeMapper javaTypeMapper = new DefaultJackson2JavaTypeMapper();
  130.         messageConverter.setJavaTypeMapper(javaTypeMapper);*/
  131.         messageListenerAdapter.setMessageConverter(messageConverter);
  132.         simpleMessageListenerContainer.setMessageListener(messageListenerAdapter);
  133.  
  134.         //消费端限流
  135.         simpleMessageListenerContainer.setPrefetchCount(1);
  136.         return simpleMessageListenerContainer;
  137.     }
  138. }

消费者

  1. @Slf4j
  2. @Service
  3. public class OrderTemplateMessageService {
  4.     public void handleMessage(MessageVO messageVO) {
  5.         log.info("messageBody:[{}]",messageVO);
  6.     }
  7.  
  8. }

生产者

  1. @Service
  2. @Slf4j
  3. public class OrderTemplateService {
  4.     @Autowired
  5.     private RabbitTemplate rabbitTemplate;
  6.     private ObjectMapper objectMapper = new ObjectMapper();
  7.     /**
  8.      * 测试生产消息
  9.      * @throws IOException
  10.      * @throws InterruptedException
  11.      * @throws TimeoutException
  12.      */
  13.     public  void testSendMessage() throws JsonProcessingException {
  14.         log.info("发送消息");
  15.         //新方式发送消息
  16.         MessageVO messageVO=new MessageVO();
  17.         messageVO.setMessageBody("test");
  18.         String messageToSend = objectMapper.writeValueAsString(messageVO);
  19.         log.info("messageToSend:{}",messageVO);
  20.         //MessageProperties messageProperties=new MessageProperties();
  21.         //messageProperties.setExpiration("1500");
  22.         //Message message=new Message(messageToSend.getBytes(),messageProperties);
  23.         //消息体需要是Message对象
  24.         //rabbitTemplate.send("exchange.order.test", "key.order", message);
  25.         //消息体需要是Object类型（自动转换后发送）
  26.         //发送消息时，指定消息id;消息确认时，接收指定消息id
  27.         CorrelationData correlationData=new CorrelationData();
  28.         correlationData.setId("12388891231239192");
  29.         rabbitTemplate.convertAndSend("springboot.rabbitmq-exchange",
  30.                 "key.springboot.order", messageToSend,correlationData);
  31.     }
  32.  
  33. }

4.3.8、利用RabbitListener快速实现消息处理器

RabbitListener是什么

  1.  RabbitListener是 SpringBoot架构中监听消息的"终极方案”
  2.  RabbitListener使用注解声明，对业务代码无侵入
  3. RabbitListener可以在SpringBoot配置文件中进行配置

@RabbitListener注解 

  1. @RabbitListener是一个组合注解，可以嵌套以下注解:
  2. @Exchange:自动声明Exchange
  3. @Queue:自动声明队列
  4. @QueueBinding:自动声明绑定关系

代码演示：

 配置类RabbitConfig

  1. @Slf4j
  2. @Configuration
  3. public class RabbitConfig {
  4.  
  5.  
  6.     @Resource
  7.     public OrderTemplateMessageService orderTemplateMessageService;
  8.     @Bean
  9.     public Exchange exchange1() {
  10.         return new DirectExchange("springboot.rabbitmq-exchange");
  11.     }
  12.  
  13.     @Bean
  14.     public Queue queue1() {
  15.         return new Queue("springboot.rabbitmq-queue");
  16.     }
  17.  
  18.     @Bean
  19.     public Binding binding1() {
  20.         return new Binding("springboot.rabbitmq-queue",
  21.                 Binding.DestinationType.QUEUE, "springboot.rabbitmq-exchange",
  22.                 "key.springboot.order", null);
  23.     }
  24.  
  25.     @Bean
  26.     public ConnectionFactory connectionFactory() {
  27.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
  28.         connectionFactory.setHost("127.0.0.1");
  29.         connectionFactory.setPort(5672);
  30.         connectionFactory.setPassword("guest");
  31.         connectionFactory.setUsername("guest");
  32.         //开启发送端确认
  33.         connectionFactory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);//SIMPLE=简单的;CORRELATED=相关的;NONE=关闭b;
  34.         //开启消息返回
  35.         connectionFactory.setPublisherReturns(true);
  36.         connectionFactory.createConnection();
  37.         return connectionFactory;
  38.     }
  39.  
  40.     @Bean
  41.     public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
  42.         RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
  43.         rabbitAdmin.setAutoStartup(true);
  44.         return rabbitAdmin;
  45.     }
  46.  
  47.     @Bean
  48.     public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
  49.         RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
  50.  
  51.         rabbitTemplate.setMandatory(true);
  52.         //消息返回
  53.         rabbitTemplate.setReturnCallback((message, i, s, s1, s2) -> {
  54.             log.info("消息返回实现，message：{},replyCode：{},replyText：{},exchange：{},routingKey：{}", message, i, s, s1, s2);
  55.         });
  56.         //发送端确认
  57.         rabbitTemplate.setConfirmCallback((correlationData, b, s) -> {
  58.             log.info("发送端确认，correlationData：{},ack：{},cause：{}", correlationData, b, s);
  59.  
  60.         });
  61.         return rabbitTemplate;
  62.     }
  63.  
  64.     
  65.  
  66.  
  67.     @Bean
  68.     public RabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
  69.         SimpleRabbitListenerContainerFactory factory=new SimpleRabbitListenerContainerFactory();
  70.         factory.setConnectionFactory(connectionFactory);
  71.         return factory;
  72.     }
  73. }

生产者：

  1. @Service
  2. @Slf4j
  3. public class OrderTemplateService {
  4.     @Autowired
  5.     private RabbitTemplate rabbitTemplate;
  6.  
  7.     /**
  8.      * 测试生产消息
  9.      * @throws IOException
  10.      * @throws InterruptedException
  11.      * @throws TimeoutException
  12.      */
  13.     public  void testSendMessage()  {
  14.         log.info("发送消息");
  15.         //新方式发送消息
  16.         MessageVO messageVO=new MessageVO();
  17.         messageVO.setMessageBody("test");
  18.         String messageToSend = JSON.toJSONString(messageVO);
  19.         log.info("messageToSend:{}",messageVO);
  20.         //MessageProperties messageProperties=new MessageProperties();
  21.         //messageProperties.setExpiration("1500");
  22.         //Message message=new Message(messageToSend.getBytes(),messageProperties);
  23.         //消息体需要是Message对象
  24.         //rabbitTemplate.send("exchange.order.test", "key.order", message);
  25.         //消息体需要是Object类型（自动转换后发送）
  26.         //发送消息时，指定消息id;消息确认时，接收指定消息id
  27.         CorrelationData correlationData=new CorrelationData();
  28.         correlationData.setId("12388891231239192");
  29.         rabbitTemplate.convertAndSend("springboot.rabbitmq-exchange",
  30.                 "key.springboot.order", messageToSend,correlationData);
  31.     }
  32.  
  33. }

消费者第一种方式（在类上设置@RabbitListener，在方法上设置@RabbitHandler）：

  1. @Slf4j
  2. @Service
  3. // 设置该类为消息监听器
  4. @RabbitListener(containerFactory = "rabbitListenerContainerFactory",
  5.         queues = "springboot.rabbitmq-queue"
  6. )
  7. public class OrderTemplateMessageServiceTWO {
  8.  
  9.     // 设置该方法为默认调用方法(注意无法使用MessageConverter接收消息)
  10.     @RabbitHandler(isDefault = true)
  11.     public void handMessage(@Payload Message message) throws IOException {
  12.         String messageBody = new String(message.getBody());
  13.         log.info("handMessage:message:{}", messageBody);
  14.     }
  15. }

消费者第二种方式（直接在方法上设置@RabbitListener(对整体代码入侵小)）：

  1. @Slf4j
  2. @Service
  3. public class OrderTemplateMessageServiceTWO {
  4.  
  5.     // 设置该方法为默认调用方法(注意无法使用MessageConverter接收消息)
  6.     @RabbitListener(containerFactory = "rabbitListenerContainerFactory",
  7.             queues = "springboot.rabbitmq-queue"
  8.     )
  9.     public void handMessage(@Payload Message message) throws IOException {
  10.         String messageBody = new String(message.getBody());
  11.         log.info("handMessage:message:{}", messageBody);
  12.     }
  13. }

运行截图：

@RabbitListener注解交换机队列绑定

  1. @Slf4j
  2. @Service
  3. public class OrderTemplateMessageServiceTWO {
  4.  
  5.     // 设置该方法为默认调用方法(注意无法使用MessageConverter接收消息)
  6.     @RabbitListener(containerFactory = "rabbitListenerContainerFactory",
  7.             admin = "rabbitAdmin",
  8.             bindings = {
  9.                     @QueueBinding(
  10.                             value = @Queue(
  11.                                     name = "springboot.rabbitmq-queue"
  12.                                     /*arguments = {
  13.                                             //设置队列中所有消息的过期时间
  14.                                             @Argument(
  15.                                                     name = "x-message-ttl",
  16.                                                     value = "1000",
  17.                                                     type = "java.lang.Integer"
  18.                                             ),
  19.                                             //设置队列为死信队列
  20.                                             @Argument(
  21.                                                     name = "x-dead-letter-exchange",
  22.                                                     value = "exchange.dlx"
  23.                                             )
  24.                                     }*/
  25.                             ),
  26.                             exchange = @Exchange(name = "springboot.rabbitmq-exchange", type = ExchangeTypes.DIRECT),
  27.                             key = "key.springboot.order"
  28.                     )
  29.             }
  30.     )
  31.     public void handMessage(@Payload Message message) throws IOException {
  32.         String messageBody = new String(message.getBody());
  33.         log.info("handMessage:message:{}", messageBody);
  34.     }
  35. }

4.3.9、SpringBoot配置rabbitmq

SpringBoot配置Rabbitmq

  1. spring:
  2.   rabbitmq:
  3.     addresses: 127.0.0.1
  4.     host: 5672
  5.     username: guest
  6.     password: guest
  7.     listener:
  8.       direct:
  9.         acknowledge-mode: auto

amqp配置文件配置详解

  1. # base
  2. spring.rabbitmq.host: 服务Host
  3. spring.rabbitmq.port: 服务端口
  4. spring.rabbitmq.username: 登陆用户名
  5. spring.rabbitmq.password: 登陆密码
  6. spring.rabbitmq.virtual-host: 连接到rabbitMQ的vhost
  7. spring.rabbitmq.addresses: 指定client连接到的server的地址，多个以逗号分隔(优先取addresses，然后再取host)
  8. spring.rabbitmq.requested-heartbeat: 指定心跳超时，单位秒，0为不指定；默认60s
  9. spring.rabbitmq.publisher-confirms: 是否启用【发布确认】
  10. spring.rabbitmq.publisher-returns: 是否启用【发布返回】
  11. spring.rabbitmq.connection-timeout: 连接超时，单位毫秒，0表示无穷大，不超时
  12. spring.rabbitmq.parsed-addresses:
  13.  
  14. # ssl
  15. spring.rabbitmq.ssl.enabled: 是否支持ssl
  16. spring.rabbitmq.ssl.key-store: 指定持有SSL certificate的key store的路径
  17. spring.rabbitmq.ssl.key-store-password: 指定访问key store的密码
  18. spring.rabbitmq.ssl.trust-store: 指定持有SSL certificates的Trust store
  19. spring.rabbitmq.ssl.trust-store-password: 指定访问trust store的密码
  20. spring.rabbitmq.ssl.algorithm: ssl使用的算法，例如，TLSv1.1
  21.  
  22. # cache
  23. spring.rabbitmq.cache.channel.size: 缓存中保持的channel数量
  24. spring.rabbitmq.cache.channel.checkout-timeout: 当缓存数量被设置时，从缓存中获取一个channel的超时时间，单位毫秒；如果为0，则总是创建一个新channel
  25. spring.rabbitmq.cache.connection.size: 缓存的连接数，只有是CONNECTION模式时生效
  26. spring.rabbitmq.cache.connection.mode: 连接工厂缓存模式：CHANNEL 和 CONNECTION
  27.  
  28. # listener
  29. spring.rabbitmq.listener.simple.auto-startup: 是否启动时自动启动容器
  30. spring.rabbitmq.listener.simple.acknowledge-mode: 表示消息确认方式，其有三种配置方式，分别是none、manual和auto；默认auto
  31. spring.rabbitmq.listener.simple.concurrency: 最小的消费者数量
  32. spring.rabbitmq.listener.simple.max-concurrency: 最大的消费者数量
  33. spring.rabbitmq.listener.simple.prefetch: 指定一个请求能处理多少个消息，如果有事务的话，必须大于等于transaction数量.
  34. spring.rabbitmq.listener.simple.transaction-size: 指定一个事务处理的消息数量，最好是小于等于prefetch的数量.
  35. spring.rabbitmq.listener.simple.default-requeue-rejected: 决定被拒绝的消息是否重新入队；默认是true（与参数acknowledge-mode有关系）
  36. spring.rabbitmq.listener.simple.idle-event-interval: 多少长时间发布空闲容器时间，单位毫秒
  37.  
  38. spring.rabbitmq.listener.simple.retry.enabled: 监听重试是否可用
  39. spring.rabbitmq.listener.simple.retry.max-attempts: 最大重试次数
  40. spring.rabbitmq.listener.simple.retry.initial-interval: 第一次和第二次尝试发布或传递消息之间的间隔
  41. spring.rabbitmq.listener.simple.retry.multiplier: 应用于上一重试间隔的乘数
  42. spring.rabbitmq.listener.simple.retry.max-interval: 最大重试时间间隔
  43. spring.rabbitmq.listener.simple.retry.stateless: 重试是有状态or无状态
  44.  
  45. # template
  46. spring.rabbitmq.template.mandatory: 启用强制信息；默认false
  47. spring.rabbitmq.template.receive-timeout: receive() 操作的超时时间
  48. spring.rabbitmq.template.reply-timeout: sendAndReceive() 操作的超时时间
  49. spring.rabbitmq.template.retry.enabled: 发送重试是否可用
  50. spring.rabbitmq.template.retry.max-attempts: 最大重试次数
  51. spring.rabbitmq.template.retry.initial-interval: 第一次和第二次尝试发布或传递消息之间的间隔
  52. spring.rabbitmq.template.retry.multiplier: 应用于上一重试间隔的乘数
  53. spring.rabbitmq.template.retry.max-interval: 最大重试时间间隔

生产者：

  1. @Service
  2. @Slf4j
  3. public class OrderTemplateService {
  4.     @Autowired
  5.     private RabbitTemplate rabbitTemplate;
  6.  
  7.     /**
  8.      * 测试生产消息
  9.      * @throws IOException
  10.      * @throws InterruptedException
  11.      * @throws TimeoutException
  12.      */
  13.     public  void testSendMessage()  {
  14.         log.info("发送消息");
  15.         //新方式发送消息
  16.         MessageVO messageVO=new MessageVO();
  17.         messageVO.setMessageBody("test");
  18.         String messageToSend = JSON.toJSONString(messageVO);
  19.         log.info("messageToSend:{}",messageVO);
  20.         //MessageProperties messageProperties=new MessageProperties();
  21.         //messageProperties.setExpiration("1500");
  22.         //Message message=new Message(messageToSend.getBytes(),messageProperties);
  23.         //消息体需要是Message对象
  24.         //rabbitTemplate.send("exchange.order.test", "key.order", message);
  25.         //消息体需要是Object类型（自动转换后发送）
  26.         //发送消息时，指定消息id;消息确认时，接收指定消息id
  27.         CorrelationData correlationData=new CorrelationData();
  28.         correlationData.setId("12388891231239192");
  29.         rabbitTemplate.convertAndSend("springboot.rabbitmq-exchange",
  30.                 "key.springboot.order", messageToSend,correlationData);
  31.     }
  32.  
  33. }

消费者：

  1. @Slf4j
  2. @Service
  3. public class OrderTemplateMessageServiceTWO {
  4.  
  5.     // 设置该方法为默认调用方法(注意无法使用MessageConverter接收消息)
  6.     @RabbitListener(containerFactory = "rabbitListenerContainerFactory",
  7.             bindings = {
  8.                     @QueueBinding(
  9.                             value = @Queue(
  10.                                     name = "springboot.rabbitmq-queue"
  11.                                     /*arguments = {
  12.                                             //设置队列中所有消息的过期时间
  13.                                             @Argument(
  14.                                                     name = "x-message-ttl",
  15.                                                     value = "1000",
  16.                                                     type = "java.lang.Integer"
  17.                                             ),
  18.                                             //设置队列为死信队列
  19.                                             @Argument(
  20.                                                     name = "x-dead-letter-exchange",
  21.                                                     value = "exchange.dlx"
  22.                                             )
  23.                                     }*/
  24.                             ),
  25.                             exchange = @Exchange(name = "springboot.rabbitmq-exchange", type = ExchangeTypes.DIRECT),
  26.                             key = "key.springboot.order"
  27.                     )
  28.             }
  29.     )
  30.     public void handMessage(@Payload Message message) throws IOException {
  31.         String messageBody = new String(message.getBody());
  32.         log.info("handMessage:message:{}", messageBody);
  33.     }
  34. }

五、RabbitMQ集群高可用

5.1、RabbitMQ集群高可用好处

  1. 扩展规模
  2. 数据冗余
  3. 高可用

5.2、RabbitMQ集群搭建

5.2.1、RabbitMQ集群搭建概述

  1. 多个RabbitMQ单节点，经过配置组成RabbitMQ集群。
  2. 集群节点之间共享数据，不共享队列数据（默认）。
  3. RabbitMQ节点数据互相转发，客户端通过单一节点访问所有数据。 

5.2.2、集群架构拓扑 

 5.2.3、RabbitMQ集群搭建步骤

链接: https://pan.baidu.com/s/1ifVV_LgGLfaOAO5COY1gdw?pwd=gx2q 提取码: gx2q 
--来自百度网盘超级会员v4的分享 

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号