RbbitMq

第一章 RabbitMQ 简介

1 消息队列中间件简介

消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题实现高性能，高可

用，可伸缩和最终一致性[架构] 。

使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ。

消息队列在实际应用中常用的使用场景：异步处理，应用解耦，流量削锋和日志处理

异步处理：
当某个操作完成之后，需要触发一系列耗时较长但并非立即必要的后续任务（如发送通知邮件、短信验证码、执行数据备份等）。将这些任务以消息形式放入MQ，消费者服务可以异步地从队列中取出并处理这些消息，避免阻塞主线程。
例如：用户注册后，系统先快速响应用户的注册请求，将发送注册确认邮件和短信的任务发布到MQ。后台的邮件服务和短信服务分别订阅相关主题，接收到消息后在不影响主线业务的情况下完成邮件和短信的发送。

应用解耦：
在微服务架构中，各服务之间直接调用可能导致高度依赖和耦合。通过引入MQ，服务间可以通过消息传递进行通信，一方只需关心消息的发送，另一方只负责消息的消费，从而实现服务间的解耦。
例如：用户下单后，需扣库存，扣完库存发物流。此时订单系统不需直接调用库存系统的接口减库存，而是向MQ发布一条“扣减库存”消息，库存系统收到消息后完成扣库存操作，然后发消息给物流系统。即使库存系统临时不可用或升级维护，也不会直接影响订单系统的正常运作，最大程度保证用户下单成功。

流量削峰填谷：
在面对瞬时大流量冲击（如秒杀、抢购、促销活动开始时）时，直接处理所有请求可能导致系统过载甚至崩溃。利用MQ作为缓冲层，可以暂时存储超出系统处理能力的请求，然后按照系统能承受的速率逐渐释放，实现流量的平滑处理。
例如：在秒杀活动中，大量用户同时请求购买商品。此时前端将请求转化为消息投递到MQ，后端服务按照预设的限流策略从队列中有序消费，避免数据库或其他资源因短时间内承受过高压力而宕机。（人工产生消息积压）

日志处理：
在大规模分布式环境中，各个节点产生的日志数据需要集中收集、过滤、传输至日志存储系统。此时应用程序产生的日志被推送到MQ，Kafka等，然后统一接收来自不同源头的日志消息并处理。高性能MQ特别适用于这种场景，能够处理高并发的日志写入。（ELK）

2 什么是RabbitMQ

RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种语言平台的客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等。
AMQP ：Advanced Message Queue Potocal，高级消息队列协议。它是应用层协议的一个开放标准，为面向消
息的中间件设计，基于此协议的客户端与消息中间件可传递消息，并不受产品、开发语言等条件的限制。
RabbitMQ最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面

具体特点包括：
1.可靠性（Reliability）
RabbitMQ 使用一些机制来保证可靠性，如持久化、传输确认、发布确认。
2.灵活的路由（Flexible Routing）
在消息进入队列之前，通过 Exchange 来路由消息的。对于典型的路由功能，RabbitMQ已经提供了一些内置的 Exchange 来实现。针对更复杂的路由功能，可以将多个Exchange 绑定在一起，也通过插件机制实现自己的 Exchange 。
3.消息集群（Clustering）
多个 RabbitMQ 服务器可以组成一个集群，形成一个逻辑 Broker 。
4.高可用（Highly Available Queues）
队列可以在集群中的机器上进行镜像，使得在部分节点出问题的情况下队列仍然可用。
5.多种协议（Multi-protocol）
RabbitMQ 支持多种消息队列协议，比如 STOMP、MQTT 等等。
6.多语言客户端（Many Clients）
RabbitMQ 几乎支持所有常用语言，比如 Java、.NET、Ruby 等等。
7.管理界面（Management UI）
RabbitMQ 提供了一个易用的用户界面，使得用户可以监控和管理消息 Broker的许多方面。
8.跟踪机制（Tracing）
如果消息异常，RabbitMQ 提供了消息跟踪机制，使用者可以找出发生了什么。
9.插件机制（Plugin System）
RabbitMQ 提供了许多插件，来从多方面进行扩展，也可以编写自己的插件

3 架构图和主要概念

架构图

主要概念

生产者(Provider)、消费者(Consumer)、交换器(Exchange)、队列(Queue)、绑定(RoutingKey)

生产者(Provider)： 消息生产者，如图 A、B、C，数据的发送方。消息生产者连接 RabbitMQ服务器然后将消息投递到Exchange。

消费者(Consumer)：消息消费者，如图 1、2、3，数据的接收方。消息消费者订阅队列，RabbitMQ 将 Queue 中的消息发送到消息消费者。

交换器(Exchange)：生产者将消息发送到 Exchange（交换器），由 Exchange将消息路由到一个或多Queue 中（或者丢弃）。Exchange 并不存储消息。

队列(Queue)：是 RabbitMQ的内部对象，用于存储消息。消息消费者就是通过订阅队列来获取消息RabbitMQ 中的消息。消息都只能存储在 Queue中，生产者生产消息并最终投递到Queue 中，消费者可以从 Queue 中获取消息并消费。

绑定(RoutingKey)：生产者在将消息发送给 Exchange 的时候，一般会指定一个 routingkey，来指定这个消息的路由规则，而这个 routing key 需要与 Exchange Type 及binding key 联合使用才能最终生效。在 Exchange Type 与binding key固定的情况下（在正常使用时一般这些内容都是固定配置好的），我们的生产者就可以在发送消息给 Exchange 时，通过指定 routingkey 来决定消息流向哪里。

Connection：（连接）：Producer 和 Consumer 都是通过 TCP 连接到 RabbitMQ Server 的。

Channels： （信道）：它建立在上述的 TCP 连接中。数据流动都是在Channel中进行的。一般情况是程序先建立 TCP 连接，然后建立Channel。

VirtualHost：权限控制的基本单位，一个 VirtualHost 里面有若干 Exchange和MessageQueue，以及指定被哪些 user 使用。

常用交换机

常用的交换机有以下三种，因为消费者是从队列获取信息的，队列是绑定交换机的（一般），所以对应的消息推

送/接收模式也会有以下几种：

Direct Exchange：直连型交换机，根据消息携带的路由键将消息投递给对应队列。
大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key 。然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时，交换机就会根据这个路由值X去寻找绑定值也是X的队列。

Fanout Exchange：扇型交换机，类似于广播模式。这个交换机没有路由键概念，就算你绑了路由键也是无视的。 这个交换机在接收到消息后，会直接转发到绑定到它上面的所有队列。

Topic Exchange：主题交换机，这个交换机其实跟直连交换机流程差不多，它的特点是在它的路由键和绑定键之间支持通配符。
简单地介绍下规则：

• (星号) 用来表示一个单词 (必须出现的)

(井号) 用来表示任意数量（零个或多个）单词

例如：
队列Q1 绑定键为 .TT. ，队列Q2绑定键为 TT.#
如果一条消息携带的路由键为 A.TT.B，那么队列Q1将会收到；
如果一条消息携带的路由键为TT.AA.BB，那么队列Q2将会收到；

当一个队列的绑定键为 “#”（井号） 的时候，这个队列将会无视消息的路由键，接收所有的消息。
当 * (星号) 和 # (井号) 这两个特殊字符都未在绑定键中出现的时候，此时主题交换机就拥有的直连交换机的行为。
所以主题交换机也就实现了扇形交换机的功能，和直连交换机的功能。

另外还有 Header Exchange 头交换机 ，Default Exchange 默认交换机。

4 RabbitMQ安装与启动

（1）下载并安装 Erlang

配套软件中已提供 otp_win64_20.2.exe （以管理员身份运行安装）

安装完成后需要配置环境变量（和jdk相同）：

ERLANG_HOME=d:\ProgramFiles\erl9.2

path中添加%JAVA_HOME%\bin

最后windows键+R键，输入cmd，再输入erl，看到版本号就说明erlang安装成功了。

（2）下载并安装 rabbitmq

配套软件中已提供rabbitmq-server-3.7.4.exe。双击安装，注意不要安装在包含中文和空格的目录下！安装后window 服务中就存在 rabbitMQ 了，并且是启动状态。

（3）安装管理界面（插件）

进入rabbitMQ 安装目录的 sbin 目录，输入命令

rabbitmq-plugins enable rabbitmq_management

（4）重新启动服务

rabbitmq_server-3.8.9\sbin\rabbitmq-server.bat

（5）打开浏览器，地址栏输入 http://127.0.0.1:15672 ,即可看到管理界面的登陆页

输入用户名和密码，都为 guest 进入主界面

最上侧的导航以此是：概览、连接、信道、交换器、队列、用户管理

第二章 RabbitMQ的使用

1 DirectExchange直连交换机

生产者

首先创建一个springboot父项目，并在父项目里面创建2个子项目，一个 rabbitmq-provider（生产者），一个rabbitmq-consumer（消费者）。

2个子项目依赖相同：

<!-- spring-boot-starter-amqp用于支持RabbitMQ -->        
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2个子项目的application.properties中配置关于RabbitMQ的连接和用户信息

#rabbitmq
spring.rabbitmq.virtual-host=/
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

接着我们先使用下direct exchange(直连型交换机),创建DirectRabbitConfig.java（对于队列和交换机持久化以及

连接使用设置，在注释里有说明，后面的不同交换机的配置就不做同样说明了）：

rabbitmq-provider中添加DirectRabbitConfig配置类：

package provider.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DirectRabbitConfig {

    //队列 起名：TestDirectQueue
    @Bean
    public Queue TestDirectQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        //   return new Queue("TestDirectQueue",true,true,false);

        //一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("TestDirectQueue", true);
    }

    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange TestDirectExchange() {
        //  return new DirectExchange("TestDirectExchange",true,true);
        return new DirectExchange("TestDirectExchange", true, false);
    }

    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingDirect() {
        return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }

}

rabbitmq-provider中写个简单的接口进行消息推送

package provider.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

@RestController
public class SendMessageController {

    //使用RabbitTemplate,这提供了接收/发送等等方法
    @Autowired
    RabbitTemplate rabbitTemplate;

    @GetMapping("/sendDirectMessage")
    public String sendDirectMessage() {
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", String.valueOf(UUID.randomUUID()));
        map.put("messageData", "test message, hello!");
        map.put("createTime", createTime);

        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return "ok";
    }
}

启动rabbitmq-provider项目，调用下接口：http://localhost:8080/sendDirectMessage

因为我们目前还没弄消费者 rabbitmq-consumer，消息没有被消费的，我们去rabbitMq管理页面看看，是否推送

成功：

再看看队列

很好，消息已经推送到rabbitMq服务器上面了。

消费者

然后一样，在rabbitmq-consumer中创建DirectRabbitConfig.java（消费者单纯的使用，其实可以不用添加这个配置，直接建后面的监听就好，使用注解来让监听器监听对应的队列即可。配置上了的话，其实消费者也是生成者的身份，也能推送该消息。）
然后是创建消息接收监听类，DirectReceiver.java

package com.consumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("DirectReceiver消费者1收到消息  : " + testMessage.toString());
    }
}

然后将rabbitmq-consumer项目运行起来，可以看到把之前推送的那条消息消费下来了

从rabbitmq的控制台上，看之前的消息已经被消费，Ready和Total都是0.

然后可以再继续调用rabbitmq-provider项目的推送消息接口，可以看到消费者即时消费消息

那么直连交换机既然是一对一，那如果咱们配置多台监听绑定到同一个直连交互的同一个队列，会怎么样？

把刚刚的DirectReceiver再复制一份，命名为DirectReceiver2，这时有2个消费者同时消费

package com.consumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.util.Map;

@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver2 {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("DirectReceiver消费者2收到消息  : " + testMessage.toString());
    }
}

然后重启2个项目，把http://localhost:8080/sendDirectMessage调用4次

控制台打印如下：

DirectReceiver消费者1收到消息  : {createTime=2021-03-25 13:02:49, messageId=4bff022a-debf-4361-805e-7a579e102955, messageData=test message, hello!}
DirectReceiver消费者2收到消息  : {createTime=2021-03-25 13:02:53, messageId=fa8fcb93-be29-4d57-8c73-c17a92195c5e, messageData=test message, hello!}
DirectReceiver消费者1收到消息  : {createTime=2021-03-25 13:02:56, messageId=3407634f-7320-4c8d-b6b4-07a954b821d3, messageData=test message, hello!}
DirectReceiver消费者2收到消息  : {createTime=2021-03-25 13:02:59, messageId=15495627-7c3c-4b04-8d9d-2aa9412b5bc8, messageData=test message, hello!}

可以看到是实现了轮询的方式对消息进行消费，而且不存在重复消费。

2 FanoutExchang 扇型交换机

生产者

同样地，先在rabbitmq-provider项目上创建FanoutRabbitConfig.java

package provider.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutRabbitConfig {

    /**
     * 创建三个队列 ：fanout.A   fanout.B  fanout.C
     * 将三个队列都绑定在交换机 fanoutExchange 上
     * 因为是扇型交换机, 路由键无需配置,配置也不起作用
     */
    @Bean
    public Queue queueA() {
        return new Queue("fanout.A");
    }

    @Bean
    public Queue queueB() {
        return new Queue("fanout.B");
    }

    @Bean
    public Queue queueC() {
        return new Queue("fanout.C");
    }

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    @Bean
    Binding bindingExchangeA() {
        return BindingBuilder.bind(queueA()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeB() {
        return BindingBuilder.bind(queueB()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeC() {
        return BindingBuilder.bind(queueC()).to(fanoutExchange());
    }

}

然后是写一个接口用于推送消息

    @GetMapping("/sendFanoutMessage")
    public String sendFanoutMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: testFanoutMessage ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        rabbitTemplate.convertAndSend("fanoutExchange", null, map);
        return "ok";
    }

消费者

接着在rabbitmq-consumer项目里加上3个消息消费类

package com.consumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
@RabbitListener(queues = "fanout.A")
public class FanoutReceiverA {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverA消费者收到消息  : " + testMessage.toString());
    }
}

@Component
@RabbitListener(queues = "fanout.B")
public class FanoutReceiverB {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverB消费者收到消息  : " + testMessage.toString());
    }
}

@Component
@RabbitListener(queues = "fanout.C")
public class FanoutReceiverC {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverC消费者收到消息  : " + testMessage.toString());
    }
}

然后加上扇型交换机的配置类，FanoutRabbitConfig.java（消费者真的要加这个配置吗？ 不需要的其实，理由在前面已经说过了）

测试

最后将rabbitmq-provider和rabbitmq-consumer项目都跑起来，调用下接口/sendFanoutMessage
然后看看rabbitmq-consumer项目的控制台情况：

FanoutReceiverB消费者收到消息  : {createTime=2021-03-25 19:31:04, messageId=3ef7633d-c440-4726-adfc-d31020ba67f3, messageData=message: testFanoutMessage }
FanoutReceiverC消费者收到消息  : {createTime=2021-03-25 19:31:04, messageId=3ef7633d-c440-4726-adfc-d31020ba67f3, messageData=message: testFanoutMessage }
FanoutReceiverA消费者收到消息  : {createTime=2021-03-25 19:31:04, messageId=3ef7633d-c440-4726-adfc-d31020ba67f3, messageData=message: testFanoutMessage }

可以看到只要发送到 fanoutExchange 这个扇型交换机的消息， 三个队列都绑定这个交换机，所以三个消息接收类都监听到了这条消息。

3 TopicExchange主题交换机

生产者

在rabbitmq-provider项目里面创建TopicRabbitConfig.java

package provider.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TopicRabbitConfig {
    //绑定键
    public final static String man = "topic.man";
    public final static String woman = "topic.woman";

    @Bean
    public Queue firstQueue() {
        return new Queue(TopicRabbitConfig.man);
    }

    @Bean
    public Queue secondQueue() {
        return new Queue(TopicRabbitConfig.woman);
    }

    @Bean
    TopicExchange exchange() {
        return new TopicExchange("topicExchange");
    }


    //将firstQueue和topicExchange绑定,而且绑定的键值为topic.man
    //这样只要是消息携带的路由键是topic.man,才会分发到该队列
    @Bean
    Binding bindingExchangeMessage() {
        return BindingBuilder.bind(firstQueue()).to(exchange()).with(man);
    }

    //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
    // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
    @Bean
    Binding bindingExchangeMessage2() {
        return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }
}

然后添加多2个接口，用于推送消息到主题交换机

    @GetMapping("/sendTopicMessage1")
    public String sendTopicMessage1() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: M A N ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> manMap = new HashMap<>();
        manMap.put("messageId", messageId);
        manMap.put("messageData", messageData);
        manMap.put("createTime", createTime);
        rabbitTemplate.convertAndSend("topicExchange", "topic.man", manMap);
        return "ok";
    }

    @GetMapping("/sendTopicMessage2")
    public String sendTopicMessage2() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: woman is all ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> womanMap = new HashMap<>();
        womanMap.put("messageId", messageId);
        womanMap.put("messageData", messageData);
        womanMap.put("createTime", createTime);
        rabbitTemplate.convertAndSend("topicExchange", "topic.woman", womanMap);
        return "ok";
    }

消费者

生产者这边已经完事，先不急着运行，在rabbitmq-consumer项目上，创建TopicManReceiver.java

package com.consumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
@RabbitListener(queues = "topic.man")
public class TopicManReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("TopicManReceiver消费者收到消息  : " + testMessage.toString());
    }
}

再创建一个TopicTotalReceiver.java

package com.consumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
@RabbitListener(queues = "topic.woman")
public class TopicTotalReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("TopicTotalReceiver消费者收到消息  : " + testMessage.toString());
    }

}

同样，加主题交换机的相关配置，TopicRabbitConfig.java（消费者一定要加这个配置吗？ 不需要的其实，理由在前面已经说过了。）

测试

然后把rabbitmq-provider，rabbitmq-consumer两个项目都跑起来，先调用/sendTopicMessage1接口

然后看消费者rabbitmq-consumer的控制台输出情况：

TopicManReceiver消费者收到消息  : {createTime=2021-03-25 19:17:55, messageId=79bf70c4-3f31-4c50-8a3b-0f020f0582b8, messageData=message: M A N }
TopicTotalReceiver消费者收到消息  : {createTime=2021-03-25 19:17:55, messageId=79bf70c4-3f31-4c50-8a3b-0f020f0582b8, messageData=message: M A N }

TopicManReceiver监听队列1，绑定键为：topic.man
TopicTotalReceiver监听队列2，绑定键为：topic.#
而当前推送的消息，携带的路由键为：topic.man

所以可以看到两个监听消费者receiver都成功消费到了消息，因为这两个recevier监听的队列的绑定键都能与这条消息携带的路由键匹配上。
接下来调用接口/sendTopicMessage2

然后看消费者rabbitmq-consumer的控制台输出情况：
TopicManReceiver监听队列1，绑定键为：topic.man
TopicTotalReceiver监听队列2，绑定键为：topic.#
而当前推送的消息，携带的路由键为：topic.woman

所以可以看到两个监听消费者只有TopicTotalReceiver成功消费到了消息。

4 消息确认(生产者推送消息成功）

在rabbitmq-provider项目的application.properties文件上，加上消息确认的配置项

#
#确认消息已发送到交换机(Exchange)
#如果使用的是低版本的springboot,则是使用spring.rabbitmq.publisher-confirms=true
spring.rabbitmq.publisher-confirm-type=correlated
#确认消息已发送到队列(Queue)
spring.rabbitmq.publisher-returns=true

然后是配置相关的消息确认回调函数，RabbitConfig.java

package provider.config;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {

    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate();
        rabbitTemplate.setConnectionFactory(connectionFactory);
        //设置开启Mandatory,才能触发回调函数,无论消息推送结果怎么样都强制调用回调函数
        rabbitTemplate.setMandatory(true);

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("ConfirmCallback:     " + "相关数据：" + correlationData);
                System.out.println("ConfirmCallback:     " + "确认情况：" + ack);
                System.out.println("ConfirmCallback:     " + "原因：" + cause);
            }
        });

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("ReturnCallback:     " + "消息：" + message);
                System.out.println("ReturnCallback:     " + "回应码：" + replyCode);
                System.out.println("ReturnCallback:     " + "回应信息：" + replyText);
                System.out.println("ReturnCallback:     " + "交换机：" + exchange);
                System.out.println("ReturnCallback:     " + "路由键：" + routingKey);
            }
        });

        return rabbitTemplate;
    }
}

到这里，生产者推送消息的消息确认调用回调函数已经完毕。

可以看到上面写了两个回调函数，一个叫 ConfirmCallback ，一个叫 RetrunCallback；

那么以上这两种回调函数都是在什么情况会触发呢？

先从总体的情况分析，推送消息存在四种情况：

①消息推送到server，但是在server里找不到交换机
②消息推送到server，找到交换机了，但是没找到队列
③消息推送到sever，交换机和队列啥都没找到
④消息推送成功

那么我先写几个接口来分别测试和认证下以上4种情况，消息确认触发回调函数的情况：

第一种

①消息推送到server，但是在server里找不到交换机

写个测试接口，把消息推送到名为‘non-existent-exchange’的交换机上（这个交换机是没有创建没有配置的）：

    @GetMapping("/TestMessageAck")
    public String TestMessageAck() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: non-existent-exchange test message ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        rabbitTemplate.convertAndSend("non-existent-exchange", "TestDirectRouting", map);
        return "ok";
    }

调用接口，查看rabbitmq-provuder项目的控制台输出情况（原因里面有说，没有找到交换机’non-existent-exchange’）：

ConfirmCallback:     相关数据：null
ConfirmCallback:     确认情况：false
ConfirmCallback:     原因：channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no exchange 'non-existent-exchange' in vhost '/', class-id=60, method-id=40)

结论： ①这种情况触发的是 ConfirmCallback 回调函数。

第二种

②消息推送到server，找到交换机了，但是没找到队列
这种情况就是需要新增一个交换机，但是不给这个交换机绑定队列，我来简单地在DirectRabitConfig里面新增一个直连交换机，名叫‘lonelyDirectExchange’，但没给它做任何绑定配置操作：

    @Bean
    DirectExchange lonelyDirectExchange() {
        return new DirectExchange("lonelyDirectExchange");
    }

然后写个测试接口，把消息推送到名为‘lonelyDirectExchange’的交换机上（这个交换机是没有任何队列配置的）：

    @GetMapping("/TestMessageAck2")
    public String TestMessageAck2() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: lonelyDirectExchange test message ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        rabbitTemplate.convertAndSend("lonelyDirectExchange", "TestDirectRouting", map);
        return "ok";
    }

调用接口，查看rabbitmq-provuder项目的控制台输出情况：

ConfirmCallback:     相关数据：null
ConfirmCallback:     确认情况：true
ConfirmCallback:     原因：null
ReturnCallback:     消息：(Body:'{createTime=2021-03-25 19:58:33, messageId=7b37a0de-088c-4b4b-bb3f-95e7cc96d0c0, messageData=message: lonelyDirectExchange test message }' MessageProperties [headers={}, contentType=application/x-java-serialized-object, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, deliveryTag=0])
ReturnCallback:     回应码：312
ReturnCallback:     回应信息：NO_ROUTE
ReturnCallback:     交换机：lonelyDirectExchange
ReturnCallback:     路由键：TestDirectRouting

可以看到这种情况，两个函数都被调用了；
这种情况下，消息是推送成功到服务器了的，所以ConfirmCallback对消息确认情况是true；
而在RetrunCallback回调函数的打印参数里面可以看到，消息是推送到了交换机成功了，但是在路由分发给队列的时候，找不到队列，所以报了错误 NO_ROUTE 。
结论：②这种情况触发的是 ConfirmCallback和RetrunCallback两个回调函数。

第三种

③消息推送到sever，交换机和队列啥都没找到
这种情况其实一看就觉得跟①很像，没错 ，③和①情况回调是一致的，所以不做结果说明了。
结论： ③这种情况触发的是 ConfirmCallback 回调函数。

第四种

④消息推送成功
那么测试下，按照正常调用之前消息推送的接口就行，就调用下 /sendFanoutMessage接口，可以看到控制台输出：

ConfirmCallback:     相关数据：null
ConfirmCallback:     确认情况：true
ConfirmCallback:     原因：null

结论： ④这种情况触发的是 ConfirmCallback 回调函数。

以上是生产者推送消息的消息确认回调函数的使用介绍（可以在回调函数根据需求做对应的扩展或者业务数据处理）。

5 消息确认(消费者接收消息成功）

三种确认机制

接下来我们继续， 消费者接收到消息的消息确认机制。和生产者的消息确认机制不同，因为消息接收本来就是在

监听消息，符合条件的消息就会消费下来。

所以，消息接收的确认机制主要存在三种模式：（AcknowledgeMode枚举类中有说明）

①自动确认， 这也是默认的消息确认情况。

RabbitMQ成功将消息发出（即将消息成功写入TCP Socket）中立即认为本次投递已经被正确处理，不管消费者端

是否成功处理本次投递。所以这种情况如果消费端消费逻辑抛出异常，也就是消费端没有处理成功这条消息，那么

就相当于丢失了消息。一般这种情况我们都是使用try catch捕捉异常后，打印日志用于追踪数据，这样找出对应数

据再做后续处理。

② 根据情况确认， 这个不做介绍

③ 手动确认。

这个比较关键，也是我们配置接收消息确认机制时，多数选择的模式。

消费者收到消息后，手动调用basic.ack或basic.nack或basic.reject后，RabbitMQ收到这些消息后，才认为本次投

递成功。

• basic.ack用于肯定确认
• basic.nack用于否定确认（注意：这是AMQP 0-9-1的RabbitMQ扩展）
• basic.reject用于否定确认，但与basic.nack相比有一个限制:一次只能拒绝单条消息

消费者端以上的3个方法都表示消息已经被正确投递，但是basic.ack表示消息已经被正确处理，而basic.nack和

basic.reject表示没有被正确处理。着重讲下reject，因为有时候一些场景是需要重新入列的。

channel.basicReject(deliveryTag, true); 拒绝消费当前消息，如果第二参数传入true，就是将数据重新丢回队列里，那么下次还会消费这消息。设置false，就是告诉服务器，我已经知道这条消息数据了，因为一些原因拒绝它，而且服务器也把这个消息丢掉就行。 下次不想再消费这条消息了。

使用拒绝后重新入列这个确认模式要谨慎，因为一般都是出现异常的时候，catch异常再拒绝入列，选择是否重入列。

但是如果使用不当会导致一些每次都被你重入列的消息一直消费-入列-消费-入列这样循环，会导致消息积压。

顺便也简单讲讲 nack，这个也是相当于设置不消费某条消息。

channel.basicNack(deliveryTag, false, true);
第一个参数依然是当前消息到的数据的唯一id;
第二个参数是指是否针对多条消息；如果是true，也就是说一次性针对当前通道的消息的tagID小于当前这条消息的，都拒绝确认。
第三个参数是指是否重新入列，也就是指不确认的消息是否重新丢回到队列里面去。

同样使用不确认后重新入列这个确认模式要谨慎，因为这里也可能因为考虑不周出现消息一直被重新丢回去的情况，导致积压。

案例1

看了上面这么多介绍，接下来我们一起配置下，看看一般的消息接收 手动确认是怎么样的。

在消费者项目里，新建MessageListenerConfig.java上添加代码相关的配置代码

package com.consumer.config;

import com.consumer.receiver.MyAckReceiver;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MessageListenerConfig {

    @Autowired
    private CachingConnectionFactory connectionFactory;

    //自定义消息接收处理类
    @Autowired
    private MyAckReceiver myAckReceiver;

    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        container.setConcurrentConsumers(1);
        container.setMaxConcurrentConsumers(1);

        //RabbitMQ确认类型有三种：NONE,MANUAL(手动确认),AUTO(自动确认);
        // RabbitMQ默认是自动确认，这里改为手动确认消息
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);

        //设置一个队列
        container.setQueueNames("TestDirectQueue");
        //如果同时设置多个如下： 前提是队列都是必须已经创建存在的
        // container.setQueueNames("TestDirectQueue","TestDirectQueue2","TestDirectQueue3");


        //另一种设置队列的方法,如果使用这种情况,那么要设置多个,就使用addQueues
        //container.setQueues(new Queue("TestDirectQueue",true));
        //container.addQueues(new Queue("TestDirectQueue2",true));
        //container.addQueues(new Queue("TestDirectQueue3",true));
        container.setMessageListener(myAckReceiver);

        return container;
    }
}

对应的手动确认消息监听类，MyAckReceiver.java（手动确认模式需要实现 ChannelAwareMessageListener）

//之前的相关监听器可以先注释掉，以免造成多个同类型监听器都监听同一个队列。

//这里的获取消息转换，只作参考，如果报数组越界可以自己根据格式去调整。

package com.consumer.receiver;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

@Component
public class MyAckReceiver implements ChannelAwareMessageListener {

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //因为传递消息的时候用的map传递,所以将Map从Message内取出需要做些处理
            String msg = message.toString();
            String[] msgArray = msg.split("'");//可以点进Message里面看源码,单引号直接的数据就是我们的map消息数据
            Map<String, String> msgMap = mapStringToMap(msgArray[1].trim(), 3);
            String messageId = msgMap.get("messageId");
            String messageData = msgMap.get("messageData");
            String createTime = msgMap.get("createTime");
            System.out.println("MyAckReceiver  messageId:" + messageId + "  messageData:" + messageData + "  createTime:" + createTime);
            System.out.println("消费的主题消息来自：" + message.getMessageProperties().getConsumerQueue());

            //basic.ack用于肯定确认
            //第二个参数，手动确认可以被批处理，当该参数为true时，则可以一次性确认delivery_tag小于等于传入值的所有消息
            channel.basicAck(deliveryTag, true);

            //basic.reject用于否定确认，但与basic.nack相比有一个限制:一次只能拒绝单条消息
            // 第二个参数，true会重新放回队列，所以需要自己根据业务逻辑判断什么时候使用拒绝
            //	channel.basicReject(deliveryTag, true);
        } catch (Exception e) {
            channel.basicReject(deliveryTag, false);
            e.printStackTrace();
        }
    }

    //{key=value,key=value,key=value} 格式转换成map
    private Map<String, String> mapStringToMap(String str, int entryNum) {
        str = str.substring(1, str.length() - 1);
        String[] strs = str.split(",", entryNum);
        Map<String, String> map = new HashMap<String, String>();
        for (String string : strs) {
            String key = string.split("=")[0].trim();
            String value = string.split("=")[1];
            map.put(key, value);
        }
        return map;
    }
}

这时，先调用接口/sendDirectMessage， 给直连交换机TestDirectExchange 的队列TestDirectQueue 推送一条

消息，可以看到监听器正常消费了下来

MyAckReceiver  messageId:012ff2e2-77af-46c0-9c64-3802e8d8d1b2  messageData:test message, hello!  createTime:2021-03-25 20:32:15
消费的主题消息来自：TestDirectQueue

案例2

到这里，我们其实已经掌握了怎么去使用消息消费的手动确认了。但是这个场景往往不够，有时我们需要这个消费
者项目里面，监听的好几个队列都想变成手动确认模式，而且处理的消息业务逻辑不一样。
场景： 除了直连交换机的队列TestDirectQueue需要变成手动确认以外，我们还需要将一个其他的队列或者多个
队列也变成手动确认，而且不同队列实现不同的业务处理。
首先是往MessageListenerConfig中的方法SimpleMessageListenerContainer里添加多个队列

//设置新的队列
//如果同时设置多个如下： 前提是队列都是必须已经创建存在的
container.setQueueNames("TestDirectQueue", "fanout.A");

然后我们的手动确认消息监听类，MyAckReceiver2.java就可以同时将上面设置到的队列的消息都消费下来。

但是我们需要做不用的业务逻辑处理，那么只需要根据消息来自的队列名进行区分处理即可

新建MyAckReceiver2，并把MyAckReceiver注释掉

package com.consumer.receiver;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

@Component
public class MyAckReceiver2 implements ChannelAwareMessageListener {

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //因为传递消息的时候用的map传递,所以将Map从Message内取出需要做些处理
            String msg = message.toString();
            String[] msgArray = msg.split("'");//可以点进Message里面看源码,单引号直接的数据就是我们的map消息数据
            Map<String, String> msgMap = mapStringToMap(msgArray[1].trim(), 3);
            String messageId = msgMap.get("messageId");
            String messageData = msgMap.get("messageData");
            String createTime = msgMap.get("createTime");

            if ("TestDirectQueue".equals(message.getMessageProperties().getConsumerQueue())) {
                System.out.println("消费的消息来自的队列名为：" + message.getMessageProperties().getConsumerQueue());
                System.out.println("消息成功消费到  messageId:" + messageId + "  messageData:" + messageData + "  createTime:" + createTime);
                System.out.println("执行TestDirectQueue中的消息的业务处理流程......");
            }

            if ("fanout.A".equals(message.getMessageProperties().getConsumerQueue())) {
                System.out.println("消费的消息来自的队列名为：" + message.getMessageProperties().getConsumerQueue());
                System.out.println("消息成功消费到  messageId:" + messageId + "  messageData:" + messageData + "  createTime:" + createTime);
                System.out.println("执行fanout.A中的消息的业务处理流程......");
            }

            channel.basicAck(deliveryTag, true);
            //channel.basicReject(deliveryTag, true);//为true会重新放回队列
        } catch (Exception e) {
            channel.basicReject(deliveryTag, false);
            e.printStackTrace();
        }
    }

    //{key=value,key=value,key=value} 格式转换成map
    private Map<String, String> mapStringToMap(String str, int enNum) {
        str = str.substring(1, str.length() - 1);
        String[] strs = str.split(",", enNum);
        Map<String, String> map = new HashMap<String, String>();
        for (String string : strs) {
            String key = string.split("=")[0].trim();
            String value = string.split("=")[1];
            map.put(key, value);
        }
        return map;
    }
}

这时候我们来分别往不同队列推送消息，看看效果
调用接口/sendDirectMessage

消费的消息来自的队列名为：TestDirectQueue
消息成功消费到  messageId:06616446-53f5-474e-b443-2425d1590a63  messageData:test message, hello!  createTime:2021-03-25 20:48:22
执行TestDirectQueue中的消息的业务处理流程......
消费的消息来自的队列名为：fanout.A
消息成功消费到  messageId:09a160ad-342a-4f75-8a94-0f71887b5af1  messageData:message: testFanoutMessage   createTime:2021-03-25 20:48:34

调用接口/sendFanoutMessage

消费的消息来自的队列名为：fanout.A
消息成功消费到  messageId:09a160ad-342a-4f75-8a94-0f71887b5af1  messageData:message: testFanoutMessage   createTime:2021-03-25 20:48:34
执行fanout.A中的消息的业务处理流程......
FanoutReceiverC消费者收到消息  : {createTime=2021-03-25 20:48:34, messageId=09a160ad-342a-4f75-8a94-0f71887b5af1, messageData=message: testFanoutMessage }
FanoutReceiverB消费者收到消息  : {createTime=2021-03-25 20:48:34, messageId=09a160ad-342a-4f75-8a94-0f71887b5af1, messageData=message: testFanoutMessage }

如果你还想新增其他的监听队列，也就是按照这种方式新增配置即可（或者完全可以分开多个消费者项目去监听处理）。

第三章 常见问题

死信队列

DLX，全称为 Dead-Letter-Exchange（死信交换器）。当消息在一个队列中变成死信之后，它能被重新被发送到另一个交换器中，这个交换器就是DLX，绑定 DLX 的队列就称之为死信队列。

延迟队列

当消息被发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费。

场景演示：用户在系统中创建一个订单，如果超过时间用户没有进行支付，那么自动取消订单。

如何处理消息重复消费？

1、全局唯一ID + 消息幂等性：
在消息的生产者端，为每条消息生成一个全局唯一的标识符。消费端，维护一个持久化的存储（如数据库或Redis），存储已经被处理的消息。消费者端每次消费消息前，都先检查该消息是否已经被处理过，如果消息已经被处理过，则忽略；否则处理消息对应的逻辑，并把当前处理成功的消息存储。

2、死信队列：
当消息在队列中无法被正常消费（例如达到最大重试次数）时，可以将其路由到死信队列。这样，可以单独处理这些无法消费的消息，避免它们被反复发送和重复消费。

如何处理消息丢失？

1 生产端消息丢失

原因：生产者发送消息由于网络等原因并没有发送到RabbitMq
解决方案：
1.1、开启RabbitMq事务机制
生产者发送数据之前开启 RabbitMQ 事务channel.txSelect，然后发送消息，如果消息没有成功被 RabbitMQ接收到，那么生产者会收到异常报错，此时就可以回滚事务channel.txRollback，然后重试发送消息。如果收到了消息，那么可以提交事务channel.txCommit，类似我们数据库数据库事务机制。

1.2、开启 confirm 模式
在生产者端设置开启confirm 模式之后，每次写的消息都会分配一个唯一的 ID，如果发送到了 RabbitMQ 中，RabbitMQ 会给你回传一个 ack 消息，告诉你说这个消息已经收到。如果 RabbitMQ 没能处理这个消息，会回调你的一个 nack 接口，告诉你这个消息接收失败，你可以重试。而且可以结合这个机制在自己业务里维护每个消息 ID 的状态，如果超过一定时间还没接收到这个消息的回调，那么可以业务主动重发。

事务机制和 confirm 机制优劣：
事务机制是同步的，提交一个事务之后会阻塞，吞吐量会下来，耗性能。
confirm 机制是异步的，流程不会阻塞，吞吐量较高，性能较好。

2 MQ丢失消息

将消息、队列和交换器持久化，即使RabbitMQ服务器重启，也能恢复消息状态。
重点：必须同时设置队列持久化和消息持久化，再结合生产者的confrim模式，才能保证消息准确投递到broker并保证进入磁盘。

3 消费端丢失消息

原因：消费端在处理消息的过程中出现异常，消息没有得到正常、恰当的处理，导致消息丢失。
解决方案：默认的消息确认机制是消费者一收到消息，就会回一个ack消息给MQ，并且MQ一收到消费端的ack消息，就会将消息从内存或磁盘中移除，所以一般需要关闭RabbitMq自动ack。在业务处理完后，需要手动调用方法发送ack消息给MQ，MQ也会一直等待直到消费端调用basicAck，回复确认消息后，才会将消息从内存或磁盘中移除。

如何处理消息积压？

消息积压是指由于消费者无法及时消费消息，导致消息在消息队列中堆积的情况。

增加消费者数量：适当增加消费者数量以提高消费速度。可以根据系统的负载情况动态地增加或减少消费者的数量。

优化消费逻辑：优化消费者的代码逻辑，查看是否存在阻塞性操作，提升消费者的性能

使用优先级队列：对于重要性不同的消息设置优先级（无消息积压设置了也无效），优先处理高优先级消息。

消息设置过期时间（延迟队列）：可以设置消息的过期时间，当消息在队列中超过一定时间还未被消费时，可以将其丢弃或进行其他处理，避免消息积压。

监控和报警：通过监控消息队列的积压情况，设置阈值告警，及时发现并介入处理消息堆积情况。