RabbitMQ详解_rabbitmq上下游-CSDN博客

本文链接：https://blog.csdn.net/qq_41910252/article/details/122688733

一、概念

1.什么是MQ

MQ(message queue),从字面意思看，本质是个队列，FIFO先入先出，只不过队列中存放的内容是message而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中,MQ是一种非常常见的上下游"逻辑解耦+物理解耦"的消息通信服务。使用了MQ之后，消息发送上游只需要依赖MQ，不用依赖其他服务。

2.为什么要用MQ

流量削峰

举个例子，如果订单系统最多能处理一万订单，这个处理能力应付正常时段的下单是卓卓有余的，正常时段我们下单一秒后就能返回结果，但是在高峰期，如果有两万订单，系统是处理不了的，只能限制订单超过一万单后不允许用户下单。使用消息队列做缓冲，我们可以取消这个限制，把一秒内下的订单分散成一段时间来处理，这时有些用户可能在下单十几秒后才能收到下单成功的操作，但是比不能下单的体验要好。

应用解耦

以电商应用为例，应用中有订单系统、库存系统、物流系统、支付系统等。用户创建订单后，如果耦合调用库存系统，物流系统，支付系统，任何一个子系统出了故障，都会造成下单异常。当转变成基于消息队列的方式后，系统间调用的问题会少很多，比如物流系统因为发生故障，需要几分钟来修复。在这几分钟内，物流系统要处理的内存被缓存在消息队列中，用户的下单操作可以正常完成。当物流系统恢复后，继续处理订单信息即可。中间用户感受不到物流系统的故障，提升系统的可用性。

异步处理

有些服务间调用是异步的，例如A调用B，B需要花费很长时间执行，但是A需要知道B什么时候可以执行完，以前一般有两种方式，A过段时间去调用B的查询api查询。或者A提供一个callback api，B执行完之后调用api通知A。这两种方式都不是很优雅，使用消息总线，可以很方便解决这个问题，A调用B服务后，只需要监听B处理完成的消息，当B处理完成后，会发送一条消息给MQ，MQ会将此消息转发给A。这样A服务即不用循环调用B的查询api，也不用提供callback api。A就可以及时的得到异步处理成功的消息。

3.MQ的分类

ActiveMQ

优点：单机吞吐量万级，时效性ms级，可用性高，基于主从架构实现高可用性，消息可靠性较低的概率丢失数据。

缺点：官方社区现在对ActiveMQ维护越来越少，高吞吐量场景较少使用。

Kafka

大数据的杀手锏，谈到大数据领域内的消息传输，则绕不开kafka，这款专为大数据而生的消息中间件，以其百万级TPS的吞吐量名声大噪，迅速成为大数据领域的宠儿，在数据采集、传输、存储的过程中发挥着举足轻重的作用。

优点

性能卓越，单机写入TPS约在百万条/秒，最大的优点，就是吞吐量高。
时效性ms级
可用性非常高，kafka是分布式的，一个数据多个副本，少数机器宕机，不会丢失数据，不会导致不可用
消费者采用pull方式获取消息，消息有序，通过控制能够保证所有消息被消息且仅被消息一次
有优秀的第三方kafka Web管理界面Kafka Mananger
在日志领域比较成熟，被多家公司和多个开源项目使用
功能支持：功能较为简单，主要支持简单的MQ功能，在大数据领域的实时计算以及日志采集被大规模使用

缺点

kafka单机超过64个队列/分区，Load会发生明显的飙高现象，队列越多，load越高，发送消息响应时间越长
使用短轮询方式，实时性取决于轮询间隔时间
消费失败不支持重试
支持消息顺序，但是一台机器宕机后，就会产生消息乱序
社区更新缓慢

RocketMQ

RocketMQ出自阿里巴巴的开源产品，用Java语言实现，在设计时参考了kafka，并作出了自己的一些改进。被阿里巴巴广泛应用在订单，交易，充值，流计算，消息推送，日志流式处理，binglog分发等场景。

优点

单机吞吐量十万级
可用性非常高
分布式架构，扩展性好
消息可以做到0丢失
MQ功能较为完善
支持10亿级别的消息堆积，不会因为堆积导致性能下降

缺点

支持的客户端语言不多，目前是java及c++，其中c++不成熟
社区活跃度一般
没有在MQ核心中去实现JMS等接口，有些系统要迁移需要修改大量代码

RabbitMQ

是一个在AMQP(高级消息队列协议)基础上完成的，可复用的企业消息系统，是当前最主流的消息中间件之一。

优点

由于erlang语言的高并发特性，性能较好
吞吐量万级
MQ功能比较完备，健壮，稳定，易用
跨平台，支持多种语言，如python，java，.net，PHP等
支持ajax
文档齐全
开源提供的管理界面非常棒
社区活跃度高，更新频率高

缺点

商业版需要收费，学习成本较高

4.MQ的选择

kafka

kafka主要特点是基于pull的模式来处理消息消费，追求高吞吐量，一开始的目的就是用于日志收集和传输，适合产生大量数据的互联网服务的数据收集业务。大型公司建议选用。如果有日志收集功能，肯定是首选kafka。

RocketMQ

天生为金融互联网领域而生，对于可靠性要求很高的场景，尤其是电商里面的订单扣款，以及业务削峰，在大量交易涌入时，后端可能无法及时处理的情况。Rocket在稳定性上可能更值得信赖，这些业务场景在阿里双11已经经历多次考验，如果业务中有上述场景，建议可以选择RocketMQ。

RabbitMQ

结合erlang语言本身的并发优势，性能好时效性微妙级，社区活跃度高，管理界面用起来十分方便，如果你的数据量没有那么大，中小型公司优先选择功能比较完备的RabbitMQ。

二、RabbitMQ

1.概念

RabbitMQ是一个消息中间件，他接受并转发消息。你可以把它当做一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人哪里，按照这种逻辑RabbitMQ是一个快递站，一个快递员帮你传递快件。RabbitMQ与快递站的主要区别在于，它不处理快件而是接收，存储和转发消息数据。

2.四大核心概念

生产者

产生数据发送消息的程序是生产者

交换机

交换机是RabbitMQ非常重要的一个部件，一方面它接收来自生产者的消息，另一方面它将消息推送到队列中。交换机必须确切的知道如何处理它接收到的消息，是将这些消息推送到特定队列还是推送到多个队列，亦或者是把消息丢弃，这个得由交换机类型决定。

队列

队列是RabbitMQ内部使用的一种数据结构，尽管消息流经RabbitMQ和应用程序，但他们只能存储在队列中。队列仅受主机的内存和磁盘限制的约束，本质上是一个大的消息缓冲区。许多生产者可以将消息发送到一个队列，许多消费者可以尝试从一个队列接收数据。这就是我们使用队列的方式。

消费者

消费与接收具有相似的含义。消费者大多时候是一个等待接收消息的程序。请注意生产者、消费者和消息中间件很多时候并不在同一机器上。同一个应用程序既可以是生产者也可以是消费者。

3.名词介绍

Broker

接收和分发消息的应用,RabbitMQ Server就是Message Broker。

VritualHost

出于多租户和安全因素设计，把AMQP的基本组件划分到一个虚拟的分组中，类似于网络中的namespace概念。当多个不同用户使用同一个RabbitMQ Server提供的服务时，可以划分出多个vhost，每个用户在自己的vhost创建exchange/queue等。

Connection

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

Channel

如果每一次访问RabbitMQ都建立一个Connection，在消息量大的时候建立TCP Connection的开销将是巨大的，效率也较低。Channel是在Connection内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的channel进行通讯，AMQP method包含了channel id帮助客户端和message broker识别channel，所以channel之间是完全隔离的。Channel作为轻量级的Connection极大减少了操作系统建立TCP Connection的开销。

Exchange

message到达broker的第一站，根据分发规则，匹配查询表中的routing key，分发消息到queue中去。常用的类型有：direct（point-to-point）、topic（publish-subscribe）、fanout（multicast）。

Queue

消息最终被发送到这里等待consumer取走。

Binding

exchange和queue之间的虚拟连接。binding中可以包含routing key，Binding信息被保存到exchange中查询表中，用于message的分发依据。

4. 什么是AMQP

AMQP:Advanced Message Queuing Protocol(高级消息队列协议)。是应用层协议的一个开发标准，为面向消息的中间件设计。

5.安装

下载erlang rpm包

下载地址：https://packagecloud.io/rabbitmq/erlang          （可自行选择版本）。

下载rabbitmq rpm包

下载地址 ： https://github.com/rabbitmq/rabbitmq-server/releases     （可自行选择版本）。

安装erlang环境

 rpm -ivh erlang-21.3.8.18-1.el7.x86_64.rpm

安装socat

 yum install socat  -y

安装rabbitmq

 rpm -ivh rabbitmq-server-3.8.8-1.el7.noarch.rpm

如果出现以下问题

使用以下命令进行解决

lsattr /etc/passwd
#得到的结果，发现多了个a权限
-----a--------e---- /etc/passwd
#执行以下命令
chattr -a /etc/passwd
#再次执行安装rabbitmq
rpm -ivh rabbitmq-server-3.8.8-1.el7.noarch.rpm
#报以下错误
useradd: cannot open /etc/shadow
error: %pre(rabbitmq-server-3.8.8-1.el7.noarch) scriptlet failed, exit status 1
error: rabbitmq-server-3.8.8-1.el7.noarch: install failed
#执行命令
chattr -a /etc/shadow
#再次执行安装命令，发现安装成功
rpm -ivh rabbitmq-server-3.8.8-1.el7.noarch.rpm

添加开机启动RabbitMQ服务

chkconfig rabbitmq-server on

启动服务

/sbin/service rabbitmq-server start

查看服务状态

/sbin/service rabbitmq-server status

停止服务

/sbin/service rabbitmq-server stop

开启web界面插件

rabbitmq-plugins enable rabbitmq_management

浏览器对rabbitmq管理界面进行访问，IP:15672，如果打不开，查看服务器的防火墙

查看防火墙状态

systemctl status firewalld

处于关闭状态

关闭防火墙

systemctl stop firewalld

禁用防火墙

systemctl enable firewalld

使用默认账号密码guest登录，会出现以下问题

添加一个新的用户

创建账号

rabbitmqctl add_user admin 123456

设置用户角色

rabbitmqctl set_user_tags admin administrator

设置用户权限

#语法 set_permissions [-p <vhostpath>] <user> <conf> <write> <read>
#用户admin具有/vhost这个virtual host中所有资源的配置、写、读权限
rabbitmqctl set_permissions -p "/" admin ".*" ".*" ".*"

当前用户和角色

rabbitmqctl list_users

修改密码

rabbitmqctl change_password admin admin123

到这里就安装完成了。

三、Hello World（简单模式）

我们将用 Java 编写两个程序；一个发送单个消息的生产者，一个接收消息并打印出来的消费者。我们将忽略 Java API 中的一些细节，专注于这个非常简单的事情只是为了开始。这是消息的“Hello World”。

在下图中，“P”是我们的生产者，“C”是我们的消费者。中间的框是一个队列——一个 RabbitMQ 代表消费者保存的消息缓冲区。

导入依赖

<!--rabbitmq客户端依赖-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.10.0</version>
        </dependency>

生产者

package com.zjb.simple;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * 生产者
 */
public class Producer {

    public static final String QUEUE_NAME = "hello";
    public static void main(String[] args) {

        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("139.196.112.71");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("123456");
        factory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            //2.创建连接
            connection = factory.newConnection();
            //3.通过连接获取通道
            channel = connection.createChannel();
           /**
             * @param1 队列的名称
             * @param2 是否持久化 false：不持久化 true:持久化（持久化是指将消息保存到磁盘中），默认情况是保存到内存中
             * @param3 是否是独占队列  true:可以多个消费者消费  false:只能一个消费者消费
             * @param4 是否自动删除  最后一个消费者消费完成后是否自动删除消息 true:自动删除  false:不自动删除
             * @param5 附属参数
             */
            //4.声明队列
            channel.queueDeclare(QUEUE_NAME,false,false,false,null);
            //5.发送消息
            String message = "Hello World";
            /**
             * @param1 交换机名称
             * @param2 路由key，本次使用队列的名称
             * @param3 其它参数信息
             * @param4 消息体
             */
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
            System.out.println("消息发送成功");
        } catch (Exception e) {

        } finally {
            //6.关闭通道
            if(channel!=null && channel.isOpen()){
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //7.关闭连接
            if(connection!=null && connection.isOpen()){
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

查看控制台

消费者

package com.zjb.simple;

import com.rabbitmq.client.*;

/**
 * 消费者
 */
public class Consumer {
    public static final String QUEUE_NAME = "hello";
    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("139.196.112.71");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("123456");
        factory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            /**
             * @param1 队列名称
             * @param2 消费成功后是否自动确认 true:自动确认 false:手动确认
             * @param3 消费者成功消费回调
             * @param4 消费者取消消费回调
             */
            DeliverCallback deliverCallback = (consumerTag,message) ->{
                System.out.println("收到消息:"+new String(message.getBody(),"UTF-8"));
            };
            CancelCallback cancelCallback = consumerTag ->{
                System.out.println("消息消费失败");
            };
            //消费消息
            channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(channel!=null && channel.isOpen()){
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null && connection.isOpen()){
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

查看控制台

四、Work Queues（工作队列模式）

工作队列（又名：任务队列）背后的主要思想是避免立即执行资源密集型任务而不得不等待它完成。相反，我们将任务安排在以后完成。我们将任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。

1.轮询分发消息

生产者

package com.zjb.work_queue;

import com.rabbitmq.client.Channel;
import com.zjb.utils.MqUtil;

import java.util.Scanner;

public class WorkProducer {
    public static final String QUEUE_NAME = "hello";
    public static void main(String[] args)throws Exception {

        Channel channel = MqUtil.getChannel();

        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String message = scanner.next();
            MqUtil.publish(channel,QUEUE_NAME,message);
            System.out.println("消息发送成功:"+message);
        }
    }
}

消费者

package com.zjb.work_queue;

import com.rabbitmq.client.Channel;
import com.zjb.utils.MqUtil;

public class WorkConsumer {
    public static final String QUEUE_NAME = "hello";
    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();
        System.out.println("消费者1号");
        MqUtil.consumer(channel,QUEUE_NAME);
    }
}

MqUtil

package com.zjb.utils;

import com.rabbitmq.client.*;

public class MqUtil {

    public static Channel getChannel() throws Exception{
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("123456");
        factory.setVirtualHost("/");

        Connection connection  = factory.newConnection();
        Channel channel = connection.createChannel();

        return channel;
    }


    public static void consumer( Channel channel,String queueName)throws Exception{

        DeliverCallback deliverCallback = (consumerTag, message) ->{
            System.out.println("收到消息:"+new String(message.getBody(),"UTF-8"));
        };
        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        /**
         * @param1 队列名称
         * @param2 消费成功后是否自动确认 true:自动确认 false:手动确认
         * @param3 消费者成功消费回调
         * @param4 消费者取消消费回调
         */
        //消费消息
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }


    public static void publish(Channel channel,String queueName,String message)throws Exception{
        /**
         * @param1 队列的名称
         * @param2 是否持久化 false：不持久化 true:持久化（持久化是指将消息保存到磁盘中），默认情况是保存到内存中
         * @param3 是否是独占队列  true:可以多个消费者消费  false:只能一个消费者消费
         * @param4 是否自动删除  最后一个消费者消费完成后是否自动删除消息 true:自动删除  false:不自动删除
         * @param5 附属参数
         */
        //4.声明队列
        channel.queueDeclare(queueName,false,false,false,null);
        //5.发送消息
        /**
         * @param1 交换机名称
         * @param2 路由key，本次使用队列的名称
         * @param3 其它参数信息
         * @param4 消息体
         */
        channel.basicPublish("",queueName,null,message.getBytes());
    }
}

先启动两个线程的消费者

启动生产者，发送消息，在控制台中输入AA、BB、CC、DD

去看下消费者1号和消费者2号

默认情况下，RabbitMQ 会按顺序将每条消息发送给下一个消费者。平均而言，每个消费者都会收到相同数量的消息。这种分发消息的方式称为循环。

2.消息应答

概念

消费者完成一个任务可能需要一段时间。如果其中一个消费者处理一个长的任务并只完成了部分突然就挂掉了，会发生什么情况。 RabbitMQ 一旦向消费者传递了一条消息，便立即将其标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息，以及后续发送给该消费者的消息，因为它无法接收到。

为了保证消息在发送过程中不丢失，RabbitMQ 引入了消息应答机制。

消息应答：消费者在接收到消息并且处理完该消息之后，告诉rabbitmq它已经处理了，rabbitmq可以把该消息删除了。

自动应答

消息发送后立即被认为已经传送成功，这种模式需要在高吞吐量和数据传输安全性方面做权衡，因为这种模式如果消息在接收到之前，消费者那边出现连接或者channel关闭，那么消息就丢失了，当然另一方面这种模式消费者那边可以传递过载的消息，没有对传递的消息数量进行限制，当然这样有可能使得消费者这边由于接收太多还来不及处理的消息，导致这些消息的积压，最终使得内存耗尽，最终这些消费者线程被操作系统杀死，所以这种模式仅适用在消费者可以高效并以某种速率能够处理这些消息的情况下使用。

手动应答

方法

Channel.basicAck(用于肯定确认)：RabbitMQ已经知道该消息处理成功了，可以将其丢弃了
Channel.basicNack(用于否定确认)：不处理该消息了，直接拒绝，可以将其丢弃了。
Channel.basicReject(用于否定确认)：相比Channel.basicNack少了一个multiple参数，不处理该消息了，直接拒绝，可以将其丢弃了。

Multiple

手动应答的好处是可以批量应答并且减少网络拥堵。

true:代表批量应答channel上未应答的消息，比如：channel上有5,6,7,8四条消息，当前消费的消息是8，那么此时5,6,7这些还未应答的消息都会被确认收到消息应答。

false: 只会应答当前消费的消息，5,6,7这三个消息依然不会被确认收到消息应答。

消息自动重新入队

如果消费者由于某些原因失去连接（其通道已关闭，连接已关闭或TCP连接丢失），导致消息未发送ACK确认，RabbitMQ将了解到消息未完全处理，并将对其重新排队。如果此时其它消费者可以处理，它将很快将其重新分发给另一个消息者。这样，即使某个消费者偶尔死亡，也可以确保不会丢人任何消息。

代码示例

修改消费者代码

 public static void consumer( Channel channel,String queueName)throws Exception{

        DeliverCallback deliverCallback = (consumerTag, message) ->{
            System.out.println("收到消息:"+new String(message.getBody(),"UTF-8"));

            /**
             * @param1 消息标记tag
             * @param2 false表示只应答接到的消息
             */
            //消息应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };
        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        /**
         * @param1 队列名称
         * @param2 消费成功后是否自动确认 true:自动确认 false:手动确认
         * @param3 消费者成功消费回调
         * @param4 消费者取消消费回调
         */
        //手动应答
        boolean autoAck = false;
        //消费消息
        channel.basicConsume(queueName,autoAck,deliverCallback,cancelCallback);
    }

3.持久化

上述我们已经知道了如何确保即使消费者死亡，任务也不会丢失。但是如何保障当 RabbitMQ 服务器停止，生产者发送过来的消息不丢失。当 RabbitMQ 退出或崩溃时，它会忽略队列和消息，除非你告诉它不要这样做。确保消息不会丢失需要做两件事：我们需要将队列和消息都标记为持久的。

队列持久化

队列实现持久化，需要在声明队列的时候把durable参数设置为true。代码如下：

但是需要注意的是，如果之前声明的队列不是持久化的，需要把原先队列删除，或者重新创建一个持久化的队列，不然就会报错。

这时候就算rabbitmq，该队列也依然存在。

消息持久化

消息持久化需要在生产者发送消息时，添加属性MessageProperties.PERSISTENT_TEXT_PLAIN

将消息标记为持久化并不能完全保证不会丢失消息。尽管它告诉RabbitMQ将消息保存到磁盘，但是这里依然存在当消息刚准备存储在磁盘的时候，但是还没有存储完，消息还在缓存的一个间隔点。此时并没有真正写入磁盘。持久性保证并不强，但是对于我们的简单任务队列而言，这已经绰绰有余了。如果需要更强有力的持久化策略，需使用发布确认模式。

不公平分发

默认情况下RabbitMQ分发消息采用的是轮询分发，但是在某种场景下这种策略并不是很好，比如：有两个消费者在处理任务，其中有个消费者处理任务速度非常快，而另外一个消费者处理速度却很慢，这个时候我们还是采用轮询分发的话就会产生处理速度快的消费者很长一段时间处于空闲状态，而处理慢的那个消费者一直在干活，这种分配方式在这种情况下其实是不太好的，但是RabbitMQ并不知道这种情况它依然会很公平的分发。

发生这种情况的原因是因为 RabbitMQ 只是在消息进入队列时分派消息。它不查看消费者未确认消息的数量。它只是盲目地将第 n 个消息发送给第 n 个消费者。

为了解决这个问题，我们可以在消费者端设置参数channel.basicQos(1);

 //设置不公平分发, 不设置或者设置为0都是公平分发
 channel.basicQos(1);

意思就是在消费者处理并确认之前，不要向消费者发送新的消息。把它分发给一个空闲的消费者。

预取值

我们还可以通过channel.basicQos()来设置预取值。

五、发布确认

1.发布确认原理

生产者将信道设置成confirm模式，一旦信道进入confirm模式，所有在该信道上面发布的消息都将会被指派一个唯一的ID(从1开始)，一旦消息被投递到所有匹配的队列之后，broker就会发送一个确认给生产者（包含消息的唯一ID），这就使得生产者知道消息已经正确到达目的队列了，如果消息和队列是可持久化的，那么确认消息会在将消息写入磁盘之后发出，broker回传给生产者的确认消息中delivery-tag域包含了确认消息的序列号，此外broker也可以设置basicAck的multiple域，表示这个序列号之前的所有消息都已经得到了处理。

confirm模式最大的好处在于它是异步的，一旦发布一条消息，生产者应用程序就可以在等信道返回确认的同时继续发送下一条消息，当消息最终得到确认之后，生产者应用便可以通过回调方法来处理该确认消息，如果RabbitMQ因为自身内部应用错误导致消息丢失，就会发送一条nack消息，生产者应用程序同样可以在回调方法中处理该nack消息。

2.发布确认的策略

开启发布确认方法

发布确认默认是没有开启的，如果要开启需要调用方法confirmSelect，每当你想要使用发布确认，都需要在channel上调用该方法。

修改生产者代码

        /**
         * 开启发布确认
         */
        channel.confirmSelect();

单个确认发布

这是一种简单的确认方式，它是一种同步确认发布的方式，也就是发布一个消息之后只有它被确认发布，后续的消息才能继续发布，waitForConfirmsOrDie(Long) 这个方法只有在消息被确认的时候才返回，如果在指定时间范围内这个消息没有被确认那么它将抛出异常。

这种确认方式有一个最大的缺点就是：发布速度特别慢，因为如果没有确认发布的消息就会阻塞所有后续消息的发布，这种方式最多提供每秒不超过数百条发布消息的吞吐量。当然对于某些应用程序来说这可能已经足够了。

代码如下

package com.zjb.confirm;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.MessageProperties;
import com.zjb.utils.MqUtil;

public class ConfirmProducer {

    public static final String QUEUE_NAME = "hello";

    public static final int MESSAGE_COUNT = 100;
    
    public static void main(String[] args) throws Exception {

        publishMessageByConfirmOne();

    }

    /**
     * 单个确认
     * @throws Exception
     */
    public static void publishMessageByConfirmOne() throws Exception {
        Channel channel = MqUtil.getChannel();

        channel.queueDeclare(QUEUE_NAME,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();

        long begin = System.currentTimeMillis();
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = i + "";
            channel.basicPublish("",QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
            //发送一个消息就进行确认一次
            boolean flag = channel.waitForConfirms();
            if(flag){
                System.out.println("消息发送成功");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("发送"+MESSAGE_COUNT+"条消息，单个确认模式耗费时长:"+(end - begin));
    }


}

结果如下

批量确认发布

与单个等待确认消息相比，先发布一批消息然后在一起确认可以极大的提高吞吐量，当然这种方式的缺点就是：当发生故障导致发布出现问题时，不知道是哪个消息出现问题了，我们必须将整个批处理保存在内存中，以记录重要的信息而后重新发布消息。当然这种方案仍然是同步的，也一样阻塞消息的发布。

代码如下

package com.zjb.confirm;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.MessageProperties;
import com.zjb.utils.MqUtil;

public class ConfirmProducer {

    public static final String QUEUE_NAME = "hello";

    public static final int MESSAGE_COUNT = 100;
    
    public static void main(String[] args) throws Exception {

        
        publishMessageByBatchConfirm();
    }


    /**
     * 批量确认
     * @throws Exception
     */
    public static void publishMessageByBatchConfirm() throws Exception {
        Channel channel = MqUtil.getChannel();

        channel.queueDeclare(QUEUE_NAME,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();

        long begin = System.currentTimeMillis();
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = i + "";
            channel.basicPublish("",QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
        }
        //发送一个消息就进行确认一次
        boolean flag = channel.waitForConfirms();
        if(flag){
            System.out.println("消息发送成功");
        }
        long end = System.currentTimeMillis();
        System.out.println("发送"+MESSAGE_COUNT+"条消息，批量确认模式耗费时长:"+(end - begin));
    }

}

结果如下

异步确认发布

异步确认虽然编程逻辑上比上边两种要复杂，但是性价比要高，无论是可靠性还是效率都很好，它是利用回调函数来达到消息可靠性传递的，这个中间件也是通过函数回调来保证是否投递成功，下面就让我们来详细讲解异步确认是怎么实现的。

代码如下

package com.zjb.confirm;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmCallback;
import com.rabbitmq.client.MessageProperties;
import com.zjb.utils.MqUtil;

public class ConfirmProducer {

    public static final String QUEUE_NAME = "hello";

    public static final int MESSAGE_COUNT = 100;
    
    public static void main(String[] args) throws Exception {

        publishMessageByAsyncConfirm();
    }

    /**
     * 异步确认
     * @throws Exception
     */
    public static void publishMessageByAsyncConfirm() throws Exception {
        Channel channel = MqUtil.getChannel();

        channel.queueDeclare(QUEUE_NAME,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();
        long begin = System.currentTimeMillis();

        //消息确认成功 回调函数
        ConfirmCallback ackCallback = ( deliveryTag,  multiple) -> {
            System.out.println("确认的消息:"+deliveryTag);
        };
        //消息确认失败 回调函数
        ConfirmCallback nackCallback = ( deliveryTag,  multiple) -> {
            System.out.println("未确认的消息:"+deliveryTag);
        };
        /**
         * @param1 消息确认成功 回调函数
         * @param2 消息确认失败 回调函数
         */
        //准备确认监听器
        channel.addConfirmListener(ackCallback,nackCallback);

        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = i + "";
            channel.basicPublish("",QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
        }

        long end = System.currentTimeMillis();
        System.out.println("发送"+MESSAGE_COUNT+"条消息，异步确认模式耗费时长:"+(end - begin));
    }

}

结果如下

如何处理异步未确认消息

最好的解决方案就是把未确认的消息放到一个基于内存的能被发布线程访问的队列，比如说用ConcurrentLinkedQueue这个队列在confirm callbacks与发布线程之间进行消息的传递。

代码如下

/**
     * 异步确认
     * @throws Exception
     */
    public static void publishMessageByAsyncConfirm() throws Exception {
        Channel channel = MqUtil.getChannel();

        channel.queueDeclare(QUEUE_NAME,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();

        /**
         * 线程安全有序的一个哈希表，适用于高并发的情况下
         * 1.将序号与消息进行关联
         * 2.批量删除
         * 3.支持高并发（多线程）
         */
        ConcurrentSkipListMap<Long,String> map = new ConcurrentSkipListMap<>();

        long begin = System.currentTimeMillis();

        //消息确认成功 回调函数
        ConfirmCallback ackCallback = ( deliveryTag,  multiple) -> {
            //删除已经确认的消息
            if(multiple){
                ConcurrentNavigableMap<Long, String> confirmed = map.headMap(deliveryTag);
                confirmed.clear();
            }else{
                map.remove(deliveryTag);
            }
            System.out.println("确认的消息:"+deliveryTag);
        };
        //消息确认失败 回调函数
        ConfirmCallback nackCallback = ( deliveryTag,  multiple) -> {
            //失败业务逻辑
            System.out.println("未确认的消息:"+deliveryTag);
        };
        /**
         * @param1 消息确认成功 回调函数
         * @param2 消息确认失败 回调函数
         */
        //准备确认监听器
        channel.addConfirmListener(ackCallback,nackCallback);

        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = i + "";
            channel.basicPublish("",QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
            //记录下所有要发送的消息
            map.put(channel.getNextPublishSeqNo(),message);
        }

        long end = System.currentTimeMillis();
        System.out.println("发送"+MESSAGE_COUNT+"条消息，异步确认模式耗费时长:"+(end - begin));
    }

3种发布模式比较

单独发布确认：同步等待确认，简单，吞吐量有限，耗时高

批量发布确认：批量同步等待确认，简单，合理的吞吐量，一旦出现问题很难推断是那条消息出现了问题，耗时较高

异步发布确认：最佳性能和资源使用，再出现错误的情况下可以很好的控制，实现麻烦。

六、交换机（Exchanges）

1.Exchanges

概念

RabbitMQ消息传递模型的核心思想是：生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递到了哪些队列中。

相反，生产者只能将消息发送到交换机（exchange），交换机的工作内容非常简单，一方面它接收来自生产者的消息，另一方面将他们推入队列。交换机必须确切知道如何处理收到的消息，是应该把这些消息放到特定队列还是说把他们发送到许多队列中或者是丢弃它们，这就由交换机的类型来决定。

类型

直接（direct）
主题（topic）
标题（headers）
扇出（fanout）
无名exchange

无名exchange

在这之前我们对交换机一无所知，但仍然可以将消息发送到队列，这是因为我们之前一直使用的都是默认交换机，我们通过空字符串进行标识。

第一个参数是交换机的名称。空字符串表示默认或无名称交换机。消息能路由发送到队列中其实是由routingKey绑定key指定的。

临时队列

每当我们连接到RabbitMQ时，我们都需要一个全新的空队列，为此我们可以创建一个具有随机名称的队列，或者能让服务器为我们选择一个随机队列名称。一旦我们断开了消费者的连接，队列将被自动删除。也就是没有持久化的对列就是临时队列。

创建临时队列的方式

  String queue = channel.queueDeclare().getQueue();

绑定（bindings）

binding其实就是exchange和queue之间的桥梁，它告诉我们exchange和那个队列进行了绑定关系。

七、Fanout（发布/订阅模式）

在上边的学习中，我们创建了一个工作队列。工作队列背后的假设是每个任务都被准确地交付给一个消费者。在这一部分中，我们将做一些完全不同的事情——我们将向多个消费者传递一条消息。这种模式被称为“发布/订阅”。

为了说明这个模式，我们将构建一个简单的日志系统。它将由两个程序组成：第一个将发出日志消息，第二个是消费者。其中我们会启动两个消费者，其中一个消费者接收到消息后把日志存储到磁盘，另一个消费者接收到消息后把消息打印在屏幕上。事实上第一个程序发布的日志消息将被广播给所有的消费者。

1.介绍

fanout这种类型非常简单，正如从名称中猜到的那样，它是将接收到的所有消息广播到它知道的所有队列中。系统中默认有些exchange类型。

2.代码实战

消费者01

package com.zjb.fanout;

import com.rabbitmq.client.*;
import com.zjb.utils.MqUtil;

public class FanoutConsumer01 {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "logs";
    //定义队列名称
    public static final String QUEUE_NAME = "logQueue01";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT.getType());

        //声明队列
        channel.queueDeclare(QUEUE_NAME,true,false,false,null);

        //绑定交换机与队列
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");

        System.out.println("消费者01等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("消费者01接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(QUEUE_NAME,false,deliverCallback,cancelCallback);
    }
}

消费者02

package com.zjb.fanout;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

public class FanoutConsumer02 {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "logs";
    //定义队列名称
    public static final String QUEUE_NAME = "logQueue02";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT.getType());

        //声明队列
        channel.queueDeclare(QUEUE_NAME,true,false,false,null);

        //绑定交换机与队列
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");

        System.out.println("消费者02等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("消费者02接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(QUEUE_NAME,false,deliverCallback,cancelCallback);
    }
}

生产者

package com.zjb.fanout;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmCallback;
import com.rabbitmq.client.MessageProperties;
import com.zjb.utils.MqUtil;

import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

public class FanoutProducer {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //开启发布确认
        channel.confirmSelect();

        ConcurrentSkipListMap<Long,String> map = new ConcurrentSkipListMap<>();
        //消息发布确认成功回调函数
        ConfirmCallback ackCallback = ( deliveryTag, multiple) ->{
            if(multiple){
                ConcurrentNavigableMap<Long, String> confirmed = map.headMap(deliveryTag);
                confirmed.clear();
            }else{
                map.remove(deliveryTag);
            }
            System.out.println("消息发布确认成功:"+deliveryTag);
        };

        //消息发布确认失败回调函数
        ConfirmCallback nackCallback = ( deliveryTag, multiple) ->{
            System.out.println("消息发布确认失败:"+deliveryTag);
        };
        //准备确认监听器
        channel.addConfirmListener(ackCallback,nackCallback);

        String message ="Hello Fanout";
        //发送消息
        channel.basicPublish(EXCHANGE_NAME,"", MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
        map.put(channel.getNextPublishSeqNo(),message);

        System.out.println("发出消息:"+message);

    }
}

效果

七、Direct（路由模式）

1.介绍

在上面这张图中，我们可以看到X绑定了两个队列，绑定类型是direct。队列Q1绑定键是orange，队列Q2绑定键有两个：一个绑定键是black，一个绑定键是green.

在这种绑定情况下，生产者发布消息到exchange上，绑定键为orange的消息会被发布到队列Q1。绑定键为black、green的消息会被发布到队列Q2，其它消息类型的消息将被丢弃。

2.多重绑定

当然如果exchange的绑定类型是direct，但是它绑定的多个队列的key如果都相同，在这种情况下虽然绑定类型是direct，但是它表现的就和fanout有点类似了，就跟广播差不多，如上图所示。

3.代码实战

消费者1

package com.zjb.routing;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

public class RoutingConsumer01 {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "logs";
    //定义队列名称
    public static final String QUEUE_NAME = "logQueue01";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

        //声明队列
        channel.queueDeclare(QUEUE_NAME,true,false,false,null);

        //绑定交换机与队列
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"info");
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"warn");

        System.out.println("消费者01等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("消费者01接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(QUEUE_NAME,false,deliverCallback,cancelCallback);
    }
}

消费者2

package com.zjb.routing;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

public class RoutingConsumer02 {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "logs";
    //定义队列名称
    public static final String QUEUE_NAME = "logQueue02";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

        //声明队列
        channel.queueDeclare(QUEUE_NAME,true,false,false,null);

        //绑定交换机与队列
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"error");

        System.out.println("消费者02等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("消费者02接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(QUEUE_NAME,false,deliverCallback,cancelCallback);
    }
}

生产者

package com.zjb.routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmCallback;
import com.rabbitmq.client.MessageProperties;
import com.zjb.utils.MqUtil;

import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

public class RoutingProducer {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //开启发布确认
        channel.confirmSelect();

        ConcurrentSkipListMap<Long,String> map = new ConcurrentSkipListMap<>();
        //消息发布确认成功回调函数
        ConfirmCallback ackCallback = ( deliveryTag, multiple) ->{
            if(multiple){
                ConcurrentNavigableMap<Long, String> confirmed = map.headMap(deliveryTag);
                confirmed.clear();
            }else{
                map.remove(deliveryTag);
            }
            System.out.println("消息发布确认成功:"+deliveryTag);
        };

        //消息发布确认失败回调函数
        ConfirmCallback nackCallback = ( deliveryTag, multiple) ->{
            System.out.println("消息发布确认失败:"+deliveryTag);
        };

        //准备确认监听器
        channel.addConfirmListener(ackCallback,nackCallback);

        String message ="Hello RoutingKey Error";
        //发送消息
        channel.basicPublish(EXCHANGE_NAME,"error", MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
        map.put(channel.getNextPublishSeqNo(),message);

        System.out.println("发出消息:"+message);

    }
}

效果

八、Topics（主题模式）

之前类型的问题

尽管使用direct交换机改进了我们的系统，但是它仍然存在局限性，比如我们想接收的日志类型有info.base和info.advantage,某个队列只想info.base的消息，那这个时候direct就办不到了，这个时候就只能使用topic类型。

Topic的要求

发送到类型是topic交换机的消息的routing_key不能随意写，必须满足一定的要求，它必须是一个单词列表，以点号分隔开。这些单词可以是任意单词，比如："stock.usd.nyse"。当然这种单词列表最多不能超过255个字节。

在这个规则列表中，其中有两个替换符是大家需要注意的：

*（星号）可以代替一个单词

#（井号）可以代替零个或多个单词

Topic匹配案例

下图绑定关系如下：

Q1-->绑定的是

中间带orange带三个单词的字符串（*.orange.*）

Q2-->绑定的是

最后一个单词是rabbit的三个单词（*.*.rabbit）

第一个单词是lazy的多个单词（lazy.#）

当队列绑定关系是下列这种情况时需要引起注意：

当一个队列绑定键是#，那么这个队列将接收所有数据，就有点像fanout了，

如果队列绑定键当中没有#和*出现，那么该队列绑定类型就是direct了。

代码实战

生产者

package com.zjb.topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmCallback;
import com.rabbitmq.client.MessageProperties;
import com.zjb.utils.MqUtil;

import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

public class TopicProducer {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //开启发布确认
        channel.confirmSelect();

        ConcurrentSkipListMap<Long,String> map = new ConcurrentSkipListMap<>();
        //消息发布确认成功回调函数
        ConfirmCallback ackCallback = ( deliveryTag, multiple) ->{
            if(multiple){
                ConcurrentNavigableMap<Long, String> confirmed = map.headMap(deliveryTag);
                confirmed.clear();
            }else{
                map.remove(deliveryTag);
            }
            System.out.println("消息发布确认成功:"+deliveryTag);
        };

        //消息发布确认失败回调函数
        ConfirmCallback nackCallback = ( deliveryTag, multiple) ->{
            System.out.println("消息发布确认失败:"+deliveryTag);
        };

        //准备确认监听器
        channel.addConfirmListener(ackCallback,nackCallback);

        String message ="Hello Topic";
        //发送消息
        channel.basicPublish(EXCHANGE_NAME,"*.orange.*", MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
        map.put(channel.getNextPublishSeqNo(),message);

        System.out.println("发出消息:"+message);

    }
}

消费者1

package com.zjb.topic;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

public class TopicConsumer01 {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "topic_logs";
    //定义队列名称
    public static final String QUEUE_NAME = "Q1";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        //声明队列
        channel.queueDeclare(QUEUE_NAME,true,false,false,null);

        //绑定交换机与队列
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"*.orange.*");

        System.out.println("消费者01等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("消费者01接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(QUEUE_NAME,false,deliverCallback,cancelCallback);
    }
}

消费者2

package com.zjb.topic;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

public class TopicConsumer02 {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "topic_logs";
    //定义队列名称
    public static final String QUEUE_NAME = "Q2";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        //声明队列
        channel.queueDeclare(QUEUE_NAME,true,false,false,null);

        //绑定交换机与队列
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"*.*.rabbit");
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"lazy.#");

        System.out.println("消费者02等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("消费者02接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(QUEUE_NAME,false,deliverCallback,cancelCallback);
    }
}

九、死信队列

死信的概念

先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。

应用场景：为了保证订单业务的消息数据不丢失，需要使用到rabbitmq的死信队列机制，当消息消费发生异常时，将消息投入死信队列中，还有比如说：用户在商城下单成功并点击去支付后在指定时间未支付时自动失效。

死信的来源

消息TTL过期。TTL:消息的存活时间

队列达到最大长度（队列满了，无法再添加数据到mq中）

消息被拒绝（basic.reject或basic.nack）并且requeue = false

死信实战

代码架构图

TTL过期

生产者

package com.zjb.dead;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmCallback;
import com.rabbitmq.client.MessageProperties;
import com.zjb.utils.MqUtil;

import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

/**
 * 死信队列实战
 */
public class DeadProducer {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "normal_exchange";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //开启发布确认
        channel.confirmSelect();

        ConcurrentSkipListMap<Long,String> map = new ConcurrentSkipListMap<>();
        //消息发布确认成功回调函数
        ConfirmCallback ackCallback = ( deliveryTag, multiple) ->{
            if(multiple){
                ConcurrentNavigableMap<Long, String> confirmed = map.headMap(deliveryTag);
                confirmed.clear();
            }else{
                map.remove(deliveryTag);
            }
            System.out.println("消息发布确认成功:"+deliveryTag);
        };

        //消息发布确认失败回调函数
        ConfirmCallback nackCallback = ( deliveryTag, multiple) ->{
            System.out.println("消息发布确认失败:"+deliveryTag);
        };

        //准备确认监听器
        channel.addConfirmListener(ackCallback,nackCallback);

        String message ="Hello Dead Queue";

        //死信消息  设置TTL时间(过期时间) 单位：ms
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();

        //发送消息
        channel.basicPublish(EXCHANGE_NAME,"zhangsan", properties,message.getBytes());
        map.put(channel.getNextPublishSeqNo(),message);

        System.out.println("发出消息:"+message);

    }
}

消费者

package com.zjb.dead;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

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

/**
 * 死信队列实战: TTL过期
 * 消费者01
 */
public class Consumer01 {
    //定义交换机名称
    public static final String NORMAL_EXCHANGE = "normal_exchange";
    public static final String DEAD_EXCHANGE = "dead_exchange";
    //定义队列名称
    public static final String NORMAL_QUEUE = "normal_queue";
    public static final String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //声明普通交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        Map<String, Object> arguments = new HashMap<>();
        //设置死信交换机
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信RoutingKey
        arguments.put("x-dead-letter-routing-key","lisi");

        //声明普通队列
        channel.queueDeclare(NORMAL_QUEUE,true,false,false,arguments);
        //声明死信队列
        channel.queueDeclare(DEAD_QUEUE,true,false,false,null);

        //绑定交换机与队列
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");

        System.out.println("消费者01等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("消费者01接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(NORMAL_QUEUE,false,deliverCallback,cancelCallback);
    }
}

死信消费者

package com.zjb.dead;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

/**
 * 死信队列实战: TTL过期
 * 死信消费者
 */
public class DeadConsumer {

    public static final String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        System.out.println("死信消费者等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("死信消费者接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(DEAD_QUEUE,false,deliverCallback,cancelCallback);
    }
}

队列达到最大长度

生产者

package com.zjb.dead;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmCallback;
import com.zjb.utils.MqUtil;

import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

/**
 * 死信队列实战
 */
public class DeadProducer {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "normal_exchange";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //开启发布确认
        channel.confirmSelect();

        ConcurrentSkipListMap<Long,String> map = new ConcurrentSkipListMap<>();
        //消息发布确认成功回调函数
        ConfirmCallback ackCallback = ( deliveryTag, multiple) ->{
            if(multiple){
                ConcurrentNavigableMap<Long, String> confirmed = map.headMap(deliveryTag);
                confirmed.clear();
            }else{
                map.remove(deliveryTag);
            }
            System.out.println("消息发布确认成功:"+deliveryTag);
        };

        //消息发布确认失败回调函数
        ConfirmCallback nackCallback = ( deliveryTag, multiple) ->{
            System.out.println("消息发布确认失败:"+deliveryTag);
        };

        //准备确认监听器
        channel.addConfirmListener(ackCallback,nackCallback);

        for (int i = 0; i < 11; i++) {
            String message ="Hello Dead Queue"+i;
            //发送消息
            channel.basicPublish(EXCHANGE_NAME,"zhangsan", null,message.getBytes());
            map.put(channel.getNextPublishSeqNo(),message);
            System.out.println("发出消息:"+message);
        }


    }
}

消费者

package com.zjb.dead;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

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

/**
 * 死信队列实战: 队列达到最大长度
 * 消费者01
 */
public class Consumer01 {
    //定义交换机名称
    public static final String NORMAL_EXCHANGE = "normal_exchange";
    public static final String DEAD_EXCHANGE = "dead_exchange";
    //定义队列名称
    public static final String NORMAL_QUEUE = "normal_queue";
    public static final String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //声明普通交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        Map<String, Object> arguments = new HashMap<>();
        //设置死信交换机
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信RoutingKey
        arguments.put("x-dead-letter-routing-key","lisi");
        //设置正常队列的长度
        arguments.put("x-max-length",6);
        //声明普通队列
        channel.queueDeclare(NORMAL_QUEUE,true,false,false,arguments);
        //声明死信队列
        channel.queueDeclare(DEAD_QUEUE,true,false,false,null);

        //绑定交换机与队列
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");

        System.out.println("消费者01等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("消费者01接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(NORMAL_QUEUE,false,deliverCallback,cancelCallback);
    }
}

死信消费者

package com.zjb.dead;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

/**
 * 死信队列实战: 队列达到最大长度
 * 死信消费者
 */
public class DeadConsumer {

    public static final String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        System.out.println("死信消费者等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("死信消费者接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(DEAD_QUEUE,false,deliverCallback,cancelCallback);
    }
}

消息被拒

生产者

package com.zjb.dead;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmCallback;
import com.zjb.utils.MqUtil;

import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

/**
 * 死信队列实战
 */
public class DeadProducer {
    //定义交换机名称
    public static final String EXCHANGE_NAME = "normal_exchange";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //开启发布确认
        channel.confirmSelect();

        ConcurrentSkipListMap<Long,String> map = new ConcurrentSkipListMap<>();
        //消息发布确认成功回调函数
        ConfirmCallback ackCallback = ( deliveryTag, multiple) ->{
            if(multiple){
                ConcurrentNavigableMap<Long, String> confirmed = map.headMap(deliveryTag);
                confirmed.clear();
            }else{
                map.remove(deliveryTag);
            }
            System.out.println("消息发布确认成功:"+deliveryTag);
        };

        //消息发布确认失败回调函数
        ConfirmCallback nackCallback = ( deliveryTag, multiple) ->{
            System.out.println("消息发布确认失败:"+deliveryTag);
        };

        //准备确认监听器
        channel.addConfirmListener(ackCallback,nackCallback);

        for (int i = 0; i < 11; i++) {
            String message ="Hello Dead Queue"+i;
            //发送消息
            channel.basicPublish(EXCHANGE_NAME,"zhangsan", null,message.getBytes());
            map.put(channel.getNextPublishSeqNo(),message);
            System.out.println("发出消息:"+message);
        }


    }
}

消费者

package com.zjb.dead;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

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

/**
 * 死信队列实战: 消息被拒
 * 消费者01
 */
public class Consumer01 {
    //定义交换机名称
    public static final String NORMAL_EXCHANGE = "normal_exchange";
    public static final String DEAD_EXCHANGE = "dead_exchange";
    //定义队列名称
    public static final String NORMAL_QUEUE = "normal_queue";
    public static final String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        //声明普通交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        Map<String, Object> arguments = new HashMap<>();
        //设置死信交换机
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信RoutingKey
        arguments.put("x-dead-letter-routing-key","lisi");
        //声明普通队列
        channel.queueDeclare(NORMAL_QUEUE,true,false,false,arguments);
        //声明死信队列
        channel.queueDeclare(DEAD_QUEUE,true,false,false,null);

        //绑定交换机与队列
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");

        System.out.println("消费者01等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            String msg = new String(message.getBody(),"UTF-8");
            if(msg.equals("Hello Dead Queue5")){
                //拒绝
                System.out.println("消费者01接收到的消息:"+msg+",此消息被拒绝");
                channel.basicReject(message.getEnvelope().getDeliveryTag(),false);
            }else{
                System.out.println("消费者01接收到的消息:"+msg);
                //手动应答
                channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            }
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(NORMAL_QUEUE,false,deliverCallback,cancelCallback);
    }
}

死信消费者

package com.zjb.dead;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zjb.utils.MqUtil;

/**
 * 死信队列实战: 消息被拒
 * 死信消费者
 */
public class DeadConsumer {

    public static final String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws Exception{
        Channel channel = MqUtil.getChannel();

        System.out.println("死信消费者等待接收消息。。。");

        DeliverCallback deliverCallback = ( consumerTag,  message) ->{
            System.out.println("死信消费者接收到的消息:"+new String(message.getBody(),"UTF-8"));
            //手动应答
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费失败");
        };
        //消费消息
        channel.basicConsume(DEAD_QUEUE,false,deliverCallback,cancelCallback);
    }
}

十、延迟队列

概念

延迟队列，队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。

使用场景

1.订单在十分钟之内未支付则自动取消

2.新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒

3.用户注册成功后，如果三天内没有登录则进行短信提醒

4.用户发起退款，如果三天内没有得到处理则通知相关运营人员

5.预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议

这些场景都有一个特点，需要在某个事件发生之后或者之前的指定时间点完成某一项任务，如：发生订单生成事件，在十分钟之后检查该订单支付状态，然后将未支付的订单进行关闭，看起来似乎使用定时任务，一直轮询数据，每秒查一次，取出需要被处理的数据，然后处理不就完事了？如果数据量比较少，确实可以这样做，比如：对于"如果账单一周内未支付则自动进行结算"这样的需求，如果对于时间不是严格限制，而是宽松意义上的一周，那么每天晚上跑个定时任务检查一下所有未支付的账单，确实是一个可行的方案。但对于数据量比较大，并且时效性较强的场景，如:"订单十分钟内未支付则关闭"，短期内未支付的订单数据可能会有很多，活动期间甚至会达到百万甚至千万级别，对这么庞大的数据量仍旧使用轮询的方式显然是不可取的，很可能在一秒内无法完成所有订单的检查，同时会给数据库带来很大压力，无法满足业务要求而且性能低下。

整合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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zjb.rabbitmq</groupId>
    <artifactId>springboot-rabbitmq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-rabbitmq</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--RabbitMQ依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

配置文件

spring.rabbitmq.host= localhost
spring.rabbitmq.port= 5672
spring.rabbitmq.username= admin
spring.rabbitmq.password= 123456

基于死信队列实现延时队列

代码架构图

创建两个队列QA和QB，两个队列TTL分别设置为10s和40s，然后在创建一个交换机X和死信交换机Y，他们的类型是direct，创建一个死信队列QD，它们的绑定关系如下：

配置文件类代码

package com.zjb.rabbitmq.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

/**
 * 延时队列  配置类
 */
@Component
@Configuration
public class TtlQueueConfig {

    //普通交换机
    public static final String X_EXCHANGE = "X";

    //死信交换机
    public static final String Y_DEAD_EXCHANGE = "Y";

    //普通队列
    public static final String QUEUE_C = "QC";

    //死信队列
    public static final String DEAD_QUEUE_D = "QD";


    //声明X交换机
    @Bean("xExchange")
    public DirectExchange xExchange(){
        return new DirectExchange(X_EXCHANGE);
    }
    //声明Y交换机
    @Bean("yExchange")
    public DirectExchange yExchange(){
        return new DirectExchange(Y_DEAD_EXCHANGE);
    }

    //声明普通队列
    @Bean("queueC")
    public Queue queueC(){
        return QueueBuilder.durable(QUEUE_C).deadLetterExchange(Y_DEAD_EXCHANGE).deadLetterRoutingKey("YD").build();
    }

    //声明死信队列
    @Bean("queueD")
    public Queue queueD(){
        return QueueBuilder.durable(DEAD_QUEUE_D).build();
    }

    //队列与交换机进行绑定
    @Bean
    public Binding queueCBindingX(@Qualifier("queueC") Queue queueC,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queueC).to(xExchange).with("XC");
    }

    @Bean
    public Binding queueDBindingY(@Qualifier("queueD") Queue queueD,
                                  @Qualifier("yExchange") DirectExchange yExchange){
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }
}

生产者

package com.zjb.rabbitmq.producer;

import com.zjb.rabbitmq.config.TtlQueueConfig;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MessageProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 发送消息
     * @param message  消息
     * @param ttlTime  ttl时间
     */
    public void send(String message,String ttlTime){
        rabbitTemplate.convertAndSend(TtlQueueConfig.X_EXCHANGE,"XC",message,msg->{
            msg.getMessageProperties().setExpiration(ttlTime);
            return msg;
        });
    }

}

消费者

package com.zjb.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class MessageConsumer {

    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel){
        String msg = new String(message.getBody());
        System.out.println(msg);
    }
}

基于死信队列实现延时队列存在的问题

看起来似乎没什么问题，但是在最开始的时候，就说过如果使用在消息属性上设置ttl方式，消息可能并不会按时死亡，因为rabbitmq只会检查第一个消息是否过期，如果消息过期则丢到死信队列，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息则并不会优先得到执行。

基于插件实现延时队列

上边我们提到一个问题，如果不能实现在消息粒度上的TTL，并使其在设置的TTL时间及时死亡，就无法设计成一个通用的延时队列。那如何解决呢？接下来我们就去解决该问题。

安装延时队列插件

在官网上下载rabbitmq_deplayed_message_exchange插件，然后解压放置到RabbitMQ的插件目录下。

进入RabbitMQ的安装目录下的plugins目录，执行以下命令让该插件生效，然后重启RabbitMQ。

rabbitmq-plugins enable rabbitmq_deplayed_message_exchange

代码架构图

配置类

package com.zjb.rabbitmq.config;

import com.google.common.collect.Maps;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 延时队列  配置类
 */
@Component
@Configuration
public class DelayedQueueConfig {

    //延时交换机
    public static final String DELAYED_EXCHANGE = "delayed.exchange";

    //队列
    public static final String DELAYED_QUEUE = "delayed.queue";

    //Routing-Key
    public static final String ROUTING_KEY = "delayed.routingkey";


    //声明自定义交换机
    @Bean("delayedExchange")
    public CustomExchange delayedExchange(){
        Map<String, Object> arguments = Maps.newHashMap();
        arguments.put("x-delayed-type","direct");
        return new CustomExchange(DELAYED_EXCHANGE,"x-delayed-message",true,false,arguments);
    }

    //声明队列
    @Bean("delayedQueue")
    public Queue delayedQueue(){
        return new Queue(DELAYED_QUEUE);
    }


    //队列与交换机进行绑定
    @Bean
    public Binding queueBindingExchange(@Qualifier("delayedQueue") Queue delayedQueue,
                                  @Qualifier("delayedExchange") CustomExchange delayedExchange){
        return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(ROUTING_KEY).noargs();
    }

}

生产者

package com.zjb.rabbitmq.producer;

import com.zjb.rabbitmq.config.DelayedQueueConfig;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class DelayedProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 发送消息
     * @param message  消息
     * @param delayedTime  延迟时间
     */
    public void send(String message,Integer delayedTime){
        rabbitTemplate.convertAndSend(DelayedQueueConfig.DELAYED_EXCHANGE,DelayedQueueConfig.ROUTING_KEY,message, msg->{
            msg.getMessageProperties().setDelay(delayedTime);
            return msg;
        });
    }

}

消费者

package com.zjb.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import com.zjb.rabbitmq.config.DelayedQueueConfig;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class DelayedConsumer {

    @RabbitListener(queues = DelayedQueueConfig.DELAYED_QUEUE)
    public void receiveDelayQueue(Message message, Channel channel){
        String msg = new String(message.getBody());
        System.out.println(msg);
    }
}

总结

延时队列在需要延时处理的场景下非常有用，使用RabbitMQ来实现延时队列可以很好的利用RabbitMQ的特性，如：消息可靠发送，消息可靠传递，死信队列来保障消息至少被消费一次以及未被正确处理的消息不会被丢弃。另外，通过RabbitMQ集群的特性，可以很好的解决单点故障问题，不会因为单个节点挂掉导致延时队列不可用或消息丢失。

当然延时队列还有很多其他的选择，比如java的DelayQueue，利用redis的Zset，利用Quartz或者利用kafka的时间轮，这些方式各有特点，看需要适用的场景。

发布确认高级

在生产环境中由于某一些不明原因，导致rabbitmq重启，在rabbitmq重启期间生产者消息投递失败，导致消息丢失，需要手动处理和恢复。于是，我们开始思考，如何才能进行rabbitmq的消息可靠传递呢？特别是在这样比较极端的情况，rabbitmq集群不可用的时候，无法投递的消息该如何处理呢？

发布确认

代码架构图

配置文件

在配置文件中需要添加

spring.rabbitmq.publisher-confirm-type = correlated

none：禁用发布确认模式，是默认值
correlated：发布消息成功到交换机后会触发回调方法
simple

配置类

package com.zjb.rabbitmq.config;

import com.google.common.collect.Maps;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 发布确认高级  配置类
 */
@Component
@Configuration
public class ConfirmConfig {

    //交换机
    public static final String CONFIRM_EXCHANGE = "confirm_exchange";

    //队列
    public static final String CONFIRM_QUEUE = "confirm_queue";

    //Routing-Key
    public static final String ROUTING_KEY = "key";



    //声明交换机
    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){

        return new DirectExchange(CONFIRM_EXCHANGE);
    }

    //声明队列
    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE).build();
    }


    //队列与交换机进行绑定
    @Bean
    public Binding queueBindingExchange(@Qualifier("confirmQueue") Queue confirmQueue,
                                  @Qualifier("confirmExchange") DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(ROUTING_KEY);
    }

}

回调接口

package com.zjb.rabbitmq.callback;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.Objects;

@Component
@Slf4j
public class CustomConfirmCallback implements RabbitTemplate.ConfirmCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        //注入
        rabbitTemplate.setConfirmCallback(this);
    }

    /**
     * 交换机确认回调方法
     * 1.发送消息，交换机成功接收了进行回调
     * 2.发送消息，交换机接收失败了进行回调
     * @param correlationData 回调消息的ID和相关信息
     * @param ack 确认true或false
     * @param cause 失败的原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String id = Objects.nonNull(correlationData) ? correlationData.getId() : "";
        if(ack){
            System.out.println("交换机成功接收到了消息,消息ID"+id);
        }else{
            System.out.println("交换机接收消息失败了,消息ID"+id+",失败原因"+cause);
        }

    }
}

生产者

package com.zjb.rabbitmq.producer;

import com.zjb.rabbitmq.config.ConfirmConfig;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ConfirmProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 发送消息
     * @param message  消息
     */
    public void send(String message){
        CorrelationData correlationData = new CorrelationData();
        correlationData.setId("1");
        rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE,ConfirmConfig.ROUTING_KEY,message,correlationData);
    }

}

消费者

package com.zjb.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import com.zjb.rabbitmq.config.ConfirmConfig;
import com.zjb.rabbitmq.config.DelayedQueueConfig;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ConfirmConsumer {

    @RabbitListener(queues = ConfirmConfig.CONFIRM_QUEUE)
    public void receiveDelayQueue(Message message, Channel channel){
        String msg = new String(message.getBody());
        System.out.println(msg);
    }
}

回退消息

Mandatory参数

在仅开启了生产者发布确认机制下，交换机接收到消息后，会直接给消息生产者发送确认消息，如果发现该消息不可路由，那么该消息会被直接丢弃，此时生产者是不知道消息被丢弃这个事件的。那么如何让无法被路由的消息通知一下呢？通过Mandatory参数可以在当消息传递过程中不可达目的地时将消息返回给生产者。

配置文件

添加以下配置

spring.rabbitmq.publisher-returns = true

生产者

package com.zjb.rabbitmq.producer;

import com.zjb.rabbitmq.config.ConfirmConfig;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ConfirmProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 发送消息
     * @param message  消息
     */
    public void send(String message){
        CorrelationData correlationData = new CorrelationData();
        correlationData.setId("1");
        rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE,ConfirmConfig.ROUTING_KEY,message,correlationData);
    }
}

回调接口

package com.zjb.rabbitmq.callback;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.Objects;

@Component
@Slf4j
public class CustomConfirmCallback implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnsCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        //注入
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }

    /**
     * 交换机确认回调方法
     * 1.发送消息，交换机成功接收了进行回调
     * 2.发送消息，交换机接收失败了进行回调
     * @param correlationData 回调消息的ID和相关信息
     * @param ack 确认true或false
     * @param cause 失败的原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String id = Objects.nonNull(correlationData) ? correlationData.getId() : "";
        if(ack){
            System.out.println("交换机成功接收到了消息,消息ID"+id);
        }else{
            System.out.println("交换机接收消息失败了,消息ID"+id+",失败原因"+cause);
        }

    }


    /**
     * 当消息不可达目的地时，将消息回退给生产者
     * @param returnedMessage
     */
    @Override
    public void returnedMessage(ReturnedMessage returnedMessage) {
        String msg = new String(returnedMessage.getMessage().getBody());
        String exchange = returnedMessage.getExchange();
        String routingKey = returnedMessage.getRoutingKey();
        String replyText = returnedMessage.getReplyText();
        System.out.println("消息:"+msg+"被交换机:"+exchange+"退回，RoutingKey:"+routingKey+"退回原因："+replyText);
    }
}

消费者

package com.zjb.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import com.zjb.rabbitmq.config.ConfirmConfig;
import com.zjb.rabbitmq.config.DelayedQueueConfig;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ConfirmConsumer {

    @RabbitListener(queues = ConfirmConfig.CONFIRM_QUEUE)
    public void receiveDelayQueue(Message message, Channel channel){
        String msg = new String(message.getBody());
        System.out.println(msg);
    }
}

备份交换机

有了mandatory参数和回退消息，我们获得了对无法投递消息的感知能力。有机会在生产者的消息无法被投递时发现并处理。但有时候，我们并不知道该如何处理这些无法路由的消息，最多打个日志，然后触发报警，再来手动处理。而通过日志来处理这些无法路由的消息是很不优雅的做法，特别是当生产者所在的服务有多台机器的时候，手动复制日志会更加麻烦而且容易出错，而且设置mandatory参数会增加生产者的复杂性，需要添加处理这些被退回的消息的逻辑，如果既不想丢失消息，又不想增加生产者的复杂性，该怎么做呢？在RabbitMQ中，有一种备份交换机的机制存在，可以很好的应对这个问题。

什么是备份交换机

备份交换机可以理解为RabbitMQ中交换机的备胎，当我们为某一个交换机声明一个对应的备份交换机时，就是为它创建一个备胎，当交换机接收到一条不可路由的消息时，将会把这条消息转发到备份交换机中，由备份交换机来进行转发和处理，通常备份交换机的类型是Fanout，这样就能把所有消息都投递到与其绑定的队列中，然后我们在备份交换机下绑定一个队列，这样所有哪些原交换机无法被路由的消息，就会都进入这个队列了。当然，我们还可以建立一个报警队列，用独立的消费者来进行监测和报警。

代码架构图

配置类

package com.zjb.rabbitmq.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;


/**
 * 发布确认高级  配置类
 */
@Component
@Configuration
public class ConfirmConfig {

    //交换机
    public static final String CONFIRM_EXCHANGE = "confirm_exchange";

    //队列
    public static final String CONFIRM_QUEUE = "confirm_queue";

    //Routing-Key
    public static final String ROUTING_KEY = "key";

    //备份交换机
    public static final String BACKUP_EXCHANGE = "backup_exchange";

    //备份队列
    public static final String BACKUP_QUEUE = "backup_queue";

    //报警队列
    public static final String WARNING_QUEUE = "warning_queue";

    //声明交换机
    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){

        return ExchangeBuilder.directExchange(CONFIRM_EXCHANGE).durable(true).alternate(BACKUP_EXCHANGE).build();
    }

    //声明备份交换机
    @Bean("backupExchange")
    public FanoutExchange backupExchange(){

        return new FanoutExchange(BACKUP_EXCHANGE);
    }

    //声明队列
    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE).build();
    }

    //声明备份队列
    @Bean("backupQueue")
    public Queue backupQueue(){
        return QueueBuilder.durable(BACKUP_QUEUE).build();
    }

    //声明报警队列
    @Bean("warningQueue")
    public Queue warningQueue(){
        return QueueBuilder.durable(WARNING_QUEUE).build();
    }


    //队列与交换机进行绑定
    @Bean
    public Binding queueBindingExchange(@Qualifier("confirmQueue") Queue confirmQueue,
                                  @Qualifier("confirmExchange") DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(ROUTING_KEY);
    }

    //备份队列与备份交换机进行绑定
    @Bean
    public Binding backupQueueBindingBackupExchange(@Qualifier("backupQueue") Queue backupQueue,
                                        @Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(backupQueue).to(backupExchange);
    }

    //报警队列与备份交换机进行绑定
    @Bean
    public Binding warningQueueBindingBackupExchange(@Qualifier("warningQueue") Queue warningQueue,
                                                    @Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(warningQueue).to(backupExchange);
    }

}

生产者

package com.zjb.rabbitmq.producer;

import com.zjb.rabbitmq.config.ConfirmConfig;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ConfirmProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 发送消息
     * @param message  消息
     */
    public void send(String message){
        CorrelationData correlationData = new CorrelationData();
        correlationData.setId("1");
        rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE,ConfirmConfig.ROUTING_KEY,message,correlationData);
    }
}

消费者

package com.zjb.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import com.zjb.rabbitmq.config.ConfirmConfig;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class WarningConsumer {

    @RabbitListener(queues = ConfirmConfig.WARNING_QUEUE)
    public void receiveDelayQueue(Message message, Channel channel){
        String msg = new String(message.getBody());
        System.out.println(msg);
    }
}

mandatory参数和备份交换机同时开启时，备份交换机的优先级更高。

其它知识点

幂等性

概念

用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生副作用。

消息重复消费

消费者在消费MQ中的消息时，MQ已把消息发送给消费者，消费者在给MQ返回ack时网络中断，故MQ未收到确认消息，该条消息会重新发给其它的消费者，或者在网络重连后再次发送给该消费者，但实际上该消费者已成功消费了该条消息，造成消费者消费了重复的消息。

解决思路

MQ消费者的幂等性的解决一般使用全局ID或者写个唯一标识比如时间戳或者UUID或者订单消费者消费MQ中的消息也可以利用MQ的ID来判断，或者可按自己的规则生成一个全局唯一ID，每次消费消息时用该ID先判断该消息是否已消费过。

消费端的幂等性保障

在海量订单生成的业务高峰期，生产端有可能就会重复发送了消息，这时候消费端就要实现幂等性，这就意味着我们的消息永远不会被消费多次，即使我们收到了一样的消息。业界主流的幂等性有两种操作：

唯一ID+指纹机制，利用数据库主键去重
利用redis的原子性来实现

唯一ID+指纹机制

指纹码：我们的一些规则或者时间戳加别的服务给到的唯一信息码，它并不一定是我们系统生成的，基本都是由我们的业务规则拼接而来，但是一定要保证唯一性，然后就利用查询语句进行判断这个ID是否存在数据库中，优势就是实现简单，然后查询判断是否重复，劣势就是高并发时，如果是单个数据库就会有写入性能瓶颈当然也可以采用分库分表提升性能，但也不是我们最佳推荐的方式。

利用redis的原子性

利用redis执行setnx命令，天然具有幂等性。从而实现不重复消费。

优先级队列

使用场景

在我们系统中有一个订单催付的场景，我们的客户在天猫下的订单，淘宝会及时将订单推送给我们，如果在用户设定的时间内未付款那么就会给用户推送一条短信提醒。但是，tmall商家对我们来说，肯定是要分大客户和小客户的，比如像苹果，小米这样大商家，理所当然，他们的订单必须得到优先处理。采用rabbitmq进行改造和优化，如果发现是大客户的订单给一个相对比较高的优先级，否则就是采用默认优先级。

队列设置优先级

生产者

    Map<String, Object> arguments = new HashMap<>();
    //官方允许是0-255之间，此处设置为10，允许优先级范围为1-10，不要设置过大，浪费CPU与内存
    arguments.put("x-max-priority",10);
    channel.queueDeclare(QUEUE_NAME,false,false,false,arguments);

消息设置优先级

AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().priority(5).build();
channel.basicPublish("",QUEUE_NAME,properties,message.getBytes());

注意事项

要让队列实现优先级需要做的事情有如下事情：对列需要设置为优先级队列，消息需要设置消息的优先级，消费者需要等待消息已经发送到队列中去才去消息，因为这样才有机会对消息进行排序。

惰性队列

使用场景

惰性队列会尽可能的将消息存入磁盘中，而在消费者消费到相应的消息时才会被加载到内存中，它的一个重要的设计目标是能够支持更长的队列，即支持更多的消息存储。当消费者由于各种各样的原因（比如消费者下线、宕机亦或者是由于维护而关闭等）而致使长时间内不能消费消息造成堆积时，惰性队列就很有必要了。

默认情况下，当生产者将消息发送到RabbitMQ的时候，队列中的消息会尽可能的存储在内存之中，这样可以更加快速的将消息发送给消费者。即使是持久化的消息，在被写入磁盘的同时也会在内存中驻留一份备份。当rabbitmq需要释放内存的时候，会将内存中的消息换页至磁盘中，这个操作会耗费较长的时间，也会阻塞队列的操作，进而无法接收新的消息。

两种模式

队列具备两种模式：default和lazy。默认的为default模式。lazy模式即为惰性队列的模式，可以通过调用channel.queueDeclare方法的时候在参数中设置，也可以通过Policy的方式设置，如果一个队列同时使用这两种方式设置的话，那么Policy的方式具备更高的优先级。如果要通过声明的方式改变已有对列的模式的话，那么只能先删除队列，然后再重新声明一个新的。

在队列声明的时候可以通过"x-queue-mode"参数来设置队列的模式，取值为"default" 和 "lazy"。

Map<String, Object> arguments = new HashMap<>();
arguments.put("x-queue-mode","lazy");
channel.queueDeclare(QUEUE_NAME,false,false,false,arguments);