RabbitMQ学习（上）——RabbitMQ介绍、安装 、Work Queues模式和发布确认

一、消息队列介绍

1.1 MQ的相关概念

什么是MQ？

• 消息队列（Message Queue，简称MQ），本质是个队列，FIFO先入先出，只不过队列中存放的内容是message而已。还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ 是一种非常常 见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了 MQ 之后，消息发送上游只需要依赖 MQ，不 用依赖其他服务

为什么要用MQ？

• 流量削峰

  一般在秒杀活动中应用广泛。秒杀活动，一般会因为流量过大，导致应用挂掉，为了解决这个问题，一般在应用前端加入消息队列。

  作用：

  1. 可以控制活动人数，超过此一定阀值的订单直接丢弃
  2. 可以缓解短时间的高流量压垮应用(应用程序按自己的最大处理能力获取订单)
     

  用户的请求，服务器收到之后，首先写入消息队列，加入消息队列长度超过最大值，则直接抛弃用户请求或跳转到错误页面。秒杀业务根据消息队列中的请求信息，再做后续处理。

• 应用解耦

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

• 异步处理

  有些服务间调用是异步的，例如 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。同样B 服务也不用 做这些操作。A 服务还能及时的得到异步处理成功的消息。
  

MQ 的分类：

• ActiveMQ

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

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

• Kafka

  大数据的杀手锏，谈到大数据领域内的消息传输，则绕不开 Kafka，这款为大数据而生的消息中间件， 以其百万级 TPS 的吞吐量名声大噪，迅速成为大数据领域的宠儿，在数据采集、传输、存储的过程中发挥 着举足轻重的作用。目前已经被 LinkedIn，Uber, Twitter, Netflix 等大公司所采纳。

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

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

• RocketMQ

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

  优点：单机吞吐量十万级,可用性非常高，分布式架构，消息可以做到 0 丢失,MQ 功能较为完善，还是分 布式的，扩展性好,支持 10 亿级别的消息堆积，不会因为堆积导致性能下降,源码是 java 我们可以自己阅 读源码，定制自己公司的 MQ

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

• RabbitMQ

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

  优点：由于 erlang 语言的高并发特性，性能较好；吞吐量到万级，MQ 功能比较完备,健壮、稳定、易 用、跨平台、支持多种语言 如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP 等，支持 AJAX 文档齐全；开源提供的管理界面非常棒，用起来很好用,社区活跃度高；更新频率相当高

  缺点：商业版需要收费,学习成本较高

1.2 RabbitMQ

MQ 全称为 Message Queue，是一种分布式应用程序的的通信方法，是消费者-生产者模型的典型的代表，producer 往消息队列中不断写入消息，而另一端 consumer 则可以读取或者订阅队列中的消息，这点可以与数据结构中队列的作用相类似，具有 FIFO 的特点。

RabbitMQ 是 MQ 产品的典型实现,是基于 AMQP 协议可复用的企业消息系统。业务上，可以实现服务提供者和消费者之间的数据解耦，提供高可用性的消息传输机制，在实际生产中应用相当广泛。

RabbitMQ的基本概念：

• Message：消息，包含消息头（即附属的配置信息）和消息体（即消息的实体内容）消息，消息体是不透明的，消息体是由一些可选属性组成的，包括路由键(routing-key)、优先级(priority)、持久性存储(delivery-mode)等。

  • Exchange(交换机)就是通过路由键来将消息路由到哪个消息队列中;

• Publisher：消息生产者，向交换机发布消息的客户端程序，我们可以简单理解为就是一个 Java 程序。

• Exchange：交换机，用来接收生产者发送的消息并将这些消息路由给服务器中的消息队列。

  常见的三种交换器类型：
  direct：发布与订阅，完全匹配 。我们可以简单理解为一对一的关系，一个交换器将消息发送给一个队列，是完全匹配的
  fanout：广播，所有订阅该广播的队列都可以收到该消息。广播式交换器，不管消息的 ROUTING_KEY 设置为什么，Exchange 都会将消息转发给所有绑定的 Queue
  topic：主题，规则匹配 。

• Queue：消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。

• Binding：绑定，用于给 Exchange(交换机) 和 Queue(消息队列) 建立关系，把 exchange 和 queue 按照路由规则绑定起来, 可以是多对多的关系。

• Connection：网络连接

• Channel：信道，MQ(消息队列)与外部打交道都是通过Channel来的，发布消息、订阅队列还是接收消息，这些动作都是通过Channel完成；简单来说就是消息通过Channel塞进队列或者流出队列。在客户端的每个连接里,可建立多个channel。因为对于操作系统来说建立和销毁 TCP 都是非常昂贵的开销，所以引入了信道的概念，以复用一条 TCP 连接。

• Consumer：消费者，从消息队列中获取消息的客户端应用程序。

• Virtual Host：虚拟主机，表示一批交换器、消息队列和相关对象。 虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器，拥有自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础，必须在连接时指定，RabbitMQ 默认的 vhost 是/。一个 broker 里可以有多个 vhost，用作不同用户的权限分离。

• Broker：消息队列服务器实体，它提供一种传输服务，它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输。可以理解为在 Linux 上创建的虚拟机实体

通信过程：

1. 生产者(Publisher)生产消息, 消息通过Channel(信道)发送给Broker(服务器主体), Broker再分配给一个Exchange(交换机)
2. Exchange收到消息后, 通过消息中的ROUTEKEY(路由键), 将消息转发给匹配的Queue(消息队列)
3. Queue收到消息后, 将消息通过Channel发送给消费者(Consumer)
4. Consumer收到消息后, 发送ACK(确认标志)给消息队列确认收到消息
5. Queue收到ACK, 删除该消息队列中缓存的此条消息.

RabbitMQ支持的消息模型：

1.3 RabbitMQ安装（Linux）

下载官网：https://www.rabbitmq.com/download.html
参考博客：RabbitMQ超详细安装教程（Linux）

注意：
RabbitMQ是采用 Erlang语言开发的，所以系统环境必须提供 Erlang环境，需要是安装 Erlang
在RabiitMQ安装过程中需要依赖socat插件，首先安装该插件

1. 把这三个文件上传到centos7中，执行下面三个命令

   rpm -ivh erlang-21.3-1.el7.x86_64.rpm # 安装 Erlang
   yum install socat -y # 安装socat插件
   rpm -ivh rabbitmq-server-3.8.8-1.el7.noarch.rpm # 安装rabbitmq
   

   
   

2. 启动：

   # 启动服务
   systemctl start rabbitmq-server
   # 查看服务状态
   systemctl status rabbitmq-server
   # 开机自启动
   systemctl enable rabbitmq-server
   # 停止服务
   systemctl stop rabbitmq-server
   # 重启服务
   systemctl restart rabbitmq-server
   

3. 开启 web 管理插件

   默认情况下，是没有安装web端的客户端插件，需要安装才可以生效

   rabbitmq-plugins enable rabbitmq_management
   

   安装完毕以后，重启服务即可

   systemctl restart rabbitmq-server
   

   
   访问 http://192.168.2.4:15672 ，用默认账号密码(guest)登录，出现权限问题。默认情况只能在 localhost 本机下访问，所以需要添加一个远程登录的用户
   

4. 添加用户

   # 创建账号和密码
   rabbitmqctl add_user 用户名 密码 # 创建一个用户名为admin，密码为123的用户
   
   # 设置用户角色
   rabbitmqctl set_user_tags 用户名 角色
   
   # 为用户添加资源权限
   # rabbitmqctl set_permissions [-p <vhostpath>] <user> <conf> <write> <read>
   rabbitmqctl set_permissions -p "/" admin ".*" ".*" ".*"  # 给admin用户添加配置、写、读权限
   
   # 修改密码
   rabbitmqctl change_ password 用户名 新密码
   
   # 删除用户
   rabbitmqctl delete_user 用户名
   
   # 查看用户清单
   rabbitmqctl list_users
   

   角色有四种：

   1. administrator：可以登录控制台、查看所有信息、可以对 rabbitmq 进行管理
   2. monitoring：监控者；登录控制台，查看所有信息
   3. policymaker：策略制定者；登录控制台指定策略
   4. managment：普通管理员；登录控制
   
   

   这里创建用户admin，密码123，设置adminstator角色，赋予所有权限
   
   创建完成后，访问服务器公网ip:15672进行登录，然后便可进入到后台

   

二 、Hello World

实现：模拟生产者发送消息，消费者接收到消息并打印

1. 添加依赖

   pom.xml

   <dependencies>
       <!--rabbitmq 依赖客户端-->
       <dependency>
           <groupId>com.rabbitmq</groupId>
           <artifactId>amqp-client</artifactId>
           <version>5.8.0</version>
       </dependency>
       <!--操作文件流的一个依赖-->
       <dependency>
           <groupId>commons-io</groupId>
           <artifactId>commons-io</artifactId>
           <version>2.6</version>
       </dependency>
   </dependencies>
   

2. 生产者发送消息

   public class Producer {
       //队列名称
       public static final String QUEUE_NAME = "hello";
   
       //发消息
       public static void main(String[] args) throws Exception {
           //创建一个连接工厂
           ConnectionFactory factory = new ConnectionFactory();
           //工厂IP，链接RabbitMQ的队列
           factory.setHost("192.168.2.4");
           //用户名
           factory.setUsername("admin");
           //密码
           factory.setPassword("123");
           //创建链接
           Connection connection = factory.newConnection();
           //获取信道
           Channel channel = connection.createChannel();
           /**
            * 生成一个队列
            * 1.队列名称
            * 2.队列里面的消息是否持久化 默认false消息存储在内存中
            * 3.exclusive： 是否排外的
            * 当exclusive = true则设置队列为排他的。如果一个队列被声明为排他队列，该队列 仅对首次声明它的连接（Connection）可见，是该Connection私有的，类似于加锁，并在连接断开connection.close()时自动删除 ；
            * 当exclusive = false则设置队列为非排他的，此时不同连接（Connection）的管道Channel可以使用该队列 ；
            * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除, true:自动删除
            * 5.其他参数
            */
           channel.queueDeclare(QUEUE_NAME,false,false,false,null);
           //发消息
           String message="hello world";
           /**
            * 发送一个消息
            * 1.发送到那个交换机
            * 2.路由的key是哪个，本次是队列的名称
            * 3.其他的参数信息
            * 4.发送消息的消息体
            */
           channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
           System.out.println("hello world消息发送完毕");
       }
   }
   

3. 消费者接收消息

   获取“生产者”发出的消息

   public class Consumer {
       //队列的名称
       private final static String QUEUE_NAME = "hello";
       //接收消息
       public static void main(String[] args) throws Exception {
           //创建链接工厂
           ConnectionFactory factory = new ConnectionFactory();
           factory.setHost("192.168.2.4");
           factory.setUsername("admin");
           factory.setPassword("123");
           //建立连接
           Connection connection = factory.newConnection();
           //建立信道
           Channel channel = connection.createChannel();
           System.out.println("等待接收消息.........");
   
           //收到消息后用来处理消息的回调对象
           DeliverCallback deliverCallback = (consumerTag, delivery) -> {
               String message = new String(delivery.getBody());
               System.out.println("收到："+message);
           };
           //消费者取消消息的回调对象
           CancelCallback cancelCallback = (consumerTag) -> {
               System.out.println("消息消费被中断");
           };
           /**
            * 消费者消费消息
            * 1.消费哪个队列
            * 2.消费成功之后是否要自动应答 true:代表自动应答，false:手动应答
            * 3.消费者未成功消费的回调
            * 4.消费者取消消费的回调
            */
           channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
       }
   }
   

4. 执行结果：
   

三、工作队列（Work Queues）

Work Queues——工作队列(又称任务队列)的主要思想是避免立即执行资源密集型任务，我们把任务封装为消息并将其发送到队列。当有多个工作线程时，这些工作线程将一起处理这些任务。

即：工作队列模式为一个生产者对应多个消费者，但是只有一个消费者获得消息，即一个队列被多个消费者监听，但一条消息只能被其中的一个消费者获取。

3.1 轮询分发消息

实现效果：启动两个工作线程，一个消息发送线程，我们来看看他们两个工作线程是如何工作的。

1、抽取工具类

public class RabbitMqUtils {
    //得到一个连接的 channel
    public static Channel getChannel() throws Exception{
        //创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.2.4");
        factory.setUsername("admin");
        factory.setPassword("123");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        return channel;
    }
}

2、启动两个工作线程来接受消息

/**
 * 这是一个工作线程（相当于之前的消费者）
 */
public class Worker01 {
    //队列的名称
    private static final String QUEUE_NAME = "hello";
    //接收消息
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();

        //接收到消息的回调方法
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String receivedMessage = new String(delivery.getBody());
            System.out.println("接收到消息:" + receivedMessage);
        };
        //消息接收被取消时执行下面的内容
        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费接口回调逻辑");
        };

        System.out.println("C2 消费者启动等待消费.................. ");
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
    }
}

启动两个工作线程：

3、启动一个发送消息线程

/**
 * 生产者，发送大量的消息
 */
public class Task01 {

    //队列名称
    private static final String QUEUE_NAME="hello";
    public static void main(String[] args) throws Exception {
        Channel channel= RabbitMqUtils.getChannel();
        //队列的声明
        /**
         * 生成一个队列
         * 1.队列名称
         * 2.队列里面的消息是否持久化 默认false消息存储在内存中
         * 3.exclusive： 是否排外的
         * 当exclusive = true则设置队列为排他的。如果一个队列被声明为排他队列，该队列 仅对首次声明它的连接（Connection）可见，是该Connection私有的，类似于加锁，并在连接断开connection.close()时自动删除 ；
         * 当exclusive = false则设置队列为非排他的，此时不同连接（Connection）的管道Channel可以使用该队列 ；
         * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除, true:自动删除
         * 5.其他参数
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //从控制台当中接受信息
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            //发送消息
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
            System.out.println("发送消息完成:"+message);
        }
    }
}

4、结果展示

当发送AA ，BB ，CC ，DD消息时两个工作线程的执行情况

可以看到两个工作线程分别都获得了两个消息

3.2 Message acknowledgment（消息确认）

---

消息自动重新入队：

如果消费者挂了(如channel信道关闭，connection连接关闭、TCPconnection 连接丢失)，而没有发送 ACK消息确认，RabbitMQ就为认为该消息没有被消费者完全地消费掉，然后就把该消息重新退回到消息(任务)队列中，如果此时存在其它在线的消费者，纳闷很快将其重新分发给另一个消费者

消息确认没有超时时间限制。只有当消费者挂了(如channel信道关闭，connection连接关闭、TCPconnection 连接丢失)，消息才会被退回到消息队列，反之是不会将消息退回到消息队列。如果消费者是正常状态，哪怕该消息被消费者处理了很长很长时间，一直没给RabbitMQ发送ack确认，也是没有问题的。

---

消息确认：

为了保证消息在发送过程中不丢失，引入消息应答机制，消息应答就是：消费者在接收到消息并且处理该消息之后，告诉 rabbitmq 它已经处理了，rabbitmq 可以把该消息删除了。

3.2.1 自动确认

当开启自动确认时，即autoAck = true，RabbitMQ默认发送完消息给消费者后自动确认为消费完成并从队列queue中删除该msg, 即使消费者端的msg丢失导致任务失败，RabbitMQ也不知道它的状态，默认消费完成（会引发消息丢失问题）。

3.2.2 手动确认

即：消费者处理完业务逻辑，手动返回ack（通知）告诉队列处理完了，队列进而删除消息。

手动确认应答的方法：

• void basicAck(long deliveryTag, boolean multiple) throws IOException;(用于肯定确认)

  • deliveryTag：该消息的index
  • multiple：是否批量处理.true:将一次性ack所有小于deliveryTag的消息

• void basicNack(long deliveryTag, boolean multiple) throws IOException;(用于否定确认)

  • deliveryTag:该消息的index
  • multiple：是否批量.true:将一次性拒绝所有小于deliveryTag的消息

• void basicNack(long deliveryTag, boolean multiple, boolean requeue) throws IOException;(用于否定确认)

  • deliveryTag:该消息的index
  • multiple：是否批量.true:将一次性拒绝所有小于deliveryTag的消息
  • requeue：被拒绝的是否重新入队列 注意：如果设置为true ，则会添加在队列的末端

Multiple 的解释：

• true 代表批量应答 channel 上未应答的消息

  比如说 channel 上有传送 tag 的消息 5,6,7,8 当前 tag 是8 那么此时5-8 的这些还未应答的消息都会被确认收到消息应答

• false 同上面相比只会应答 tag=8 的消息 5,6,7 这三个消息依然不会被确认收到消息应答

---

消息手动应答代码：

• 消费者中设置手动应答的关键代码：
  

实现效果：演示消息在手动应答时不丢失，在消息丢失时，把消息放回队列中重新消费

1. 消息生产者

   public class Task2 {
       //队列名称
       public static final String TASK_QUEUE_NAME = "ack_queue";
   
       public static void main(String[] args) throws Exception {
           Channel channel = RabbitMqUtils.getChannel();
   
           /**
            * 生成一个队列
            * 1.队列名称
            * 2.队列里面的消息是否持久化 默认false消息存储在内存中
            * 3.exclusive： 是否排外的
            * 当exclusive = true则设置队列为排他的。如果一个队列被声明为排他队列，该队列 仅对首次声明它的连接（Connection）可见，是该Connection私有的，类似于加锁，并在连接断开connection.close()时自动删除 ；
            * 当exclusive = false则设置队列为非排他的，此时不同连接（Connection）的管道Channel可以使用该队列 ；
            * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除, true:自动删除
            * 5.其他参数
            */
           channel.queueDeclare(TASK_QUEUE_NAME,true,false,false,null);
           //从控制台输入信息
           Scanner scanner = new Scanner(System.in);
           while(scanner.hasNext()){
               String message = scanner.next();
               //发布消息
               channel.basicPublish("",TASK_QUEUE_NAME,null,message.getBytes(StandardCharsets.UTF_8));
               System.out.println("生产者发出消息：" + message);
           }
       }
   }
   

2. 消费者C1，应答时间为1秒

   /**
    * 消费者C1，处理消息速度比较快
    */
   public class Work03 {
   
       //队列名称
       public static final String TASK_QUEUE_NAME = "ack_queue";
   
       //接收消息
       public static void main(String[] args) throws Exception {
           Channel channel = RabbitMqUtils.getChannel();
           System.out.println("C1等待接收消息，处理速度快");
   
           DeliverCallback deliverCallback = (consumerTag, message) -> {
               //沉睡1S
               SleepUtils.sleep(1);
               System.out.println("接收到的消息：" + new String(message.getBody(),"UTF-8"));
               //手动应答
               /**
                * 1.消息标记 tag
                * 2.是否批量应答未应答消息,false:不批量应答信道中的消息；true:批量应答信道中的消息
                */
               channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
           };
           
           //采用手动应答
           boolean autoAck = false;
           channel.basicConsume(TASK_QUEUE_NAME,autoAck,deliverCallback,(consumerTag) -> {
               System.out.println(consumerTag + "消费者取消消息接口回调逻辑");
           });
   
       }
   }
   

3. 消费者C2，把应答时间改为30秒

   /**
    * 消费者C1，处理消息速度比较慢
    */
   public class Work04 {
   
       //队列名称
       public static final String TASK_QUEUE_NAME = "ack_queue";
   
       //接收消息
       public static void main(String[] args) throws Exception {
           Channel channel = RabbitMqUtils.getChannel();
           System.out.println("C2等待接收消息，处理速度慢");
   
           DeliverCallback deliverCallback = (consumerTag, message) -> {
               //设置沉睡30S，=====================
               SleepUtils.sleep(30);
               System.out.println("接收到的消息：" + new String(message.getBody(),"UTF-8"));
               //手动应答
               /**
                * 1.消息标记 tag
                * 2.是否批量应答未应答消息,false:不批量应答信道中的消息；true:批量应答信道中的消息
                */
               channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
           };
   
           //采用手动应答
           boolean autoAck = false;
           channel.basicConsume(TASK_QUEUE_NAME,autoAck,deliverCallback,(consumerTag) -> {
               System.out.println(consumerTag + "消费者取消消息接口回调逻辑");
           });
       }
   }
   

4. 效果展示

   在发送者发送消息 dd，发出消息之后的把 C2 消费者停掉，按理说该 C2 来处理该消息，但是由于它处理时间较长，在还未处理完，也就是说 C2 还没有执行 ack 代码的时候，C2 被停掉了， 此时会看到消息被 C1 接收到了，说明消息 dd 被重新入队，然后分配给能处理消息的 C1 处理了

   

3.3 RabbitMQ持久化

当 RabbitMQ 服务停掉以后，消息生产者发送过来的消息不丢失要如何保障？默认情况下 RabbitMQ 退出或由于某种原因崩溃时，它忽视队列和消息，除非告知它不要这样做。确保消息不会丢失需要做两件事：我们需要将队列和消息都标记为持久化。

3.3.1 队列的持久化

之前我们创建的队列都是非持久化的，rabbitmq 如果重启的话，该队列就会被删除掉，如果要队列实现持久化需要在声明队列的时候把 durable 参数设置为持久化

//让队列持久化
boolean durable = true;
//声明队列
channel.queueDeclare(TASK_QUEUE_NAME, durable, false, false, null);

web界面持久化与非持久化队列的区别：

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

3.3.2 消息持久化

需要在消息生产者修改代码，MessageProperties.PERSISTENT_TEXT_PLAIN 添加这个属性。

channel.basicPublish("", "task_queue",
            MessageProperties.PERSISTENT_TEXT_PLAIN,
            message.getBytes());

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

3.4 Fair dispatch（公平转发）

• 在上面例子所运行的结果中，两个消费者获得的msg的数量是相同的，但是会出现其中一个消费者比较闲，另外一个消费者比较忙的情况，从而造成了资源的不完全利用问题 。
• 为了解决这个问题，我们使用basicQos( prefetchCount = 1)方法，来限制RabbitMQ只发不超过1条的消息给同一个消费者。当消息处理完毕后，有了反馈，才会进行第二次发送 ；即：如果消费者还未将上次所给的消息进行ACK,就不要把新的消息转发给消费者，直到消费者对上次拿到的消息进行ACK。
• 注意：使用公平分发，必须关闭自动应答，改为手动应答

设置公平分发msg的代码：

//公平分发，同一时刻服务器只会发一条消息给同一个消费者
int prefetchCount = 1;
channel.basicQos(prefetchCount);
//采用手动应答
boolean autoAck = false;
channel.basicConsume(TASK_QUEUE_NAME, autoAck, deliverCallback, cancelCallback);

设置之后可以在web界面看到：

---

预取值分发：

可以设置channel.basicQos(prefetchCount);的数量来实现预取值，该值定义通道上允许的未确认消息的最大数量。一旦数量达到配置的数量，RabbitMQ 将停止在通道上传递更多消息。即：带权的消息分发

channel.basicQos(prefetchCount);

四、发布确认

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

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

开启发布确认的方法：

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

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

4.1 单个确认发布

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

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

public class ConfirmMessage {

    //批量发消息的个数
    public static int MESSAGE_COUNT = 1000;

    public static void main(String[] args) throws Exception {
        //1、单个确认
        publishMessageSingle();//发布1000个单独确认消息，耗时874秒
    }

    public static void publishMessageSingle() throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //队列的声明
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();
        //开始时间
        long begin = System.currentTimeMillis();

        //批量发消息
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = i + "";
            channel.basicPublish("",queueName,null,message.getBytes());
            //单个消息就马上进行确认
            boolean flag = channel.waitForConfirms();
            if(flag) {
                System.out.println("消息发送成功");
            }
        }
        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("发布" + MESSAGE_COUNT + "个单独确认消息，耗时" + (end-begin) + "秒");
    }
}

执行结果：

4.2 批量确认发布

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

代码示例：

public class ConfirmMessage {

    //批量发消息的个数
    public static int MESSAGE_COUNT = 1000;

    public static void main(String[] args) throws Exception {
        //2、批量确认
        publishMessageBatch();//发布1000个批量确认消息，耗时154秒
    }

    //批量发布确认
    public static void publishMessageBatch() throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //队列的声明
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();
        //开始时间
        long begin = System.currentTimeMillis();

        //批量确认消息大小
        int batchSize = 100;
        //批量发消息，批量发布确认
        for (int i = 1; i <= MESSAGE_COUNT; i++) {
            String message = i + "";
            channel.basicPublish("",queueName,null,message.getBytes());

            //判断达到100条消息的时候，批量确认一次
            if(i % batchSize == 0){
                boolean flag = channel.waitForConfirms();
                if(flag) {
                    System.out.println("消息发送成功");
                }
            }
        }

        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("发布" + MESSAGE_COUNT + "个批量确认消息，耗时" + (end-begin) + "秒");

    }
}

执行结果：

4.3 异步确认发布

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

如何处理异步未确认消息？

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

public class ConfirmMessage {

    //批量发消息的个数
    public static int MESSAGE_COUNT = 1000;

    public static void main(String[] args) throws Exception {
        //3、异步批量确认
        publishMessageAsync();//发布1000个异步确认消息，耗时33秒
    }

    //异步发布确认
    public static void publishMessageAsync() throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //队列的声明
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();
        //开始时间
        long begin = System.currentTimeMillis();

        /**
         * 线程安全有序的一个哈希表，适用于高并发的情况下
         *  1.轻松的将序号于消息进行关联
         *  2.轻松的批量删除条目，只要给到序号
         *  3.支持高并发
         */
        ConcurrentSkipListMap<Long, String> outstandingConfirms = new ConcurrentSkipListMap<>();

        //消息确认成功回调函数
        ConfirmCallback ackCallback = (deliveryTag, multiple) -> {
            //=====2.删除掉已经确认的消息，剩下的就是未确认的消息=====
            if(multiple) {
                ConcurrentNavigableMap<Long, String> confirmd =
                        outstandingConfirms.headMap(deliveryTag);
            } else {
                outstandingConfirms.remove(deliveryTag);
            }

            System.out.println("确认的消息：" + deliveryTag);
        };
        /**
         * 消息确认失败回调函数
         *  1.消息的标识
         *  2.是否为批量确认
         */
        ConfirmCallback nackCallback = (deliveryTag, multiple) -> {
            //=====3.打印一下未确认的消息都有哪些=====
            String message = outstandingConfirms.get(deliveryTag);
            System.out.println("未确认的消息是：" + message + "未确认的消息tag：" + deliveryTag);
        };
        /**
         * 准备消息的监听器，监听哪些消息成功了，哪些消息失败了
         *  1.消息发送成功的监听对象
         *  2.消息发送失败的监听对象
         */
        channel.addConfirmListener(ackCallback,nackCallback);//异步通知

        for (int i = 1; i <= MESSAGE_COUNT; i++) {
            String message = i + "";
            channel.basicPublish("",queueName,null,message.getBytes());

            //======1.此处记录下所有要发送的消息，消息的总和=====
            outstandingConfirms.put(channel.getNextPublishSeqNo(),message);
        }

        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("发布" + MESSAGE_COUNT + "个异步确认消息，耗时" + (end-begin) + "秒");
    }
}

执行结果：

---

总结：

单独发布消息

• 同步等待确认，简单，但吞吐量非常有限。

批量发布消息

• 批量同步等待确认，简单，合理的吞吐量，一旦出现问题但很难推断出是那条消息出现了问题。

异步处理：

• 最佳性能和资源使用，在出现错误的情况下可以很好地控制，但是实现起来稍微难些

好的博客：RabbitMQ知识体系

RabbitMQ之Work Queues模式

rabbitmq专题