【消息队列】万字长文浅析RabbitMQ携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第4天，点击

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第4天，点击查看活动详情

前言📃

在上篇文章中安装完rabbitMq后，输入http://localhost:15672/ ，是可以看到一个简单后台管理界面的。

我们可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。

后台消息推送服务将消息推送到rabbitMq的服务器，然后经过服务器里面的交换机、队列等各种关系（后面会详细讲）将数据处理入列后，最终消费者获取对应监听的消息。

常用的交换机有以下三种，因为消费者是从队列获取信息的，队列是绑定交换机的（一般），所以对应的消息推送/接收模式也会有以下几种：

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 默认交换机，Dead Letter Exchange 死信交换机，这几个该篇暂不做讲述。

快速开始⚡

一共需要创建两个springboot项目，一个 rabbitmq-provider （生产者），一个rabbitmq-consumer（消费者）。注意：这里使用SpringBoot框架集成的amqp版本是包含了RabbitMQ的所有所需依赖的，不需要额外添加别的子依赖。

导入依赖

首先导入依赖(这里可以在上一篇中的Maven项目中改造——依赖替换为SpringBoot的，启动类加上@SpringBootApplication和SpringApplication.run(Application.class, args);即可改造为SpringBoot项目)：

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.deepinsea</groupId>
    <artifactId>rabbitTest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--添加父工程依赖版本-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.7.RELEASE</version>
    </parent>

    <dependencies>
<!--        &lt;!&ndash; https://mvnrepository.com/artifact/com.rabbitmq/amqp-client &ndash;&gt;-->
<!--        <dependency>-->
<!--            <groupId>com.rabbitmq</groupId>-->
<!--            <artifactId>amqp-client</artifactId>-->
<!--            <version>5.10.0</version>-->
<!--        </dependency>-->
<!--        &lt;!&ndash;  引入rabbitmq-client中所需的slf4j日志依赖  &ndash;&gt;-->
<!--        <dependency>-->
<!--            <groupId>org.slf4j</groupId>-->
<!--            <artifactId>slf4j-nop</artifactId>-->
<!--            <version>1.7.2</version>-->
<!--        </dependency>-->

        <!--SpringBoot整合RabbitMQ-->
        <!--amqp-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!--web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

配置application.yml

在配置文件中自动装配连接参数：

application.yml

server:
  port: 8021
spring:
  # 给项目来个名字
  application:
    name: rabbitmq-provider
  # 配置rabbitMq 服务器
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    #虚拟host 可以不设置,使用server默认host(/)
    virtual-host: myVHost

注意： 这里是运行在5672端口，是启动的AMQP协议，非HTTP协议。当然，启用的是GetMapping方法还是可以在浏览器调用的!

消息生产者

1. 配置文件

首先注入Queue、Exchange、Binding对象到Spring容器中：

config/DirectRabbitConfig.java

package com.deepinsea.rabbitTest.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;

/**
 * @author deepinsea
 * @data 2021/1/19 19:02
 */
@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");
    }


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


}

2. 创建消息生产者

然后创建消息生产者：

controller/SendMessageController.java

package com.deepinsea.rabbitTest.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;

/**
 * @author deepinsea
 * @data 2021/1/19 19:03
 */

@RestController
public class SendMessageController {

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

    @GetMapping("/sendDirectMessage")
    public String sendDirectMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        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);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return "ok";
    }

}

3. 调试接口

启动项目，把rabbitmq-provider项目运行，调用下接口(无需添加任何配置，只需一个地址然后请求即可):

注意： 这里的地址后面不能出现多余的空格，否则会因为地址与接口不匹配报404的错误！

后台输出日志：

2021-01-20 01:39:19.717  INFO 3384 --- [nio-8021-exec-2] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2021-01-20 01:39:19.719  INFO 3384 --- [nio-8021-exec-2] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2021-01-20 01:39:19.763  INFO 3384 --- [nio-8021-exec-2] o.s.web.servlet.DispatcherServlet        : Completed initialization in 44 ms
2021-01-20 01:39:19.864  INFO 3384 --- [nio-8021-exec-2] o.s.a.r.c.CachingConnectionFactory       : Attempting to connect to: [127.0.0.1:5672]
2021-01-20 01:39:20.050  INFO 3384 --- [nio-8021-exec-2] o.s.a.r.c.CachingConnectionFactory       : Created new connection: rabbitConnectionFactory#35e478f:0/SimpleConnection@15001695 [delegate=amqp://guest@127.0.0.1:5672/myVHost, localPort= 64820]

web管理界面显示：

这时候，消息已经推送到rabbitMq服务器上面了，并且因为做了持久化关机了消息还存在。

消息消费者

我们这里另外创建一个SpringBoot项目，添加AMQP依赖(依赖与生产者一样)。然后更改配置文件中的port与name即可(其他均一样)：

server:
  port: 8022
spring:
  # 配置服务消费者
  application:
    name: rabbitmq-consumer
  # 配置rabbitMq 服务器
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    #虚拟host 可以不设置,使用server默认host
    virtual-host: myVHost

1. 配置文件

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

config/DirectRabbitConfig.java

package com.deepinsea.rabbitconsumer.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;

/**
 * @author deepinsea
 * @data 2021/1/19 23:49
 * 消费者配置：消费队列、交换机、绑定
 */
@Configuration
public class DirectRabbitConfig {

    /**
     *  队列 起名：TestDirectQueue
     */
    @Bean
    public Queue TestDirectQueue() {
        return new Queue("TestDirectQueue",true);
    }

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

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

}

2. 接收监听器

然后是创建消息接收监听类，DirectReceiver.java：

receiver/DirectReceiver.java

package com.deepinsea.rabbitconsumer.config;

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

import java.util.Map;

/**
 * @author deepinsea
 * @data 2021/1/19 23:53
 * 监听的(消费)队列名称：TestDirectQueue
 */
@Component
@RabbitListener(queues = "TestDirectQueue")
public class DirectReceiver {

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


}

3. 启动项目

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

4. 在线消费测试

上面的可以为在线消费也可以为离线消费，因为关掉了第一个进程的缘故，因此上面的消费是消息推送端离线后的消费！

下面，我们进行在线消费，继续在启动了的两个项目中发送消息和消费消息(可以浏览器地址访问，也可以是Http请求工具发送)：

可以看到，控制台打印出了刚刚发送的5个请求消息！

注意： 因为生产者与消费者同时在开启，生产者生产的消息马上就被消费者消费掉了，因此不存在堆积有任何消息！

5. 1对多消费测试

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

1对2消费测试

首先，将receiver/DirectReceiver.java中的打印信息更换为：

System.out.println("第一个消费者DirectReceiver收到消息  : " + testMessage.toString());

然后，创建一个另外一个消费者类：

receiver/DirectAnotherReceiver.java

package com.deepinsea.rabbitconsumer.receiver;

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

import java.util.Map;

/**
 * @author deepinsea
 * @data 2021/1/20 2:25
 */
@Component
@RabbitListener(queues = "TestDirectQueue")
public class DirectAnotherReceiver {

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

}

启动项目并发送6个请求(生产者与消费者项目得同时开启)：

可以看到两个消费者一共消费了6个消息且是按照顺序消费的，因为RabbitMQ是实现了轮询的方式对消息进行消费，不存在重复消费。

注意： 上面的消费是先在消费者2开始的，这是因为没有创建消费者ID；因此在平级执行的两个消费者之间并不会按照给定的顺序推送消息(会按照某种内部参数执行)，相当于消费者之间相当于Redis中的set（虽然无序，但是下一次执行还是会按照上一次的执行顺序执行）。

1对三消费测试

receiver/DirectThreeReceiver.java

package com.deepinsea.rabbitconsumer.receiver;

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

import java.util.Map;

/**
 * @author deepinsea
 * @data 2021/1/20 2:43
 */
@Component
@RabbitListener(queues = "TestDirectQueue")
public class DirectThreeReceiver {
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("第三个消费者DirectThreeReceiver收到消息  : " + testMessage.toString());
    }

}

在此情况下，启动项目并发送6个请求

可以看到，这里虽然消费者收到的顺序是2-1-3，但是后面的请求还是这个顺序。因此，说明消息队列（也是一种分布式系统）是追求CAP（一致性、可用性、分区容错性）中的可用性与分区容错性，即消息队列不追求在短时间内数据保持一致。

到这里，RabbitMQ消息队列中简单的生产者与消费者（1对1、1对多）的已经成功实现！

下面是关于交换机的配置以及消息堆积等各种情景的进阶处理：

进阶

一、主题交换机(分键多对多—开销小，推荐)

接着，我们使用主题交换机（Topic Exchange ）进行配置！

消息生产者

1. 主题交换机配置

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

config/TopicRabbitConfig.java

package com.deepinsea.rabbitTest.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;

/**
 * @author deepinsea
 * @data 2021/1/20 3:06
 * 主题交换机配置
 */

@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. 主题交换机消息控制器器

然后创建一个控制器SendTopicMessageController，添加多2个接口，用于推送消息到主题交换机：

controller/SendTopicMessageController.java

package com.deepinsea.rabbitTest.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;

/**
 * @author deepinsea
 * @data 2021/1/20 3:11
 */
@RestController
public class SendTopicMessageController {

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

    @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";
    }
}

生产者这边已经完事，先不急着运行！

消息消费者

创建好了主题交换机消息推送机制，下面就是读取到消息的过程了：

1. 键名消息接收器

在rabbitmq-consumer项目上，创建TopicManReceiver.java

receiver/TopicManReceiver.java

package com.deepinsea.rabbitconsumer.receiver;

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

import java.util.Map;

/**
 * @author deepinsea
 * @data 2021/1/20 3:24
 */

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

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

}

2. 总消息接收器

再创建一个TopicTotalReceiver.java总接收器：

receiver/TopicTotalReceiver.java

package com.deepinsea.rabbitconsumer.receiver;

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

import java.util.Map;

/**
 * @author deepinsea
 * @data 2021/1/20 3:27
 */

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

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

3. 主题交换机配置(不是必须)

同样，加主题交换机的相关配置，TopicRabbitConfig.java（消费者一定要加这个配置吗？不需要的其实，理由在前面已经说过了——因为可以不用作为生产者生产消息）：

config/TopicRabbitConfig.java

package com.deepinsea.rabbitconsumer.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;

/**
 * @author deepinsea
 * @data 2021/1/20 3:29
 */

@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.#");
    }

}

4. 启动项目

调用sendTopicMessage1接口

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

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

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

因此：可以得到启发，将每个用户绑定一个唯一的键(UUID、雪花算法等)，这样每个用户就都能一次收到所有的消息了！

调用sendTopicMessage2接口

接下来调用/sendTopicMessage2接口:

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

所以可以看到两个监听消费者==只有==TopicTotalReceiver成功消费到了消息（因为接口2绑定的主题交换机发送者的键是topic.woman，因此只要总消息接收器能收到）

注意： 在启动项目的时候，RabbitMQ在虚拟主机myVHost中创建了topic.man与topic.woman。同时，该消息队列是<K,V>结构，将消息队列更加细分为键名（类似于Redis中String到Hash的转变）。

二、扇形交换机(多对多)

接下来，我们使用扇型交换机（Fanout Exchang ）进行生产-消费配置！

消息生产者

1. 扇形交换机配置

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

config/FanoutRabbitConfig.java

package com.deepinsea.rabbitTest.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;

/**
 * @author deepinsea
 * @data 2021/1/20 4:06
 */

@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());
    }

}

2. 扇形交换机消息发送者

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

controller/CendFanoutMessageController.java

package com.deepinsea.rabbitTest.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;

/**
 * @author deepinsea
 * @data 2021/1/20 4:09
 */
@RestController
public class CendFanoutMessageController {

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

    @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";
    }
}

消息消费者

1. 消息消费类A

receiver/FanoutReceiverA.java

package com.deepinsea.rabbitconsumer.receiver;

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

import java.util.Map;

/**
 * @author deepinsea
 * @data 2021/1/20 4:15
 */

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

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

2. 消息消费类B

receiver/FanoutReceiverB.java

package com.deepinsea.rabbitconsumer.receiver;

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

import java.util.Map;

/**
 * @author deepinsea
 * @data 2021/1/20 4:16
 */

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

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

3. 消息消费类C

receiver/FanoutReceiverC.java

package com.deepinsea.rabbitconsumer.receiver;

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

import java.util.Map;

/**
 * @author deepinsea
 * @data 2021/1/20 4:18
 */

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

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

4. 扇形交换机配置类(双向性)

然后加上扇型交换机的配置类，FanoutRabbitConfig.java（同样可以不加，加上是为了可以双向通信）

config/FanoutRabbitConfig.java

package com.deepinsea.rabbitconsumer.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;

/**
 * @author deepinsea
 * @data 2021/1/20 4:20
 */

@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());
    }
}

5. 启动项目

最后将rabbitmq-provider和rabbitmq-consumer项目都跑起来，调用下接口/sendFanoutMessage ：

然后看看rabbitmq-consumer项目的控制台情况：

继续发送推送消息请求，发现消费者收到消息的顺序发生了改变：

这是因为生产者的messageId做了UUID处理(有顺序的话可以考虑用分布式唯一键)，因此ID是随机发给消费者的！

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

到了这里其实三个常用的交换机的使用我们已经完毕了，那么接下来我们继续讲讲消息的回调，其实就是消息确认（生产者推送消息成功，消费者接收消息成功）。

三、消息回调(解决MQ丢消息)

注意： 本篇文章使用springboot版本为 2.2.7.RELEASE ; 如果你们在配置确认回调，测试发现无法触发回调函数，那么存在原因也许是因为版本过时导致的配置项不起效，可以把publisher-confirms: true 替换为 publisher-confirm-type: correlated

消息生产者

1. 配置文件

application.yml

server:
  port: 8021
spring:
  # 给项目来个名字
  application:
    name: rabbitmq-provider
  # 配置rabbitMq 服务器
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    #虚拟host 可以不设置,使用server默认host
    virtual-host: myVHost

    # 消息确认配置项
    # 确认模式：确认消息已发送到交换机(Exchange)
#    publisher-confirms: true 已经过时了，下面是新版本的配置参数
    publisher-confirm-type: correlated
    # 返回模式：确认消息已发送到队列(Queue)
    publisher-returns: true

注意： 上面提示参数配置已经过时(显示删除线)，那么我们可以通过查看自动配置类源码来找到最新的配置参数：

找到配置文件中的对应的参数：

因此，我们就找到新的配置参数了，读源码找新配置参数是不是很方便？😏

2. 消息确认配置类

然后是配置相关的消息确认回调函数，RabbitConfig.java(这才是完整配置文件吗？😂))

config/RabbitConfig.java

package com.deepinsea.rabbitTest.config;

import com.rabbitmq.client.ConnectionFactory;
import org.springframework.amqp.core.Message;
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;

/**
 * @author deepinsea
 * @data 2021/1/20 4:40
 */

@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;
    }
}

注意： 源码中的RabbitAccessor.java次顶级类中说明了，该set方法是不可重写的

/**
	 * Set the ConnectionFactory to use for obtaining RabbitMQ {@link Connection Connections}.
	 *
	 * @param connectionFactory The connection factory.
	 */
	public final void setConnectionFactory(ConnectionFactory connectionFactory) {
		this.connectionFactory = connectionFactory;
	}

并且也提示了，不能实现反射，因为选项已经被锁死了！

究其原因：spring boot使用rabbitmq传递实体类的时候会发生java对象不能反序列化而抛异常所以要进行以下配置

@Configuration
public class RabbitConfig {

    @Bean
    public RabbitAdmin rabbitTemplate(ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory, MessageConverter messageConverter) {
        RabbitTemplate template = new RabbitTemplate(connectionFactory);
        template.setMessageConverter(messageConverter);
        return template;
    }

    @Bean
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory, MessageConverter messageConverter) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setMessageConverter(messageConverter);
        return factory;
    }

    @Bean
    public MessageConverter messageConverter() {
        return new ContentTypeDelegatingMessageConverter(new Jackson2JsonMessageConverter());
    }
}

解决办法：

我的ConnectionFactory类是导入的rabbitmq-client客户端的依赖包，

import com.rabbitmq.client.ConnectionFactory;

而正确的配置是导入springboot框架的amqp的ConnectionFactory：

import org.springframework.amqp.rabbit.connection.ConnectionFactory;

OK，终于解决了！

到这里，生产者推送消息的消息确认调用回调函数已经完毕。可以看到上面写了两个回调函数，一个叫 ConfirmCallback ，一个叫 RetrunCallback；那么以上这两种回调函数都是在什么情况会触发呢？

3. 消息推送四种情况

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

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

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

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

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

controller/TestMessageAckController.java

package com.deepinsea.rabbitTest.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;

/**
 * @author deepinsea
 * @data 2021/1/20 6:48
 */
@RestController
public class TestMessageAckController {

    /**
     * 使用RabbitTemplate,这提供了接收/发送等等方法
     * 消息确认测试接口类
     */
    @Autowired
    RabbitTemplate rabbitTemplate;

    @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";
    }
}

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

2021-01-20 06:59:37.950  INFO 8108 --- [nio-8021-exec-2] o.s.a.r.c.CachingConnectionFactory       : Created new connection: rabbitConnectionFactory#2bc12da:0/SimpleConnection@592399d2 [delegate=amqp://guest@127.0.0.1:5672/myVHost, localPort= 62336]
2021-01-20 06:59:38.048 ERROR 8108 --- [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory       : Channel shutdown: channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no exchange 'non-existent-exchange' in vhost 'myVHost', class-id=60, method-id=40)
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 'myVHost', class-id=60, method-id=40)

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

②消息推送到server，找到交换机了，但是没找到队列

这种情况就是需要新增一个交换机(虽然上面的直连交换机配置文件中有，只是没有使用)，但是不给这个交换机绑定队列，我来简单地在DirectRabitConfig里面新增一个直连交换机，名叫‘lonelyDirectExchange’，但没给它做任何绑定配置操作：

config/DirectRabitConfig.java

 /**
     * 新增的交换机，但没有与队列绑定
     * @return
     */
    @Bean
    DirectExchange lonelyDirectExchange() {
        return new DirectExchange("lonelyDirectExchange");
    }

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

controller/TestMessageAck2Controller.java

package com.deepinsea.rabbitTest.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;

/**
 * @author deepinsea
 * @data 2021/1/20 7:06
 */
@RestController
public class TestMessageAck2Controller {

    /**
     * 使用RabbitTemplate,这提供了接收/发送等等方法
     * 消息确认测试接口类
     */
    @Autowired
    RabbitTemplate rabbitTemplate;

    @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";
    }
}

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

ReturnCallback:     消息：(Body:'{createTime=2021-01-20 07:10:55, messageId=9945bbbb-b15e-40bb-949d-5fe8c19b6d45, 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:     相关数据：null
ConfirmCallback:     确认情况：true
ConfirmCallback:     原因：null

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

③消息推送到sever，交换机和队列啥都没找到

这种情况其实一看就觉得跟①很像，没错，③和①情况回调是一致的，所以不做结果说明了。结论： ③这种情况触发的是 ConfirmCallback 回调函数。

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

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

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

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

高级进阶

接下来我们继续深挖：消费者接收到消息的消息确认机制

消息确认机制

介绍

和生产者的消息确认机制不同，因为消息接收本来就是在监听消息，符合条件的消息就会消费下来。所以，消息接收的确认机制主要存在三种模式：

①自动确认，这也是默认的消息确认情况。 AcknowledgeMode.NONE 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异常再拒绝入列，选择是否重入列。

但是如果使用不当会导致一些每次都被你重入列的消息一直消费-入列-消费-入列这样循环，会导致消息积压（引申到阿里的rocketMQ的消息堆积处理机制）。

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

channel.basicNack(deliveryTag, false, true);

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

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

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

手动确认机制实现

消费者配置

1. 消息接收类(接收消息)

在消费者项目里:

1、对应的手动确认消息接收类，MyAckReceiver.java（手动确认模式需要实现 ChannelAwareMessageListener）： //之前的相关监听器可以先注释掉，以免造成多个同类型监听器都监听同一个队列。 //这里的获取消息转换，只作参考，如果报数组越界可以自己根据格式去调整

receiver/MyAckReceiver.java

package com.deepinsea.rabbitconsumer.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;

/**
 * @author deepinsea
 * @data 2021/1/20 7:24
 */

@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());
            channel.basicAck(deliveryTag, true); 
            //第二个参数，手动确认可以被批处理，当该参数为 true 时，则可以一次性确认 delivery_tag 小于等于传入值的所有消息
//			channel.basicReject(deliveryTag, true);//第二个参数，true会重新放回队列，所以需要自己根据业务逻辑判断什么时候使用拒绝
        } catch (Exception e) {
            channel.basicReject(deliveryTag, false);
            e.printStackTrace();
        }
    }

    /**
     * {key=value,key=value,key=value} 格式转换成map
     * 
     * @param str
     * @param entryNum
     * @return
     */
    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;
    }
}

2. 消息监听配置类(手动返回确认消息)

2、新建MessageListenerConfig.java上添加代码相关的配置代码：

config/MessageListenerConfig.java

package com.deepinsea.rabbitconsumer.config;

import com.deepinsea.rabbitconsumer.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;

/**
 * @author deepinsea
 * @data 2021/1/20 7:21
 */

@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);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        // RabbitMQ默认是自动确认，这里改为手动确认消息
        //设置一个队列
        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），再创建消息监听配置类（MessageListenerConfig），因为消息监听配置类需要自动注入消息接收类对象。实现思路是：

服务端发送消息=> 客户端收到消息(消息接收类) => 客户端确认消息(消息监听配置类) => 服务端收到消息(回调函数配置类)

3. 启动项目

这时，先调用接口/sendDirectMessage，给直连交换机TestDirectExchange的队列TestDirectQueue 推送一条消息，可以看到监听器正常消费了下来：

生产者控制台：

消费者控制台：

多队列手动确认模式(多对1手动确认)

介绍

但是这个场景往往不够！因为很多伙伴之前给我评论反应，他们需要这个消费者项目里面，监听的好几个队列都想变成手动确认模式，而且处理的消息业务逻辑不一样。

==没有问题，接下来看代码==

场景

场景： 除了直连交换机的队列TestDirectQueue需要变成手动确认以外，我们还需要将一个其他的队列

或者多个队列也变成手动确认，而且不同队列实现不同的业务处理。

实现思想：通过监听扇形交换机消息发送者来达到实现多个队列的监听

消费者配置

1. 配置多队列监听容器(SimpleMessageListenerContainer)

因为上文配置了单队列监听容器（MessageListenerConfig.java），因此我们只需修改一下配置即可实现(具体就是添加扇形交换机发送者到监听容器里)：

那么我们需要做的第一步，往SimpleMessageListenerContainer里添加多个队列：

config/MessageListenerConfig.java

package com.deepinsea.rabbitconsumer.config;

import com.deepinsea.rabbitconsumer.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;

/**
 * @author deepinsea
 * @data 2021/1/20 7:21
 */

@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);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        // RabbitMQ默认是自动确认，这里改为手动确认消息
        //设置一个队列
//        container.setQueueNames("TestDirectQueue");
        container.setQueueNames("TestDirectQueue","fanout.A");
        //如果同时设置多个如下： 前提是队列都是必须已经创建存在的，那还不如监听扇形交换机(只有一个接口就行)
        //  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;
    }
}

2. 配置手动确认消息接收(监听)类

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

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

receiver/MyAckReceiver.java

package com.deepinsea.rabbitconsumer.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;

/**
 * @author deepinsea
 * @data 2021/1/20 7:24
 */

@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");

            // 监听的单个消息队列并返回消息的时代(1对1，即同一时刻一个人返回数据)过去了，下面是多个人与单个人的情况判断
//            System.out.println("  MyAckReceiver  messageId:"+messageId+"  messageData:"+messageData+"  createTime:"+createTime);
//            System.out.println("消费的主题消息来自："+message.getMessageProperties().getConsumerQueue());
            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);
            //第二个参数，手动确认可以被批处理，当该参数为 true 时，则可以一次性确认 delivery_tag 小于等于传入值的所有消息
//          channel.basicReject(deliveryTag, true);//第二个参数，true会重新放回队列，所以需要自己根据业务逻辑判断什么时候使用拒绝
        } catch (Exception e) {
            channel.basicReject(deliveryTag, false);
            e.printStackTrace();
        }
    }

    /**
     * {key=value,key=value,key=value} 格式转换成map
     *
     * @param str
     * @param entryNum
     * @return
     */
    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;
    }
}

ok，这时候我们来分别往不同队列推送消息，看看效果：

3. 调用sendDirectMessage 和sendFanoutMessage 接口

调用接口/sendDirectMessage 和 /sendFanoutMessage ，

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

好，这篇Springboot整合rabbitMq教程就暂且到此。

面试题总结

1. 怎么保证消息不丢失

因为消息队列是基于内存的，所以rabbitmq重启后会丢失之前的数据。所以必须开启持久化将消息持久化到磁盘，这样就算rabbitmq挂了，恢复之后会自动读取之前存储的数据，一般数据不会丢失。除非极其罕见的情况，rabbitmq还没来得及持久化自己就挂了，这样可能导致一部分数据丢失。

那么如何防止消息的丢失呢？

1:生产者丢失消息

生产者开启事务

生产者在发送数据之前开启事物，然后发送消息，如果消息没有成功被rabbitmq接收到，那么生产者会受到异常报错，这时就可以回滚事物，然后尝试重新发送；如果收到了消息，那么就可以提交事物。

  channel.txSelect();//开启事物
  try{
  }catch(Exection e){
      channel.txRollback()；//回滚事物
      //重新提交
  }

缺点：rabbitmq事物一旦开启，就会变为同步阻塞操作，生产者会阻塞等待是否发送成功，太耗性能会造成吞吐量的下降。这有点违背我们的初衷了。

开启confirm模式

生产者开启了confirm模式之后，每次写的消息都会分配一个唯一的id，然后如何写入了rabbitmq之中，rabbitmq会给你回传一个ack消息，告诉你这个消息发送OK了；如果rabbitmq没能处理这个消息，会回调你一个nack接口，告诉你这个消息失败了，你可以进行重试。而且你可以结合这个机制知道自己在内存里维护每个消息的id，如果超过一定时间还没接收到这个消息的回调，那么你可以进行重发。

    //开启confirm
    channel.confirm();
    //发送成功回调
    public void ack(String messageId){
      
    }

    // 发送失败回调
    public void nack(String messageId){
        //重发该消息
    }

事务机制是同步的，你提交了一个事物之后会阻塞住，但是confirm机制是异步的，发送消息之后可以接着发送下一个消息，然后rabbitmq会回调告知成功与否。一般在生产者这块避免丢失，都是用confirm机制。

2.MQ丢失了消息 我们说了对于mq丢失消息的话我们可以开启mq的持久化，而且持久化和生产者的confirm机制配合起来，只有消息持久化到了磁盘，才会个生产者发送ack，这样就算是在持久化之前rabbitmq挂了，数据丢了，生产者收不到ack回调也会进行消息重发。

3.消费者丢失消息 使用rabbitmq提供的ack机制，首先关闭rabbitmq的自动ack，然后每次在确保处理完这个消息之后，在代码里手动调用ack。这样就可以避免消息还没有处理完就ack。

2. 怎么防止消息重复消费

解决思路是：保证消息的唯一性，就算是多次传输，不要让消息的多次消费带来影响；另外保证消息等幂性。

统计了一下，总共有10017词，感谢观看ヾ(◍°∇°◍)ﾉﾞ！