029. RabbitMQ 消息可靠性和插件机制

时间秒杀一切 提交于 2020-08-19 17:38:30

1. 消息可靠性


  • RabbitMQ 的消息可靠性,一般是业务系统接入消息中间件时首要考虑的问题,一般通过三个方面保障:

    • 发送可靠性:确保消息成功发送到 Broker。
    • 存储可靠性:Broker 对消息持久化,确保消息不会丢失。
    • 消费可靠性:确保消息成功被消费。

1. 发送可靠性

  • 一般消息发送可靠性分为 3 个层级:

    • At most once:最多一次,消息可能会丢失,但绝不会重复传输。
    • At least once:最少一次,消息绝不会丢失,但可能会重复传输。
    • Exactly once:恰好一次,每条消息肯定会被传输一次且仅传输一次。
  • RabbitMQ 支持其中的“最多一次”和“最少一次”。

    • 其中“最少一次”投递实现需要考虑以下这几个方面的内容:

      • 消息生产者需要开启事务机制或者 publisher confirm 机制,以确保消息可以可靠地传输到 RabbitMQ 中。
      • 消息生产者需要配合使用 mandatory 参数或者备份交换器来确保消息能够从交换器路由到队列中,进而能够保存下来而不被丢弃。
    • “最多一次”的方式无需考虑以上那些方面,生产者随意发送,不过这样很难确保消息会成功发送。

image-20200703182019407

2. 消费可靠性

  • 消费者在消费消息的同时,需要将 autoAck 设置为 false,然后通过手动确认的方式去确认已经正确消费的消息,以免在消费端引起不必要的消息丢失。

3. 代码示例

// 可靠生产
// https://www.rabbitmq.com/confirms.html
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1. 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        // 2. 设置连接属性
        factory.setHost("114.67.85.157");
        factory.setUsername("admin");
        factory.setPassword("admin");

        Connection connection = null;
        Channel channel = null;
        try {
            // 3. 从连接工厂获取连接
            connection = factory.newConnection("生产者");

            // 4. 从连接中创建通道
            channel = connection.createChannel();

            // 进入 confirm 模式,每次发送消息,rabbitmq 处理之后会返回一个对应的回执消息
            AMQP.Confirm.SelectOk selectOk = channel.confirmSelect();

            // 增加监听器
            ArrayList<String> queues = new ArrayList<>();

            channel.addConfirmListener(new ConfirmListener() {
                @Override
                public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                    // deliveryTag 同一个 channel 中此条消息的编号。
                    // 业务...
                    System.out.println("受理成功 " + queues.get((int) deliveryTag) + " " + multiple);
                }
                @Override
                public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                    // 失败重发
                    // queues.get((int) deliveryTag)
                    System.out.println("受理失败 " + deliveryTag);
                }
            });

            // 受理 fanout 类型的交换器
            channel.exchangeDeclare("ps_test", "fanout");

            for (int i = 0; i < 10; i ++) {
                // 消息内容
                String message = "Hello confirm " + i;
                queues.add(message);

                // 发送消息到 ps_test 交换器上
                AMQP.BasicProperties basicProperties = new AMQP.BasicProperties();
                channel.basicPublish("ps_test", "", basicProperties, message.getBytes());
                System.out.println("消息 " + message + "已发送!");
            }

            // 等待 20 秒
            Thread.sleep(20 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (channel != null && channel.isOpen()) {
                channel.close();
            }
            if (connection != null && connection.isOpen()) {
                connection.close();
            }
        }
    }
}
/**
 * 消息确认机制
 */
public class Consumer {
    private static Runnable receive = () -> {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("114.67.85.157");
        factory.setUsername("admin");
        factory.setPassword("admin");

        Connection connection = null;
        Channel channel = null;
        final String clientName = Thread.currentThread().getName();

        try {
            connection = factory.newConnection("消费者-" + clientName);

            // 死信队列:专门用来存储出错、出异常的数据
            channel = connection.createChannel();
            channel.exchangeDeclare("dlq_exchange", "fanout");
            channel.queueDeclare("dlq_queue1", false, false, false, null);
            channel.queueBind("dlq_queue1", "dlq_exchange", "");

            channel = connection.createChannel();
            channel.exchangeDeclare("ps_test", "fanout");
            String queueName = "queue1";
            // 队列中有死信产生时,消息会转发到交换器 dlq_exchange
            Map<String, Object> args = new HashMap<>();
            args.put("x-dead-letter-exchange", "dlq_exchange");
            channel.queueDeclare(queueName, false, false, false, args);
            channel.queueBind(queueName, "ps_test", "");

            Channel finalChannel = channel;
            channel.basicConsume(queueName, false, "消费者-手动回执",
                    new DefaultConsumer(finalChannel) {
                        @Override
                        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                            try {
                                System.out.println("收到消息:" + new String(body));
                                // TODO 业务
                                long deliveryTag = envelope.getDeliveryTag();
                                // 模拟业务处理耗时
                                Thread.sleep(1000);
                                // 正常消费
                                finalChannel.basicAck(deliveryTag, false);
                                // 异常消费
//                                finalChannel.basicNack(deliveryTag, false, true);
                            } catch (InterruptedException e) {
                                // 异常消费, requeue参数 true 重发,false 不重发(丢弃或者移到 DLQ 死信队列)
                                // finalChannel.basicNack(envelope.getDeliveryTag(), false, false);
                                e.printStackTrace();
                            }
                        }
                    });

            System.out.println(clientName + " 开始接收消息");
            System.in.read();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    public static void main(String[] args) {
        new Thread(receive, "c1").start();
    }
}

2. RabbitMQ 插件机制


  • RabbitMQ 支持插件,通过插件可以扩展多种核心功能:支持多种协议、系统状态监控、其他 AMQP 0-9-1 交换类型、节点联合等。许多功能都是通过插件实现的。

插件列表

  • RabbitMQ 内置一些插件,通过 rabbitmq-plugins list 命令可以查看插件列表。

启用插件

  • 通过 rabbitmq-plugins 命令可以启用或禁用插件。
rabbitmq-plugins enable plugin-name
rabbitmq-plugins disable plugin-name

常用插件

  • rabbitmq_auth_mechanism_ssl:身份验证机制插件,允许 RabbitMQ 客户端使用 x509 证书和 TLS(PKI)证书进行身份验证。

  • rabbitmq_event_exchange:事件分发插件,使客户端可以接收到 Broker 的 queue.deleted、exchange.created、binding.created 等事件。

  • rabbitmq_management:基于 Web 界面的管理/监控插件。

  • rabbitmq_management_agent:启用 rabbitmq_management 时,会自动启用此插件,用于在 Web 管理中查看集群节点。

  • rabbitmq_mqtt:MQTT 插件,使 RabbitMQ 支持 MQTT 插件。

  • rabbitmq_web_mqtt:使 RabbitMQ 支持通过 WebSocket 订阅消息,基于 MQTT 协议传输。

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!