【RabbitMQ】多个消费者情况下的应答机制、队列信息持久化、公平转发

1、消息应答

执行一个任务需要花费一定的时间。期间会发生一些意想不到的状况，比如其中一个消费工作者服务器中断。这样我们会丢失它正在处理的信息。我们也会丢失已经转发给这个工作者且它还未执行的消息。但是，我们不希望丢失任何任务（信息）。当某个工作者（接收者）被杀死时，我们希望将任务传递给另一个工作者。
为了保证消息永远不会丢失，RabbitMQ支持消息应答（message acknowledgments）。消费者发送应答给RabbitMQ，告诉它信息已经被接收和处理，然后RabbitMQ可以自由的进行信息删除。
如果消费者被杀死而没有发送应答，RabbitMQ会认为该信息没有被完全的处理，然后将会重新转发给别的消费者。通过这种方式，你可以确认信息不会被丢失，即使消者偶尔被杀死。

这种机制并没有超时时间这么一说，RabbitMQ只有在消费者连接断开是重新转发此信息。如果消费者处理一个信息需要耗费特别特别长的时间是允许的。

可以这样设置：

 

1. boolean ack = false ; //默认是true表示的是自动应答机制被打开，我之前的demo都是默认true，现在要将自动应答关闭，在执行完任务之后手动应答
2. channel.basicConsume(QUEUE_NAME, ack, consumer);  
3. //另外需要在每次处理完成一个消息后，手动发送一次应答。  
4. channel.basicAck(envelope().getDeliveryTag(), false);  

2、信息持久化

 

我们已经学习了即使消费者被杀死，消息也不会被丢失。但是如果此时RabbitMQ服务被停止，我们的消息仍然会丢失。

当RabbitMQ退出或者异常退出，将会丢失所有的队列和信息，除非你告诉它不要丢失。我们需要做两件事来确保信息不会被丢失：我们需要给所有的队列和消息设置持久化的标志。

第一， 我们需要确认RabbitMQ永远不会丢失我们的队列。为了这样，我们需要声明它为持久化的。
boolean durable = true;
channel.queueDeclare("task_queue", durable, false, false, null);
注：RabbitMQ不允许使用不同的参数重新定义一个队列，所以已经存在的队列，我们无法修改其属性。
第二， 我们需要标识我们的信息为持久化的。通过设置MessageProperties（implements BasicProperties）值为PERSISTENT_TEXT_PLAIN。
channel.basicPublish("", "task_queue",MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
现在你可以执行一个发送消息的程序，然后关闭服务，再重新启动服务，运行消费者程序做下实验。

3、公平转发

或许会发现，目前的消息转发机制（Round-robin）并非是我们想要的。例如，这样一种情况，对于两个消费者，有一系列的任务，奇数任务特别耗时，而偶数任务却很轻松，这样造成一个消费者一直繁忙，另一个消费者却很快执行完任务后等待。
造成这样的原因是因为RabbitMQ仅仅是当消息到达队列进行转发消息。并不在乎有多少任务消费者并未传递一个应答给RabbitMQ。仅仅盲目转发所有的奇数给一个消费者，偶数给另一个消费者。
为了解决这样的问题，我们可以使用basicQos方法，传递参数为prefetchCount = 1。这样告诉RabbitMQ不要在同一时间给一个消费者超过一条消息。换句话说，只有在消费者空闲的时候会发送下一条信息。

[java] view plain copy

1. int prefetchCount = 1;  
2. channel.basicQos(prefetchCount);  

生产者：

package mq.dupli;

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

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

/**
 * @description 多个消费者下的新的生产者
 * @author: gaobh
 * @date: 2018/4/25 10:13
 * @version: v1.0
 */
public class DupliMqProviderDemo {
    private final static String QUEUE_NAME = "workQueue";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        for (int i = 10; i > 0; i--) {
            String dots = "";
            for (int j = 0; j <= i; j++) {
                dots += ".";
            }
            String message = "helloWorld" + dots + dots.length();
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println("[x] Sent '" + message + "'");
        }
        channel.close();
        connection.close();
    }
}

 

 

 

消费者1：

package mq.dupli;

import com.rabbitmq.client.*;

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

/**
 * @description 多个消费者情况下的消费者1
 * @author: gaobh
 * @date: 2018/4/25 10:21
 * @version: v1.0
 */
@SuppressWarnings("ALL")
public class DupliMqConsumer1Demo {
    private final static String QUEUE_NAME = "workQueue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //区分不同工作进程的输出
        final int hashCode = DupliMqConsumer1Demo.class.hashCode();
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        System.out.println(hashCode + "[*] Waiting for message.To exit press CTRL+C");
        //设置最大服务转发消息数量
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(hashCode + " [x] Received '" + message + "'");
                try {
                    for (char ch : message.toCharArray()) {
                        if (ch == '.') {
                            Thread.sleep(1000);
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //另外需要在每次处理完成一个消息后，手动发一次应答。
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
                System.out.println(hashCode + " [x] Done");
            }
        };
        //打开消息应答机制，以防其中一个消费者突然宕机时，出现消息丢失问题
        //此处ack=false 理解为关闭通道的自动应答，改为消费完数据之后手动应答，防止数据丢失后，无应答
        boolean ack = false;
        channel.basicConsume(QUEUE_NAME, ack, consumer);


    }
}

 

 

消费者2：

 

 

package mq.dupli;

import com.rabbitmq.client.*;

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

/**
 * @description
 * @author: gaobh
 * @date: 2018/4/25 10:41
 * @version: v1.0
 */
@SuppressWarnings("ALL")
public class DupliMqConsumer2Demo {
    private final static String QUEUE_NAME = "workQueue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //区分不同工作进程的输出
        final int hashCode = DupliMqConsumer1Demo.class.hashCode();
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        System.out.println(hashCode + "[*] Waiting for message.To exit press CTRL+C");
        //设置最大服务转发消息数量
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(hashCode + " [x] Received '" + message + "'");
                try {
                    for (char ch : message.toCharArray()) {
                        if (ch == '.') {
                            Thread.sleep(1000);
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //另外需要在每次处理完成一个消息后，手动发一次应答。
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
                System.out.println(hashCode + " [x] Done");
            }
        };
        boolean ack = false;
        channel.basicConsume(QUEUE_NAME, ack, consumer);
    }
}