springboot整合rabbitmq超详细教学

rabbitmq

什么是消息队列

MQ全称为Message Queue，即消息队列。“消息队列”是在消息的传输过程中保存消息的容器。它是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。简而言之，在 “生产者”(消息发送者) 与 “消费者”(消息接收者) 之间架起一座可靠的信息传递桥梁

开发中消息队列通常有如下应用场景：

1. 系统解耦： 比如我们原来的需求是向购买课程者发送邮件和系统中的消息，但是需求突然变更，觉得，老师也要接到开课的提醒，其实消息主体内容是相同，只是提示的文案不太一样时，若是用代码解决，我们就需要写接口,定义一些东西告诉app端，但若是通过MQ发送消息，我们就不需要添加新的接口，把消息推送给app的老师端，app修改一下文案即可。
2. 异步调用： 比如有一个人希望注册为一位老师，但是后台需要做一些类似查询数据库他是否有资格，是不是黑名单中的用户，做完这些，开始为他插入一条老师的数据，还可能有一些需要创建的关系数据，最后再发送消息提示用户注册成功，未免太慢了一些，其实我们完全可以在确认他可以注册老师后，插入数据库之前，将数据插入mq，发送消息给用户，这样老师收到到通知就可以去做一些类似创建课程的后续操作了
3. 流量削峰： 比如秒杀场景，远远超过了平时服务器所能处理能力的上限，假设平时一次可以处理1000条数据，此时突然在极短的时间内一起涌入了100000条数据，这就很有可能使得服务器宕机。若是在服务器前，挡上一层MQ，MQ就可以延缓请求，减小服务器的压力，不至于宕机。

AMQP和JMS

MQ是消息通信的模型，并发具体实现。现在实现MQ的有两种主流方式：AMQP、JMS。

两者间的区别和联系：

JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式

JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。

JMS规定了两种消息模型；而AMQP的消息模型更加丰富

AMQP（Advanced Message Queuing Protocol，高级消息队列协议）是一个进程间可靠、通用的传递异步消息的网络协议，就类似于SMTP、HTTP、FTP等是一种协议，它是专门用来统一消息服务的一种协议，为消息中间件设计的，且不受开发语言的限制。

RabbitMQ：基于AMQP协议，erlang语言开发，稳定性好

RabbitMQ工作原理：

黄色的圈圈就是我们的消息推送服务，将消息推送到 中间方框里面也就是 rabbitMq的服务器，然后经过服务器里面的交换机、队列等各种关系（后面会详细讲）将数据处理入列后，最终右边的蓝色圈圈消费者获取对应监听的消息。

组成部分说明：

Producer： 消息生产者，投递消息。
Connection： 每次访问 RabbitMQ 都建立一个 Connection，将 publisher、consumer 和 broker 连接起来
Channel： Channel 在 connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个 thread 创建单独的 channel 进行通讯，且 channel 之间是完全隔离的（Channel 作为轻量级的Connection 极大减少了操作系统建立 TCP connection 的开销）
Broker： 接收和分发消息的应用。
Exchange： message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到 queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and fanout(multicast)。

生产者发送消息流程：

1、生产者和Broker建立TCP连接。

2、生产者和Broker建立通道。

3、生产者通过通道消息发送给Broker，由Exchange将消息进行转发。

4、Exchange将消息转发到指定的Queue（队列）

消费者接收消息流程：

1、消费者和Broker建立TCP连接

2、消费者和Broker建立通道

3、消费者监听指定的Queue（队列）

4、当有消息到达Queue时Broker默认将消息推送给消费者。

5、消费者接收到消息。

6、ack回复

RabbitMQ三种Exchange重要模式

1.Fanout模式

Fanout—发布与订阅模式，是一种广播机制，它是没有路由key的模式，只要将队列绑定到交换机上，则该交换机接收到的消息都会被转发到与该交换机绑定的所有队列上。所以，Fanout交换机转发消息是最快的。

2.Direct模式

Direct—路由模式，是基于fanout模式上的一种叠加，增加了路由routingKey，即：所有发送到 Direct Exchange 的消息会被转发到 routingKey 中指定的 Queue，所以在消息传递时需要注意的是，routingKey必须完全匹配才会被队列接收，否则该消息会被抛弃。

3.Topic模式

Topic模式是基于direct模式上的一种叠加，增加了模糊路由routingKey，即：可以使用通配符进行模糊匹配。
×××.# : 匹配0或1级又或多级
×××.* : 匹配有且只能有1级

* (星号) 用来表示一个单词 (必须出现的)
# (井号) 用来表示任意数量（零个或多个）单词

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

项目运用

package com.autel.cloud.report.manage.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@Slf4j
public class RabbitMqConfig {

    /**
     * 生成pdf队列
     */
    public static final String CREATE_PDF_REPORT_EXCHANGE = "bggl.pdf.report.app.pdf.exchange";
    public static final String CREATE_PDF_REPORT_ROUTING_KEY = "bggl.pdf.report.app.pdf.routingKey";
    public static final String CREATE_PDF_REPORT_QUEUE = "bggl.pdf.report.app.pdf.queue";


	//直连交换机
    @Bean
    public DirectExchange createPdfReportExchange() {
        return new DirectExchange(CREATE_PDF_REPORT_EXCHANGE, true, false);
    }
	//队列
    @Bean
    public Queue createPdfReportQueue() {
        return QueueBuilder.durable(CREATE_PDF_REPORT_QUEUE).build();
    }
	//路由键
    @Bean
    public Binding createPdfReportBinding() {
        return BindingBuilder.bind(createPdfReportQueue()).to(createPdfReportExchange()).with(CREATE_PDF_REPORT_ROUTING_KEY);
    }
}

package com.autel.cloud.report.manage.mq;

import com.alibaba.fastjson.JSON;
import com.autel.cloud.report.manage.api.dto.report.NoticeGenerateReportDto;
import com.autel.cloud.report.manage.config.RabbitMqConfig;
import com.autel.cloud.report.manage.service.IPdfReportService;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @author by X20025 (liujinxing)
 * @description 生成pdf报告监听器
 * @date 2021/8/3 11:00
 */
@Component
@Slf4j
public class CreatePdfReportListener {
    @Autowired
    private IPdfReportService pdfReportService;

    @RabbitListener(queues = RabbitMqConfig.CREATE_PDF_REPORT_QUEUE)
    public void consume(Message message, Channel channel) {
        log.info("消费消息开始...");
        byte[] bytes = message.getBody();
        String s = new String(bytes);
        log.info("监听到的消息：{}", s);
        NoticeGenerateReportDto noticeGenerateReportDto = JSON.parseObject(s, NoticeGenerateReportDto.class);

        // todo 重复消费校验
        MessageProperties properties = message.getMessageProperties();
        long deliveryTag = properties.getDeliveryTag();
        try {
            /**
             * 1.从data-insight中查诊断报告详情接口；
             * 2.生成pdf文件；
             * 3.上传pdf文件到s3；
             * 4.附件地址插入到pdf表（存在则更新）
             */
            pdfReportService.generatePdfReportBusinessProcess(noticeGenerateReportDto);
        } catch (Exception e) {
            log.error("消费消息业务逻辑处理异常", e);
        }

    }
}

springboot集成rabbitmq

rabbitmq-provider:

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

# 服务端口
server:
  port: 8080
# 配置rabbitmq服务
spring:
  rabbitmq:
    host: 10.240.3.153
    port: 5672
    username: admin
    password: admin

    #消息确认配置项

    #确认消息已发送到交换机(Exchange)
    publisher-confirms: true
    #确认消息已发送到队列(Queue)
    publisher-returns: true

direct exchange(直连型交换机):

package com.autel.rabbitmqprovider.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);
        return  new Queue("TestDirectQueue",true);
    }

    //Direct交换机（直连型） 起名：TestDirectExchange
    @Bean
    public DirectExchange TestDirectExchange(){
        return new DirectExchange("TestDirectExchange",true,false);
    }

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

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


}

package com.autel.rabbitmqprovider.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 {
    @Autowired
    //提供了接受、发送等方法；
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendDirectMessage")
    public  String sendDirecrMessage(){
        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";
    }

调用接口：

目前消息没有被消费的，我们去rabbitMq管理页面看看，是否推送成功：

rabbitmq-consumer：

        <!--rabbitmq-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
    

# 服务端口
server:
  port: 8081
# 配置rabbitmq服务
spring:
  rabbitmq:
    host: 10.240.3.153
    port: 5672
    username: admin
    password: admin
    #消息确认配置项

    #确认消息已发送到交换机(Exchange)
    publisher-confirms: true
    #确认消息已发送到队列(Queue)
    publisher-returns: true

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

配置多台监听绑定到同一个直连交互的同一个队列

package com.autel.rabbitmqconsumer.mq;
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消费者收到消息  : " + testMessage.toString());
    }
}

package com.autel.rabbitmqconsumer.mq;

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 DirectReceivernew {
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("第二个DirectReceiver消费者收到消息  : " + testMessage.toString());
    }
}

Topic Exchange 主题交换机:

package com.autel.rabbitmqprovider.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 static  final  String  man = "topic.man";
    public static  final  String  woman = "topic.woman";

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

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

 @GetMapping("/sendTopicMessage")
    public  String sendTopicMessage(){
        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  "topicExchange Ok";
    }
 
  @GetMapping("/sendTopicMessage1")
    public String sendTopicMessage1() {
        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";
    }

@Component
@RabbitListener(queues = "topic.man")
public class TopicManReceiver {
    @RabbitHandler
    public void  process(Map testMessage){
        System.out.println("TopicManReceiver消费者收到消息  : " + testMessage.toString());
    }

}

@Component
@RabbitListener(queues = "topic.woman")
public class TopicTotalReceiver {
    @RabbitHandler
    public void process(Map testMessage){
        System.out.println("TopicTotalReceiver消费者收到消息  : " + testMessage.toString());
    }
}

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

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

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

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

Fanout Exchang 扇型交换机：

package com.autel.rabbitmqprovider.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 "fanoutMessage ok!";
    }

package com.autel.rabbitmqconsumer.mq;

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 messageMap){
        System.out.println("FanoutReceiverA消费者收到消息  : " + messageMap.toString());
    }

}

消息确认（生产者推送消息成功，消费者接收消息成功）

发送消息确认：用来确认生产者 producer 将消息发送到 broker ，broker 上的交换机 exchange 再投递给队列 queue的过程中，消息是否成功投递。

消息从 producer 到 rabbitmq broker有一个 confirmCallback 确认模式。

消息从 exchange 到 queue 投递失败有一个 returnCallback 退回模式。

我们可以利用这两个Callback来确保消息的100%送达。

#确认消息已发送到交换机(Exchange)
    publisher-confirms: true
    #确认消息已发送到队列(Queue)
    publisher-returns: true

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

package com.autel.rabbitmqprovider.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
            //重写其confirm()方法，方法内有三个参数correlationData、ack、cause。
			//correlationData：对象内部只有一个 id 属性，用来表示当前消息的唯一性。
			//ack：消息投递到broker 的状态，true表示成功。
			//cause：表示投递失败的原因。
            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，交换机和队列啥都没找到
④消息推送成功

①消息推送到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 回调函数。

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

这种情况就是需要新增一个交换机，但是不给这个交换机绑定队列，我来简单地在DirectRabitConfig里面新增一个直连交换机，
//    名叫‘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";
    }

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

结论：②这种情况触发的是 ConfirmCallback和RetrunCallback两个回调函数。

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

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

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

消息接收的确认机制主要存在三种模式：

①自动确认

② 根据情况确认

③ 手动确认

消费者收到消息后，手动调用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表示没有被正确处理；

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

package com.autel.rabbitmqconsumer.config;
import com.autel.rabbitmqconsumer.mq.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);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); // RabbitMQ默认是自动确认，这里改为手动确认消息
        //设置一个队列
//        container.setQueueNames("TestDirectQueue");
        //如果同时设置多个如下： 前提是队列都是必须已经创建存在的
          container.setQueueNames("TestDirectQueue","topic.man","topic.woman","fanout.A","fanout.B","fanout.C");


        //另一种设置队列的方法,如果使用这种情况,那么要设置多个,就使用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.autel.rabbitmqconsumer.mq;

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

            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中的消息的业务处理流程......");

            }

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

            }

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

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

AMQP和JMS：

​ 实现Mq的两种主流方式;

​ jms只能用java，amqp只是协议，不规定实现方式，跨语言。

​ jms定义了统一的接口，来对消息操作进行统一；amqp是通过规定协议来统一数据交互的格式。

RabbitMq：基于amqp协议,erlang语言开发，稳定性好。