RabbitMQ（三）-消息可靠性投递

  在RabbitMQ（一）简介及工作原理中，通过工作原理图，我们了解到一个消息从产生到投递成功要经过的几个环节。同样，保证这几个环节的成功执行也是保证消息可靠投递的重要因素。

如何保证消息投递成功

服务器确认（生产者到服务器）

  在消息发布的过程中，可能出现网络故障或者消息丢失的情况。通过发布确认机制，生产者可以知道服务器是否成功接收了消息。通过反馈信息可以帮助生产者进行错误处理和监控。确保消息能够可靠地被服务器接收和处理。

事务模式

  通过channel.txSelect()将信道设置为事务模式进行消息投递，通过channel.commit()进行事务提交，如果事务提交失败，则用channle.rollback()进行回滚。

  但是显而易见的是，这种方式每次只能传递一条消息，多条消息传递时需要频繁对channel进行设置，并且一条消息的确认需要多次通信交互。另外由于过程是阻塞的，对吞吐量会造成很大影响，根据官网给出的说法，吞吐量会下降250倍。因此，有了接下来的确认模式

确认模式

  通过channel.confirmSelect()将channel设置为确认模式。

同时，confirm模式下也有3种模式可以进行选择：

1. 普通模式

        channel.confirmSelect();
        channel.basicPublish("QUESE_CONFIRM","",null,"普通confirm".getBytes(StandardCharsets.UTF_8));
        // 普通Confirm，发送一条，确认一条
        if (channel.waitForConfirms()){
            System.out.println("提交成功");
        }else {
            System.out.println("出现错误");
        }

2. 批量模式，这种模式有一个明显缺点：第一，无法确认是具体哪条消息发送错误；第二，如果大量消息进行发送，只要发生一个错误，其他消息都要进行重新发送，且发送成功的消息无法回滚，会造成重复发布。

        channel.confirmSelect();
        try {
            channel.confirmSelect();
            for (int i = 0; i < 500; i++) {
                // 发送消息
                // String exchange, String routingKey, BasicProperties props, byte[] body
                channel.basicPublish("", "QUESE_CONFIRM", null, ("批量" +"-"+ i).getBytes());
            }
            // 批量确认结果，ACK如果是Multiple=True，代表ACK里面的Delivery-Tag之前的消息都被确认了
            // 比如5条消息可能只收到1个ACK，也可能收到2个（抓包才看得到）
            // 直到所有信息都发布，只要有一个未被Broker确认就会IOException
            channel.waitForConfirmsOrDie();
            System.out.println("消息发送完毕，批量确认成功");
        } catch (Exception e) {
            // 发生异常，可能需要对所有消息进行重发
            e.printStackTrace();
        }

3. 异步模式

        // 用来维护未确认消息的deliveryTag
       final SortedSet<Long> confirmSet = Collections.synchronizedSortedSet(new TreeSet<Long>());
       channel.confirmSelect();
       // 这里不会打印所有响应的ACK；ACK可能有多个，有可能一次确认多条，也有可能一次确认一条
       // 异步监听确认和未确认的消息
       // 如果要重复运行，先停掉之前的生产者，清空队列
       channel.addConfirmListener(new ConfirmListener(){
           @Override
           public void handleAck(long l, boolean multiple) throws IOException {
               // 如果true表示批量执行了deliveryTag这个值以前（小于deliveryTag的）的所有消息，如果为false的话表示单条确认
               System.out.println(String.format("Broker已确认消息，标识：%d，多个消息：%b", l, multiple));
               if (multiple) {
                   // headSet表示后面参数之前的所有元素，全部删除
                   confirmSet.headSet(l + 1L).clear();
               } else {
                   // 只移除一个元素
                   confirmSet.remove(l);
               }
               System.out.println("待确认的消息:"+confirmSet);
           }

           @Override
           public void handleNack(long l, boolean multiple) throws IOException {

               System.out.println("Broker未确认消息，标识：" + l);
               if (multiple) {
                   // headSet表示后面参数之前的所有元素，全部删除
                   confirmSet.headSet(l+1L).clear();
               }else{
                   confirmSet.remove(l);
               }
               //
               System.out.println("执行回滚");
           }
       });

       for (int i = 0; i < 12; i++) {
           long nextSeqNo = channel.getNextPublishSeqNo();
           // 发送消息
           // String exchange, String routingKey, BasicProperties props, byte[] body
           channel.basicPublish("", "QUESE_CONFIRM", null, ("confirmMsg" +"-"+ i).getBytes());
           confirmSet.add(nextSeqNo);
       }

交换机路由

  在 RabbitMQ 中，当routingKey错误或当前交换机未绑定队列时会导致从交换机（exchange）到队列的消息传递失败。
通过以下两种方案可以对这种情况进行捕捉处理：
首先，对发生消息设置mandatory=true，表示强制rabbitMQ对消息进行处理，如果发生无法路由的问题，将消息路由到交换机绑定的备用交换机或向生产者返回一个回执。

1. ReturnListener回执

       channel.addReturnListener((returnMsg)->{

           System.out.println("=========监听器收到了无法路由，被返回的消息============");
           System.out.println("replyText:"+returnMsg.getReplyText());
           System.out.println("exchange:"+returnMsg.getExchange());
           System.out.println("routingKey:"+returnMsg.getRoutingKey());
           System.out.println("message:"+new String(returnMsg.getBody()));
       });
       AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder().deliveryMode(2).
               contentEncoding("UTF-8").build();
       //mandatory =>TRUE 当路由不到队列时，会进行returnback或进入备用交换机处理,否则进行丢弃
       channel.basicPublish("EXCHANE_RETURN", "", true,properties, ("returnMsg"  ).getBytes());

2. 设置备用交换机

channel.exchangeDeclare("EXCHANGE_ALTER", BuiltinExchangeType.FANOUT,false,false,null);
channel.queueDeclare("ALT_QUEUE",false,false,false,null);
channel.queueBind("ALT_QUEUE","EXCHANGE_ALTER","");
Map<String, Object> arguments=new HashMap<>();
arguments.put("alternate-exchange","EXCHANGE_ALTER");//设置备用交换机
channel.exchangeDeclare("EXCHANE_RETURN", BuiltinExchangeType.DIRECT,false,false,arguments);

  需要注意的是，备用交换机的优先级高于ReturnListener。

队列数据安全

  重启或宕机时，放在内存中的数据会丢失。因此，通过数据持久化及集群，提高数据安全性。由于内容较多，详细在此不进行展开。

消费者确认

  在生产环境中，建议将消费者确认模式设置为手动确认。首先，是为了让Breaker知道，消息已经被成功消费，其次，自动确认模式虽然快速简单，但是存在风险，消费者在处理消息的过程中出现异常或崩溃，消息将丢失，无法重新投递。
手动确认使用步骤：
  1. 设置消费者的channel.basicConsume方法的第二个参数autoAck为false，表示关闭自动确认。
  2. 在消费者处理消息的逻辑中，处理完成后调用channel.basicAck方法发送确认，参数为消息的deliveryTag，可以确认多条消息的deliveryTag，表示已经确认的消息的最后一个deliveryTag。
  3. 如果消费者无法处理消息并希望丢弃消息，可以调用channel.basicReject或channel.basicNack()方法发送拒绝确认，参数为消息的deliveryTag。两者区别在于Nack支持批量拒绝消息。
  需要注意的是，拒绝方法中的requeue表示被拒绝的消息是否重新回到队列。但是，如果当前队列只有一个消费者在消费，会造成消费者重复消费一个处理不了的消息。