【RabbitMQ】消息确认机制的“事务机制”和“confirm模式”<2>

前面说到的AMQP协议自身实现的事务机制会降低消息的吞吐量，发送消息时需要的请求的次数太多，对此，Comfirm模式提出解决方案。

Confirm模式

生产者端confirm模式的实现原理

• 生产者将信道channel设成confirm模式，一旦信道channel进入confirm模式，所有在该channel发布的消息都会指派一个唯一的ID（标识这条channel的ID），一旦消息被投递到所匹配的队列queue之后，broker就会发送一个携带该消息ID的确认消息回执给生产者。
• 如果消息和队列是可持久化（durable=true）的，那么确认消息会将消息写到磁盘之后发出，broker回执给生产者的确认消息中deliver-tag域包含了确认消息的序列号，此外broker也可以设置basic.ack的multiple域，表示到这个序列号之前的所有消息都已经得到了处理。
  这个Confirm模式最大的好处就是异步。
• 如果RabbitMQ发生异常，造成数据丢失，那么Confirm就会发一条Nack消息，生产者在回调方法处理这个Nack消息。

开启confirm模式

channel.chonfirmSelect()
编程模式：
1.普通 发一条：waitForConfirms( )
2.批量的发一批：waitForConfirms( )
3.异步confirm模式：提供一个回调方法

实现代码

普通模式（单条）

P生产者

Send.class

package com.springrabbitmq.comfirm;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.springrabbitmq.util.RabbitMQConnectionUtil;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @Title:普通模式
 * @author: fly
 * @date: 2020-3-11
 */
public class Send1 {

    private static final String QUEUE_NAME="test_queue_confirm1";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = RabbitMQConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //开启confirm模式
        //注意已经定义队列为AMQP的事务机制的话，就不能再改成confirm
        channel.confirmSelect();

        String msg="Hello Confirm Message!!";
        channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());

        //确认消息
        if (!channel.waitForConfirms()){
            System.out.println("Message Send Failed!");
        }else {
            System.out.println("Message Send Success!!");
        }
        channel.close();
        connection.close();
    }
}

C消费者

ConfirmRecv.class

package com.springrabbitmq.comfirm;
import com.rabbitmq.client.*;
import com.springrabbitmq.util.RabbitMQConnectionUtil;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @Title:普通模式
 * @author: fly
 * @date: 2020-3-11
 */
public class ConfirmRev1 {

    private static final String QUEUE_NAME="test_queue_confirm1";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = RabbitMQConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //自动确认true
        channel.basicConsume(QUEUE_NAME,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("Confirm "+new String(body,"UTF-8"));
            }
        });
     }
}

运行结果

发送成功

消费成功

批量模式（批量）

一旦出现异常，这一批消息就会丢失

P生产者

Send2.class

package com.springrabbitmq.comfirm;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.springrabbitmq.util.RabbitMQConnectionUtil;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @Title:批量模式
 * @author: fly
 * @date: 2020-3-11
 */
public class Send2 {

    private static final String QUEUE_NAME="test_queue_confirm1";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = RabbitMQConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //开启confirm模式
        //注意已经定义队列为AMQP的事务机制的话，就不能再改成confirm
        channel.confirmSelect();

        String msg="Hello Confirm Message!![批量]";
        //这就是批量
        for (int i=0;i<10;i++) {
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        }
        //确认
        if (!channel.waitForConfirms()){
            System.out.println("Message Send Failed!");
        }else {
            System.out.println("[批量]Message Send Success!!");
        }
        channel.close();
        connection.close();
    }
}

C消费者

与普通模式前面一致

运行结果

改完后直接启动Send2


这里同一条队列Queue关了channel后，重新再启动Send2，也能发送。

异步模式

• Channel对象提供的ConfirmListener()回调方法只包含deliverTag（当前Channel发出的消息序号），我们需要自己为每一个Channel维护一个unconfirm的消息序号集合，每basicPublish一条数据，集合元素+1，每回调一次handleAck方法，unconfirm集合删掉相应的一条（multiple=false）或多条（multiple=true）记录。从程序运行效率上看，这个unconfirm集合最好采用有序集合SortedSet存储结构

生产者

package com.springrabbitmq.comfirm;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmListener;
import com.rabbitmq.client.Connection;
import com.springrabbitmq.util.RabbitMQConnectionUtil;

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

/**
 * @Title:异步模式
 * @author: fly
 * @date: 2020-3-11
 */
public class Send3 {

    private static final String QUEUE_NAME="test_queue_confirm1";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = RabbitMQConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //开启confirm模式
        //注意已经定义队列为AMQP的事务机制的话，就不能再改成confirm
        channel.confirmSelect();

        //未确认的消息标识
        final SortedSet<Long> confirmSet = Collections.synchronizedSortedSet(new TreeSet<Long>());

        //Confirm监听
        channel.addConfirmListener(new ConfirmListener() {
            //没有问题的handleAck，从unconfirmed集合里移除元素表示确认收到了
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                if (multiple){
                    System.out.println("------handleAck----multiple------");
                    //multiple为true时，移除（deliveryTag+1）之前的多个元素
                    confirmSet.headSet(deliveryTag+1).clear();
                }else {
                    System.out.println("------handleAck----multiple------false");
                    //multiple为false时，移除一个
                    confirmSet.remove(deliveryTag);
                }
            }

            //RabbitMQ异常时没有收到消息，confirm会回执一条Nack给生产者
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                if (multiple){
                    System.out.println("------handleNack----multiple------");
                    //multiple为true时，移除（deliveryTag+1）之前的多个元素
                    confirmSet.headSet(deliveryTag+1).clear();
                }else {
                    System.out.println("------handleNack----multiple------false");
                    //multiple为false时，移除一个
                    confirmSet.remove(deliveryTag);
                }
            }
        });

        String msg="Hello Confirm Message!![异步]";

        for (int i=0;i<20;i++){
            //channel为每次发布的消息指派一个ID
            long seqNo = channel.getNextPublishSeqNo();
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            System.out.println("Message Send Success!"+i);
            //每次发布后将ID添加到unconfirmed未确定是否发送成功的集合Set中
            confirmSet.add(seqNo);
            System.out.println(confirmSet.size());
        }

    }
}

运行结果