rabbitMQ 消费确认机制

无需确认机制

即生产者将消息发送到队列，消费者监听到该消息是，无需发送任何反馈信息给RabbitMQ 服务器。

AUTO 消费模式

生产者将消息发送至列队，消费者监听到反馈给RabbitMQ 服务器，之后将消息在队列种移除。

手动确认机制

即生产者将消息发送至队列，消费者监听到该消息是需要手动的以代码形象发送一个ACK 的反馈给RabbitMQ 服务器，之后消息将在RabbitMQ 的队列种移除。

以上为3种确认消费模式，常用的为AUTO、MANUAL机制。

RabbitMQ 在消息的发送、传输和接收的过程中，可以保证消息成功发送不会丢失，以及确认被消费。

消息高可用和确认消费

使用RabbitMQ 在实际的应用过程中，如果配置和使用不当，则会出现各种令人头疼的问题

• 发送出去的消息不知道有没有成功，即采用RabbitTemplate操作组件发送消息的时候，开发者认为消息已经发送出去了，然而在某些情况下却很可能发送失败。（如：交换机、路由、和队列绑定结构的消息模型不存在）
• 由于某些特殊原因，RabbitMQ服务出现宕机和崩溃等问题，导致其需要执行重启操作。如果列队中仍有大量的消息没有被消费，则很有可能在重启RabbitMQ 服务的过程中发生消息丢失的现象。
• 消费者在监听处理消息的时候，可能会出现监听失败或者直接崩溃等问题，导致消息所在的列队找不到对应的消费者而不断的重新入队，最终被重复消费的现象。

针对第一种情况Rabbit MQ 会在要求生产者发送消息之后进行“发送确认”，当确认成功是即代表发送出去了！
如下

 package com.ruoyi.framework.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;

@Configuration
public class RabbitMQConfig {

    /** 定义日志*/
    private static  final Logger loger = LoggerFactory.getLogger(RabbitMQConfig.class);
    /** 自动配置RabbitMQ 的连接工厂*/
    @Autowired
   private CachingConnectionFactory cachingConnectionFactory;
   //自动装配消息监听所在的容器工厂配置类实例
    @Autowired
    private SimpleRabbitListenerContainerFactoryConfigurer factoryConfigure;

   /**
    *  单一消费者配置实例
     * @return
    */
    @Bean(name = "singleListenerContainer")
    public SimpleRabbitListenerContainerFactory listenerContainerFactory(){
        //定义消息监听所在的容器工厂
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        /** 设置容器工厂所用的实例*/
        factory.setConnectionFactory(cachingConnectionFactory);
        /** 设置消息在传输中的格式，这里采用JSON 的格式进行传输*/
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
       /** 设置并发消费者的初始化数量，这里设置为一个*/
       factory.setConcurrentConsumers(1);
       /** 设置消费者最大并发数量.,这里设置1个*/
       factory.setMaxConcurrentConsumers(1);
      /** 设置并发消费者实例中每个实例拉取的消息数量*/
      factory.setPrefetchCount(1);
       return factory;
    }

   /**
    *  多消费者配置实例
    * @return
    */
    @Bean(name = "multiListnerContainer")
    public SimpleRabbitListenerContainerFactory simpleRabbitListenerContainerFactory(){
        //定义消息监听工厂所在的容器
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        /** 设置容器工厂所用的实例*/
        factoryConfigure.configure(factory,cachingConnectionFactory);
        /** 设置消息格式的传输格式，*/
        /** 设置消息在传输中的格式，这里采用JSON 的格式进行传输*/
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        /** 设置消息的确认模式。这里为NONE ,表示不需要确认消费*/
        factory.setAcknowledgeMode(AcknowledgeMode.NONE);
        /** 设置并发消费者的初始化数量，这里设置为一个*/
        factory.setConcurrentConsumers(10);
        /** 设置消费者最大并发数量.,这里设置5个*/
        factory.setMaxConcurrentConsumers(15);
        /** 设置并发消费者实例中每个实例拉取的消息数量*/
        factory.setPrefetchCount(10);
        return factory;
    }

   /**
    *  自定义配置RabbitMQ 发消息的操作组件RabbitTemplate
    * @return
    */
   @Bean
   public RabbitTemplate rabbitTemplate(){
        // 设置“发送消息后进行确认”
       cachingConnectionFactory.setPublisherConfirms(true);
       /** 设置“发送消息后返回确认信息”*/
       cachingConnectionFactory.setPublisherReturns(true);
       /** 构造发送消息组件实例对象*/
       RabbitTemplate rabbitTemplate = new RabbitTemplate(cachingConnectionFactory);
       rabbitTemplate.setMandatory(true);
       // 发消息后如果成功，则输出“消息发送成功”的反馈信息
       rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
           @Override
           public void confirm(CorrelationData correlationData, boolean b, String s) {
               loger.info("消息发送成功：correlationData({}),ack({}),cause({})",correlationData,b,s);
           }
       });

       /** 发送消息后，如果发送失败，则输出“消息发送失败-消息丢失” 的反馈信息*/
       rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
           @Override
           public void returnedMessage(Message message, int i, String s, String s1, String s2) {
               loger.info("消息丢失：exchange({}),route({}),replyCode({}),replyText({}),message({})",s1,s2,s,message);
           }
       });
       return rabbitTemplate;
   }

   // 定义读取配置文件的环境变量实例
   @Autowired
   private Environment environment;

   /**
    *  c创建简单的消息模型：队列 、 交互机 和路由
    * @return
    */
   @Bean(name = "basicQueue")
   public Queue basicQueue(){
       return  new Queue(environment.getProperty("mq.basic.info.queue.name"),true);
   }

   @Bean
   public DirectExchange basicExchange(){
       return  new DirectExchange(environment.getProperty("mq.basic.info.exchange.name"),true,false);
   }

   /**
    * 创建绑定
    * @return
    */
   @Bean
   public Binding basicBinding() {
       return BindingBuilder
               .bind(basicQueue())
               .to(basicExchange())
               .with(environment.getProperty("mq.basic.info.routing.key.name"));
   }

}

针对第二种情况，即如何保证RabbitMQ 队列种的消息不丢失；RabbitMq在创建创建队列、交换机是设置其持久化参数为true，即durable 设置为true。除此之外在创建消息是RabbitMQ要求设置消息的持久化模式为:“持久化”。
针对第三种情况，即如何保证消息能够被准备消费、不重复消费，RabbitMQ提供了“消费应答机制”，即ACK模式。分别为NONE(无需确认)、AUTO（自动确认）、MANUAL(手动确认)，不同的机制对应不同的 场景。在实际的生产环境种一般都是消息的确认机制，只有当消息被确认消费后，消息才会从列队种被移除。