RabbitMQ——消费端限流和ACK重回队列

一、消费端限流

假设一个场景，首先，我们 Rabbitmq 服务器积压了有上万条未处理的消息，我们随便打开一个消费者客户端，会出现这样情况: 巨量的消息瞬间全部推送过来，但是我们单个客户端无法同时处理这么多数据!
当数据量特别大的时候，我们对生产端限流肯定是不科学的，因为有时候并发量就是特别大，有时候并发量又特别少，我们无法约束生产端，这是用户的行为。所以我们应该对消费端限流，用于保持消费端的稳定，当消息数量激增的时候很有可能造成资源耗尽，以及影响服务的性能，导致系统的卡顿甚至直接崩溃。

限流API讲解

RabbitMQ 提供了一种 qos （服务质量保证）功能，即在非自动确认消息的前提下，如果一定数目的消息（通过基于 consume 或者 channel 设置 Qos 的值）未被确认前，不进行消费新的消息。

限流API介绍

void basicQos(int prefetchSize, int prefetchCount, boolean global) throws IOException;

 参数介绍：

prefetchSize：0，单条消息大小限制，0代表不限制。

prefetchCount：一次性消费的消息数量。会告诉 RabbitMQ 不要同时给一个消费者推送多于 N 个消息，即一旦有 N 个消息还没有 ack，则该 consumer 将 block 掉，直到有消息 ack。

global：true、false 是否将上面设置应用于 channel，简单点说，就是上面限制是 channel 级别的还是 consumer 级别。当我们设置为 false 的时候生效，设置为 true 的时候没有了限流功能，因为 channel 级别尚未实现。

prefetchSize 和 global 这两项，rabbitmq 没有实现，暂且不研究。特别注意一点，prefetchCount 在 no_ask=false 的情况下才生效，即在自动应答的情况下这两个值是不生效的。

 

 

 

 

二、消费端ACK与重回队列

消费端手工ACK与NACK

消费端进行消费的时候，如果由于业务异常我们可以进行日志的记录，然后进行补偿；如果由于服务器宕机等严重问题，那么我们就需要手工进行ACK，保障消费端消费成功，比如我们在消费端调用第三方接口，但这个第三方接口出现了问题导致接口调用失败，这时我们就要使消息重回队列

消费端的重回队列

消费端重回队列是为了对没有处理成功的消息，把消息重新回递给Broker；一般我们在实际应用中，都会关闭重回队列，也就是设置为false，因为重回队列消息有很大概率依然会处理失败，比如我们在消费端写的代码有逻辑错误，这时就算重回队列也仍然是失败（会导致失败的消息一直重回队列）

示例：

生产者：

package com.bxp.rabbitmqapi.ackExchange;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;

public class Sender {
    // RabbitMq 生产者入门示例
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1、创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.40.110");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

        // 2、生产连接
        Connection connection = connectionFactory.newConnection();

        // 3、创建通信通道
        Channel channel = connection.createChannel();
        // 4、创建队列，如果队列已经存在，则不会执行任何操作，如果队列不存在，会执行创建队列的操作
        //String queueName = "test-001";
        // 参数：队列名称、是否持久化、是否独占（队列仅供此连接使用，即只能有一个消费者）、不使用时是否自动删除、其他参数
        //channel.queueDeclare("test-001", false, false, false , null);

        // 生产消息
        String exchangeName = "test-ack-exchange";
        String routeKey = "ack.save";
        // String routeKey = "test.save";
        String messagePrefix = "RabbitMq Message test00";

        for(int i = 0; i < 5; i++){
            String message = messagePrefix + i;
            // 5、创建消息的属性
            Map<String, Object> headers = new HashMap<>();
            headers.put("flag", i);
            AMQP.BasicProperties properties = new AMQP.BasicProperties().builder()
                    .deliveryMode(2)
                    .contentEncoding("UTF-8")
                    .headers(headers).build();
            // 生产者端在发送消息时，只需要关心exchange和routeKey即可
            channel.basicPublish(exchangeName, routeKey, properties, message.getBytes());
        }

    }
}

消费者：

package com.bxp.rabbitmqapi.ackExchange;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;

public class Receiver {
    // RabbitMq 消费者示例
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1、创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.40.110");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

        // 2、生产连接
        Connection connection = connectionFactory.newConnection();

        // 3、生产通信通道
        Channel channel = connection.createChannel();
        String exchangeName = "test-ack-exchange";
        String queueName = "test-ack-queue";
        String routeKey = "ack.#";
        // 4、创建队列，如果队列已经存在，则不会执行任何操作，如果队列不存在，会执行创建队列的操作
        channel.exchangeDeclare(exchangeName, "topic", true, false, false, null);
        channel.queueDeclare(queueName, false, false, false, null);
        channel.queueBind(queueName, exchangeName, routeKey);
        // 在手动ack的时候，使用消费端限流，prefetch = 2表示消费端每次从queue拉两条条消息来消费 直到有一条消息手动确认消费完毕后，才会继续拉取下一条消息
        channel.basicQos(0, 2, false);
        //创建队列消费者
        DefaultConsumer consumer = new DefaultConsumer(channel){
            // 监听接收消息的方法
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.err.println("接收消息: " + new String(body, "utf-8"));
                Map<String, Object> headers = properties.getHeaders();
                // 这里模拟消息头中flag为0时，返回NAck;
                Integer flag = (Integer)headers.get("flag");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(flag == null || flag.equals(0)){
                    System.out.println("nack");
                    // 第二个参数：是否批量操作；第三个参数：是否重回队列，实际使用都是false
                    channel.basicNack(envelope.getDeliveryTag(), false, false);
                } else {
                    System.out.println("ack");
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        };
        // 参数介绍：队列名称、是否自动Ack、消费者
        channel.basicConsume(queueName, false, consumer);
    }
}