RabbitMQ高级特性

1. 消息确认

1.1 消息确认机制

生产者发送消息之后，到达消费端之后，可能会有以下情况：

消息处理成功
消息处理异常

RabbitMQ向消费者发送消息之后，就会把这条消息删掉，那么第二种情况，就会造成消息丢失，那么如何确保消费端已经成功接收了，并且正确处理了

为了保证消息从队列可靠到达消费者，RabbitMQ提供了消息确认机制

消费者在订阅队列时，可以指定autoAck参数，根据这个参数设置，消息机制分为以下两种：

自动确认：当 auotAck 等于 true时，会自动把发送出去的消息置为确认，然后从内存（或磁盘）删除，而不管消费者是否真正消费了这些消息，自动确认模式适合随遇消息可靠性要求不高的场景
手动确认：当 autoAck 等于 false 时，RabbitMQ会等待消费者显式地调用 Basic Ack 命令，回复确认信号后才从内存（或磁盘）中一区消息，这种模式适合对消息可靠性要求比较高的场景

java 复制代码

String basicConsume(String queue, boolean autoAck, Consumer callback) throws 
IOException;

当autoAck参数置为false，对于RabbitMQ服务端而言，队列中的消息分成了两部分：

一是等待投递给消费者的消息

二是已经投递给消费者，但是还没有收到消费者确认信号的消息

如果RabbitMQ一直没有收到消费者的确认信号，并且消费此消息的消费者已经断开了连接，则RabbitMQ会安排该消息重新进入队列，等待投递给下一个消费者，当然也有可能是原来那个消费者

1.2 手动确认方法

消费者在收到消息之后，可以选择确认，也可以选择直接拒绝或者跳过，RabbitMQ也提供了不同的确认应答方法，消费者客户端可以调用与其对应的channel的相关方法

1）肯定确认

Channel。basicAck（long delivertTag，boolean multiple）

RabbitMQ已经知道该消息发送成功并且被成功消费了，可以将其丢弃了

参数说明：

deliveryTag：消息的唯一表示，它是一个单调递增的64位的长整型值，是每个通道独立维护的，所以在每个通道上都是唯一的，当消费者确认一条消息时，必须使用对应的通道来确认
multiple：是否批量确认，在某些情况下，为了减少网络流量，可以对一系列连续的deliveryTag进行确认，值为true则会一次性ack所有小于或等于deliveryTag的消息，值为false则值确认当前指定deliveryTag的消息

2）否定确认

Channel.basicReject（long deliveryTag，boolean requeue）

消费者客户端可以调用方法来告诉RabbitMQ拒绝这个消息

参数说明：

deliveryTag
requeue：表示拒接后，这条消息如何处理，如果requeue参数设置为true，会重新将这条消息存入队列，以便可以发送给下一个订阅的消费者，如果设置为false，会把消息从队列中移除

3）否定确认

Channel。basicNack（long deliveryTag，boolean multiple，boolean requeue）

可以批量拒绝消息

multiple参数设置为true则表示拒绝deliveryTag之前所有未被当前消费者确认的消息

1.3 代码示例

spring-AMQP 对消息确认机制提供了三种策略

java 复制代码

public enum AcknowledgeMode {
   NONE,
   MANUAL,
   AUTO;
}

1）AcknowledgeMode.NONE

消息一旦递给消费者，不管消费者是否成功处理了消息，RabbitMQ都会自动确认消息，从队列中移除消息，如果消费者处理消息失败，消息可能会丢失

2）AcknowledgeMode.AUTO(默认)

消费者在消息处理成功时会自动确认消息，但如果过程中抛出了异常，则不会确认

3）AcknowledgeMode.MANUAL

手动确认模式下，消费者必须在成功处理消息后显式调用 basicAck方法来确认消息，如果消息未被确认，RabbitMQ会认为消息尚未被成功处理，并且会在消费者可用时重新投递该消息，这种模式提高了消息处理的可靠性，因为即使消费者处理消息后失败，消息也不会丢失，而是可以被重新处理

配置是none时，消息会丢失

配置是auto时，控制台会不断输出错误信息

配置为 manual时，要手动签收

java 复制代码

@Component
public class AckQueueListener {
   //指定监听队列的名称
    @RabbitListener(queues = Constant.ACK_QUEUE)
   public void ListenerQueue(Message message, Channel channel) throws Exception {
      long deliveryTag = message.getMessageProperties().getDeliveryTag();
      try {
        //1. 接收消息   
        System.out.printf("接收到消息: %s, deliveryTag: %d%n", new String(message.getBody(),"UTF-8"),message.getMessageProperties().getDeliveryTag());
        //2. 处理业务逻辑
        System.out.println("处理业务逻辑");
        //⼿动设置⼀个异常, 来测试异常拒绝机制
        //  int num = 3/0;
        //3. ⼿动签收
            channel.basicAck(deliveryTag, true);
        } catch (Exception e) {
            //4. 异常了就拒绝签收
            //第三个参数requeue, 是否重新发送, 如果为true, 则会重新发送
            // 若为false, 则直接丢弃
            channel.basicNack(deliveryTag, true,true);
        }
    }
}

异常后会不断重试

2. 持久化

RabbitMQ的持久化分为三部分：交换器持久化、队列持久化、消息持久化

2.1 交换机持久化

交换器的持久化是通过声明交换机时将durable参数设置为true实现的，相当于交换机的属性在服务器内部保存，在MQ服务器发送意外关闭后，重启时不需要重新建立交换机，交换机会自动建立，相当于一直存在

如果交换机不设置持久化，那么在重启后，相关的交换机元数据会丢失，对一个长期使用的交换器来说，建议将其值为持久化

ExchangeBuilder.topicExchange(Constant.ACK_EXCHANGE_NAME).durable(true).build()

2.2 队列持久化

队列的持久化是在声明队列时将 durable 参数设置为true

如果队列不设置持久化，在服务器重启后，队列就会被删掉，此时数据也会丢失

队列的持久化能保证队列本身的元数据不会因异常情况而丢失，但是并不能保证内部所存储的消息不会丢失，要确保消息不会丢失，需要将消息设置为持久化

QueueBuilder.durable(Constant.ACK_QUEUE).build();

进入源码会发现，该方法默认durable是true

java 复制代码

public static QueueBuilder durable(String name) {
   return (new QueueBuilder(name)).setDurable();
}

java 复制代码

private QueueBuilder setDurable() {
   this.durable = true;
   return this;
}

如果要设置为非持久化

QueueBuilder.nonDurable(Constant.ACK_QUEUE).build();

2.3 消息持久化

消息实现持久化，需要把消息的投递模式（MessageProperties 中的 deliveryMode）设置为2

也就是 MessageDeliveryMode.PERSISINT

java 复制代码

public enum MessageDeliveryMode {
    NON_PERSISTENT,//⾮持久
    PERSISTENT;//持久化
}

设置了队列和消息的持久化，但RabbitMQ服务器重启后，消息依然存在，如果只设置队列持久化，重启后消息会丢失，如果只设置消息持久化，重启后队列会消失，数据也会消失、

java 复制代码

//⾮持久化信息 
channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());

//持久化信息
channel.basicPublish("",QUEUE_NAME, 
MessageProperties.PERSISTENT_TEXT_PLAIN,msg.getBytes());

spring中默认是持久化

java 复制代码

// 创建⼀个Message对象，设置为非持久化
Message messageObject = new Message(message.getBytes(), new 
MessageProperties());
messageObject.getMessageProperties().setDeliveryMode(MessageDeliveryMode.NON_PERSIS
TENT)

rabbitTemplate.convertAndSend(Constant.ACK_EXCHANGE_NAME, "ack", 
messageObject);

将交换器、队列、消息都设置了持久化也不能100%保证数据不丢失

1）从消费者角度来看，如果在订阅消费队列时将autoAck设置为true，那么当消费者接收到相关信息之后，还没来得及处理就宕机了，这样也算数据丢失，进行手动确认可解决

2）在持久化的消息正确存入RabbitMQ只有，还需要一段时间才能存入硬盘中，如果在此时间发生了宕机，重启等异常情况，消息保存还没来得及落盘，那么消息将会丢失

如何解决：

1）引入仲裁队列（后续会将）

2）在发送端引入事务机制或者发送方确认机制来保证消息已经正确的发送并存储到RabbitMQ中

3. 发送方确认

3.1 confirm确认模式

Producer 在发送消息的时候，对发送端设置了一个 ConfirmCallback 监听，无论消息是都到达Exchange，这个监听都会执行，如果Exchange 成功收到，ACK确认为true

配置

java 复制代码

@Bean("confirmRabbitTemplate")
public RabbitTemplate confirmRabbitTemplate(ConnectionFactory 
connectionFactory){
    RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
    rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            System.out.printf("");
            if (ack){
                System.out.printf("消息接收成功, id:%s \n", correlationData.getId());
            }else {
                System.out.printf("消息接收失败, id:%s, cause: %s", correlationData.getId(), cause);
            }
        }
    });
    return rabbitTemplate;
}

java 复制代码

@Resource(name = "confirmRabbitTemplate")
private RabbitTemplate confirmRabbitTemplate;

@RequestMapping("/confirm")
public String confirm() throws InterruptedException {
    CorrelationData correlationData1 = new CorrelationData("1")
    confirmRabbitTemplate.convertAndSend(Constant.CONFIRM_EXCHANGE_NAME,
    "confirm", "confirm test...", correlationData1);
    return "确认成功";
}

3.2 return模式

java 复制代码

@Bean("confirmRabbitTemplate")
public RabbitTemplate confirmRabbitTemplate(CachingConnectionFactory connectionFactory{
   RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
   rabbitTemplate.setMandatory(true);
   rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
   @Override
   public void returnedMessage(ReturnedMessage returned) {
       System.out.printf("消息被退回: %s", returned);
   }
});
   return rabbitTemplate;
}

java 复制代码

public class ReturnedMessage {
   //返回的消息对象，包含了消息体和消息属性 
   private final Message message;
   //由Broker提供的回复码, 表⽰消息⽆法路由的原因. 通常是⼀个数字代码，每个数字代表不同的含义.  
   private final int replyCode;
   //⼀个⽂本字符串, 提供了⽆法路由消息的额外信息或错误描述.
   private final StringreplyText;
   //消息被发送到的交换机名称 
   private final String exchange;
   //消息的路由键，即发送消息时指定的键  
   private final String routingKey;
}