RabbitMQ(六)、消息可靠性投递

RabbitMQ消息的不可靠性主要有以上四个地方产生，下面对这四个地方都做出相应的策略保证，来保证RabbitMQ的高可靠性。

1. 服务端确认

1.1 服务端确认-Transaction模式

// 将 Channel 设置成事务模式
channel.txSelect();
try {
    ...
    // 发送消息
    channel.basicPublish("exchange_name", "routing_key", null, msg.getBytes("UTF-8"));
	// 提交事务
	channel.txCommit();
}catch(Exception e) {
    // 事务回滚
    channel.txRollback();
}

1.2 服务端确认-Confirm模式

1.2.1 单条确认

// 开启发送确认模式
channel.confirmSelect();
...
// 发送消息
channel.basicPublish("exchange_name", "routing_key", null, msg.getBytes("UTF-8"));
// 普通Confirm：发送一条，确认一条
if (channel.waitForConfirms()){
    // 消息发送成功
    ...
}else {
    // 消息发送失败
}

1.2.2 批量确认

一批消息确认一次

// 开启发送确认模式
channel.confirmSelect();
try {
    ...
    // 发送消息
    channel.basicPublish("exchange_name", "routing_key", null, msg.getBytes("UTF-8"));
    // 批量确认结果，Ack如果是Multiple=true,代表Ack里面的Delivery-Tag之前的消息都被确认了。
    // 只要存在一个未被确认的消息就会抛 Exception
    channel.waitForConfirmsOrDie();
}catch(Exception e){
    // 消息发送失败
}

异步确认(一边发送消息，一边确认)

try (
    // 建立连接
    Connection connection = factory.newConnection();
    // 创建Channel消息通道
    Channel channel = connection.createChannel();
) {
    // 开启发送确认模式
    channel.confirmSelect();
    // 用来维护未确认消息的 deliveryTag
    final SortedSet<Long> confirmSet = Collections.synchronizedSortedSet(new TreeSet());
    // 异步监听确认和未确认的消息
    channel.addConfirmListener(new ConfirmListener() {
        @Override
        public void handleNack(long deliveryTag, boolean multiple) throws IOException {
            System.out.println("Broker 未确认消息标识" + deliveryTag);
            if (multiple) {// multiple表示是否批量：true -> 批量（未确认当前deliveryTag之前的全部信息）
                // headSet表示后面参数之前的所有元素
                confirmSet.headSet(deliveryTag + 1l).clear();
            } else {
                confirmSet.remove(deliveryTag);
            }
            // 这里添加重发的方法
        }

        @Override
        public void handleAck(long deliveryTag, boolean multiple) throws IOException {
            if (multiple) {// multiple表示是否批量：true -> 批量（确认当前deliveryTag之前的全部信息）
                // headSet表示后面参数之前的所有元素
                confirmSet.headSet(deliveryTag + 1l).clear();
            } else {
                confirmSet.remove(deliveryTag);
            }
            System.out.println("未确认的消息:" + confirmSet);
        }
    });
    String msg = "阁下可是常山赵子龙";
    for (int i = 0; i < 20; i++) {
        long seqno = channel.getNextPublishSeqNo();
        // 发送消息
        channel.basicPublish("exchange_name", "routing_key", null, (msg + i).getBytes("UTF-8"));
        confirmSet.add(seqno);
    }
    System.out.println("所有消息:" + confirmSet);

    TimeUnit.SECONDS.sleep(10);
} catch (Exception e) {
    e.printStackTrace();
}

2. 路由保证

1. 设置发送消息参数mandatory=true，并且添加ReturnListener监听

try (
        // 建立连接
        Connection connection = factory.newConnection();
        // 创建Channel消息通道
        Channel channel = connection.createChannel();
) {
    channel.addReturnListener(new ReturnListener() {
        @Override
        public void handleReturn(int replyCode, String replyText, String exchange,
                                 String routingKey, AMQP.BasicProperties basicProperties, byte[] bytes) throws IOException {
            System.out.println("=============监听器收到了无法路由的消息==============");
            System.out.println("replyCode:" + replyCode);
            System.out.println("replyText:" + replyText);
            System.out.println("exchange:" + exchange);
            System.out.println("routingKey:" + routingKey);
            System.out.println("basicProperties:" + basicProperties);
            System.out.println("message:" + new String(bytes, StandardCharsets.UTF_8));
        }
    });
    String msg = "阁下可是常山赵子龙";
    // 第三个参数为 mandatory, mandatory=true 时 ReturnListener 才生效
    channel.basicPublish(RabbitMQConfig.DIRECT_EXCHANGE, "not_exit_routingKey", true,
            null, msg.getBytes(StandardCharsets.UTF_8));
    
    TimeUnit.SECONDS.sleep(5);
} catch (Exception e) {
    e.printStackTrace();
}

2. 指定交换机的备份交换机

为交换机添加备份交换机 (alternate-exchange=备份交换机名称) ，由备份交换机路由到对应队列，交由相应消费者进行处理。

Map<String, Object> headers = new HashMap<>();
headers.put("alternate-exchange", "ALTERNATE-EXCHANGE");// 指定备份交换机
AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
        .headers(headers)
        .build();
channel.basicPublish(RabbitMQConfig.DIRECT_EXCHANGE, "routingKey", 
        properties, msg.getBytes(StandardCharsets.UTF_8));

3. 集群

通过集群保证RabbitMQ的高可用，同时保证消息在队列持久化，进而保证了可靠性。

4. 可靠性投递

消息确认设置 autoAck 为 false：手动应答

// 创建消费者
Consumer consumer = new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        try {
            // 获取消息
            String msg = new String(body, "UTF-8");
            System.out.println("message:" + msg + " 消息接收时间" +
                    new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()));
            if (msg.contains("拒绝接收")) {
                /**
                 * 拒绝消息
                 * requeue：是否重新进入RabbitMQ队列。true：是，false：直接丢弃
                 * 注意：如果只有一个消费者，requeue 为 true的时候会循环拒绝消费，从而死循环
                 */
                // long deliveryTag, boolean requeue
                channel.basicReject(envelope.getDeliveryTag(), false);
            } else {
                // 进行手工应答
                // long deliveryTag, boolean multiple
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        } catch (Exception e) {
            e.printStackTrace();
            /**
             * 异常
             * requeue：是否重新进入RabbitMQ队列。true：是，false：直接丢弃
             * 注意：如果只有一个消费者，requeue 为 true的时候会循环拒绝消费，从而死循环
             */
            // long deliveryTag, boolean multiple, boolean requeue
            channel.basicNack(envelope.getDeliveryTag(), true, false);
        }
    }
};

// 非自动确实消息的前提下，如果一定数量的消息未进行确认，将不再接收消息
channel.basicQos(10);// prefetch count
// 开始获取消息String queue, boolean autoAck, Consumer callback
channel.basicConsume(RabbitMQConfig.QUEUE_NAME, false, consumer);// 此处要注意，必须关闭自动应答autoAck=false