RabbitMQ之Producer(三)

最新推荐文章于 2024-09-10 13:21:22 发布
原创 最新推荐文章于 2024-09-10 13:21:22 发布 · 561 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#死信队列 #延迟队列 #DLX

本文深入探讨了消息队列中的死信队列、延迟队列和优先级队列的实现原理与应用场景，通过代码示例展示了如何配置这些高级特性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

死信队列

  1. 死信队列(DLQ(Dead-Letter-Queue))用来保存处理失败或者过期的消息。当一个消息变为死信消息(Dead Message)之后,消息会被投递到死信交换器(DLX(Dead-Letter-Exchange))中，DLX会将消息投递到死信队列(DLQ)中

  2. 消息变为死信消息的情况

    • 消息没有被正确消费————被取消确认(Basic.Nack或者Basic.Reject),并且设置requeue参数为false；
    • 消息TTL过期
    • 队列达到最大长度

  3. 死信交换器(DLX(Dead-Letter-Exchange))就是普通的Exchange.RabbitMQ 不会去验证死信交换器(DLX(Dead-Letter-Exchange))设置是否有效，当死信消息找不到指定的交换器时，死信消息会被RabbitMQ安静的丢弃，而不是抛出异常。

  4. 当在某一个队列中设置x-dead-letter-exchange属性时，如果这个队列中有消息变为死信消息，则Broker会自动的将这个消息重新发布到设置的Exchange上(x-dead-letter-exchange对应的那个交换器)。

  5. 代码示例

      /**
     * 死信队列
     */
    @Test
    public void testDLX() {
        ConnectionFactory factory = new ConnectionFactory();

        String userName = "jannal";
        String password = "jannal";
        String virtualHost = "jannal-vhost";
        String dlxQueueName = "jannal.direct.queue.dlx";
        String queueNameNormal = "jannal.direct.queue.normal";
        String dlxExchange = "jannal.direct.exchange.dlx";
        String exchangeNormal = "jannal.direct.exchange.normal";
        String routingKey = "DeadMessage";
        String bindingKey = "DeadMessage";
        String hostName = "jannal.mac.com";
        int portNumber = 5672;

        factory.setUsername(userName);
        factory.setPassword(password);
        factory.setVirtualHost(virtualHost);
        factory.setHost(hostName);
        factory.setPort(portNumber);
        factory.setAutomaticRecoveryEnabled(false);

        Connection conn = null;
        try {
            conn = factory.newConnection();
            Channel channel = conn.createChannel();
            boolean durable = true;
            boolean exclusive = false;
            boolean autoDelete = false;


            //普通队列添加DLX
            HashMap<String, Object> queueArgs = new HashMap<>();
            queueArgs.put("x-dead-letter-exchange", dlxExchange);
            //如果不为DLX执行routingKey，则使用原来队列的
            //args.put("x-dead-letter-routing-key","dlx");
            queueArgs.put("x-message-ttl", 10000); // 设置队列中消息存活时间为10秒
            queueArgs.put("x-max-length", 5); // 设置队列最大消息数量为5
            channel.queueDeclare(queueNameNormal, durable, exclusive, autoDelete, queueArgs);
            channel.exchangeDeclare(exchangeNormal, "direct", true);
            channel.queueBind(queueNameNormal, exchangeNormal, bindingKey);

            //死信
            channel.queueDeclare(dlxQueueName, durable, exclusive, autoDelete,null);
            channel.exchangeDeclare(dlxExchange, "direct", true);
            channel.queueBind(dlxQueueName, dlxExchange, bindingKey);

            boolean mandatory = false;
            boolean immediate = false;
            String msg = "Hello, world ";
            for (int i = 0; i < 12; i++) {
                channel.basicPublish(exchangeNormal,
                        routingKey,
                        mandatory,
                        immediate,
                        MessageProperties.PERSISTENT_TEXT_PLAIN,
                        msg.getBytes("UTF-8"));
            }

        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        } catch (TimeoutException e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

  6. 查看web控制台,Lim表示x-max-length=5,D表示durable=true,TTL表示x-message-ttl=10000,DLX表示x-dead-letter-exchange=jannal.direct.exchange.dlx。 因为队列最大长度为5，所以发送12条消息其中5条是进入jannal.direct.queue.normal,其中7条被放入到jannal.direct.queue.dlx死信队列中。当普通队列中的5条消息10s后过期时，此时12条消息都被投递到死信队列中

延迟队列

  1. 延迟队列存储的是延迟的消息，即consumer(消费者)只有在等待特定的时间后才能去消费消息或者看到消息。

  2. 延迟消息应用场景

    • 一个A任务执行之后，等待特定的时间T，B任务才能去执行。比如用户买火车票，必须在30分钟以内支付，否则席位会被取消。此时【取消席位】这个任务就可以使用延迟队列来处理。再比如滴滴打车之后，用户一直不评价，24小时之后自动评价

  3. x-message-ttl设置队列中消息的存活时间，当消息过期变为死信队列之后，此时Consumer(消息者)就可以从死信队列中消费消息，这样就达到了延迟特定时间的目的了。

  4. 为不同的延迟时间设置不同的队列，代码示例

     /**
     * 延迟队列
     */
    @Test
    public void testDelayQueue() {
        ConnectionFactory factory = new ConnectionFactory();

        String userName = "jannal";
        String password = "jannal";
        String virtualHost = "jannal-vhost";
        String dlxQueueName_5 = "jannal.direct.queue.dlx.5";
        String dlxQueueName_10 = "jannal.direct.queue.dlx.10";
        String queueNameNormal_5 = "jannal.direct.queue.normal_5";
        String queueNameNormal_10 = "jannal.direct.queue.normal_10";
        String dlxExchange_5 = "jannal.direct.exchange.dlx_5";
        String dlxExchange_10 = "jannal.direct.exchange.dlx_10";
        String exchangeNormal = "jannal.direct.exchange.normal";

        String hostName = "jannal.mac.com";
        int portNumber = 5672;

        factory.setUsername(userName);
        factory.setPassword(password);
        factory.setVirtualHost(virtualHost);
        factory.setHost(hostName);
        factory.setPort(portNumber);
        factory.setAutomaticRecoveryEnabled(false);

        Connection conn = null;
        try {
            conn = factory.newConnection();
            Channel channel = conn.createChannel();
            boolean durable = true;
            boolean exclusive = false;
            boolean autoDelete = false;

            HashMap<String, Object> queueArgs = new HashMap<>();
            queueArgs.put("x-dead-letter-exchange", dlxExchange_5);

            //设置5s
            queueArgs.put("x-message-ttl", 5);
            channel.queueDeclare(queueNameNormal_5, durable, exclusive, autoDelete, queueArgs);
            channel.exchangeDeclare(exchangeNormal, "direct", true);
            channel.queueBind(queueNameNormal_5, exchangeNormal, "5s");
            //设置10s
            queueArgs.put("x-dead-letter-exchange", dlxExchange_10);
            queueArgs.put("x-message-ttl", 10);
            channel.queueDeclare(queueNameNormal_10, durable, exclusive, autoDelete, queueArgs);
            channel.exchangeDeclare(exchangeNormal, "direct", true);
            channel.queueBind(queueNameNormal_10, exchangeNormal, "10s");

            //死信
            channel.queueDeclare(dlxQueueName_5, durable, exclusive, autoDelete,null);
            channel.exchangeDeclare(dlxExchange_5, "direct", true);
            channel.queueBind(dlxQueueName_5, dlxExchange_5, "5s");

            channel.queueDeclare(dlxQueueName_10, durable, exclusive, autoDelete,null);
            channel.exchangeDeclare(dlxExchange_10, "direct", true);
            channel.queueBind(dlxQueueName_10, dlxExchange_10, "10s");


            boolean mandatory = false;
            boolean immediate = false;
            String msg = "Hello, world ";
            //过期时间5s的12条
            for (int i = 0; i < 12; i++) {
                channel.basicPublish(exchangeNormal,
                        "5s",
                        mandatory,
                        immediate,
                        MessageProperties.PERSISTENT_TEXT_PLAIN,
                        msg.getBytes("UTF-8"));
            }

            //过期时间10s的10条
            for (int i = 0; i < 10; i++) {
                channel.basicPublish(exchangeNormal,
                        "10s",
                        mandatory,
                        immediate,
                        MessageProperties.PERSISTENT_TEXT_PLAIN,
                        msg.getBytes("UTF-8"));
            }

        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        } catch (TimeoutException e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

  5. web控制台查看

优先级队列

  1. 对于消息在Broker中堆积的情况下，优先级高的消息具有优先被消费的特权。

  2. 代码示例

            /**
         * 优先级队列
         */
        @Test
        public void testPriority(){
            ConnectionFactory factory = new ConnectionFactory();
    
            String userName = "jannal";
            String password = "jannal";
            String virtualHost = "jannal-vhost";
            String queueName = "jannal.direct.queue.priority";
            String exchange = "jannal.direct.exchange.priority";
            String routingKey = "priority";
            String bindingKey = "priority";
            String hostName = "jannal.mac.com";
            int portNumber = 5672;
    
            factory.setUsername(userName);
            factory.setPassword(password);
            factory.setVirtualHost(virtualHost);
            factory.setHost(hostName);
            factory.setPort(portNumber);
            factory.setAutomaticRecoveryEnabled(false);
    
            Connection conn = null;
            try {
                conn = factory.newConnection();
                Channel channel = conn.createChannel();
                boolean durable = true;
                boolean exclusive = false;
                boolean autoDelete = false;
    
    
                HashMap<String, Object> args = new HashMap<>();
                args.put("x-max-priority", 10);//设置一个队列的最大优先级
                channel.queueDeclare(queueName, durable, exclusive, autoDelete, args);
                channel.exchangeDeclare(exchange, "direct", true);
                channel.queueBind(queueName, exchange, bindingKey);
    
                boolean mandatory = false;
                boolean immediate = false;
                String msg = "Hello, world ";
    
                //消息的优先级默认是0，最高为队列设置的优先级，优先级高的消息会被先消费
                AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().priority(3).build();
                channel.basicPublish(exchange,
                        routingKey,
                        mandatory,
                        immediate,
                        properties,
                        msg.getBytes("UTF-8"));
    
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            } catch (TimeoutException e) {
                logger.error(e.getMessage(), e);
            } finally {
                if (conn != null) {
                    try {
                        conn.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

  3. web控制台
    -w650

RabbitMQ之Producer(一)
jannal专栏
09-24 2104
文章目录RabbitMQ-java-client版本API介绍`queueDeclare``exchangeDeclare``queueBind``exchangeBind``basicPublish`持久化 RabbitMQ-java-client版本 com.rabbitmq:amqp-client:4.3.0 RabbitMQ版本声明: 3.6.15 API介绍 Connectio...
kettle从入门到精通 第五十三课 ETL之kettle MQTT/RabbitMQ producer 实战
zhangjin1222的博客
04-18 2129
MQTT 是基于发布/订阅模式（Publish/Subscribe）的协议，其中设备可以发布消息到一个主题（Topic），其他设备可以订阅这个主题以接收相关消息。MQTT (Message Queuing Telemetry Transport) 是一种轻量级的消息传输协议，设计用于连接低带宽、高延迟或不可靠网络的设备。在主题名称字段中，输入您希望发布流数据（消息）的 MQTT 主题的名称。指定此步骤将连接的 MQTT 服务器的地址，如127.0.0.1:1883（注意这里的端口是1883，不是5672）
RabbitMQ之Producer(二)
jannal专栏
09-29 511
文章目录事务publish Confirm 模式同步方式发送单条同步方式发送批量同步发送异步发送总结 事务 事务机制步骤 设置Channel为事务模式:channel.txSelect 发送信息 如果出现异常则回滚channel.txRollback，如果成功则channel.txCommit 如果事务提交成功，则消息一定达到了RabbitMQ.因为只有消息成功被RabbitMQ接收，...
rabbitmq producer
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
02-04 295
1.加入maven 依赖 2.创建实体类； package com.tuling.entity; import java.io.Serializable; import java.util.Date; /** * Created by smlz on 2019/10/9. */ public class Order implements Serializable { ...
6.RabbitMQ 生产者Producer实现
自能生羽翼，何必仰云梯
07-20 453
1、创建Producer配置类RabbitMqConfig ： package com.java996.producer.config; import org.springframework.amqp.core.Binding; import org.springframework.amqp.core.BindingBuilder; import org.springframework.amqp.core.DirectExchange; import org.springframework.amqp.c
RabbitMq_Producer 详解
Crown的博客
12-06 634
package com.clown.message; import com.rabbitmq.client.*; import org.junit.Test; public class MqTest { public final static String IP_ADDRESS = "127.0.0.1"; public final static int PORT = 5...
rabbitmq-producer
03-13
本项目“rabbitmq-producer”专注于RabbitMQ的生产者部分，即消息的发布者。在这里，我们将深入探讨RabbitMQ的基本概念、生产者的角色以及如何创建一个RabbitMQ生产者应用。 **1. RabbitMQ基本概念** RabbitMQ是...
rabbitmq-producer:Rabbit MQ-ConsumerProducer消息队列
03-06
本篇文章将深入探讨RabbitMQ的Producer（生产者）和Consumer（消费者）模型，以及如何在C#环境中使用它们。 首先，RabbitMQ的Producer是发送消息的应用程序部分，它的主要任务是创建消息并将其发送到消息队列。在C#...
rabbitmqproducer.rar
05-15
RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于各种业务场景，包括任务调度、数据同步、日志收集等。SpringBoot框架以其轻量级和便捷的特性，成为了开发Java应用的首选。本方案将重点讨论如何在SpringBoot...
RabbitMQ的Producer发送消息保证消息不丢失方案
chuixieli7527的博客
06-04 428
RabbitMQ的Producer发送消息保证消息不丢失方案 在rabbitTemplate异步确认的基础上 1 ，为当前message生成一个唯一的id，并在本地缓存已发送的message 2， 通过confirmCallback监听被确认的ack【虽然没有message本身，但是...
RabbitMQ中的生产者Producer，消费者Consumer，服务节点Broker，队列Queue和Exchange交换机
m0_58524181的博客
10-10 2354
RabbitMQ中的生产者Producer，消费者Consumer，服务节点Broker，队列Queue和Exchange交换机
RabbitMQ生产者Producer实现
m0_68935893的博客
01-05 536
【代码】RabbitMQ生产者Producer实现。
【RabbitMQ】消息可靠性投递（一）Producer-＞Broker
A minor
02-28 1714
第一个环节是生产者发送消息到Broker。可能因为网络或者Broker的问题导致消息发送失败，生产者不能确定Broker有没有正确的接收。 在 RabbitMQ 里面提供了两种机制服务端确认机制，也就是在生产者发送消息给RabbitMQ的服务端的时候，服务端会通过某种方式返回一个应答，只要生产者收到了这个应答，就知道消息发送成功了。 第一种是Transaction（事务）模式，第二种Confirm（确认）模式。 1.事务模式ACK 通过channel.txSelect()方法把信道设置成事务模式，然后就可以
理解 RabbitMQ：生产者、连接、通道、交换机、队列与消费者的消息流
吃面不喝汤的博客
09-10 1719
生产者（Producer）：发送消息的一方。通常在需要时建立连接，不保持长时间连接。连接（Connection）：生产者和消费者与 RabbitMQ 之间的物理 TCP 连接。多个通道可以复用一个连接，减少资源消耗。通道（Channel）：轻量级的虚拟通信路径，用于执行消息的发送和接收操作。交换机（Exchange）：负责根据绑定规则将消息路由到不同的队列，确保消息能够正确分发。队列（Queue）：存储消息的容器，等待消费者提取和处理消息。消费者（Consumer）：从队列中消费消息的程序。
【RabbitMQ】Producer之mandatory、alternative exchange、TTL - 基于AMQP 0-9-1
穿越在未来的专栏
03-02 469
这篇文章主要介绍RabbitMQ Producer的开发，包括mandatory参数，备份交换器，消息过期时间，队列过期时间，每个案例都给出关键代码实现，通过一篇文章就可以掌握Producer客户端日常开发。
RabbitMQ生产者producer, consumer实现
可控的事情要谨慎，不可控的事情要乐观。
10-07 984
RabbitMQ目录1. docker安装RabbitMQ2. RabbitMQConfig配置文件2.1 RabbitMQConfig2.1 new Queue重载参数解析3. 生产者consumer3.1 引入依赖3.2 配置文件3.3 发送消息4. 创建消费者consumer4.1 引入依赖（同上）4.2 配置（同上）4.3 消费 1. docker安装RabbitMQ 下载地址： Downloading and Installing RabbitMQ docker run -it --rm --na
rabbit - producer的confirm和consumer的ack模式
weixin_30820151的博客
08-30 256
本篇和大家分享的是关于rabbit的生产和消费方的一些实用的操作；正如文章标题，主要内容如producer的confirm和consumer的ack，这两者使用的模式都是用来保证数据完整性，防止数据丢失。 producer的confirm模式 consumer的ack模式 producer的confirm模式 首先，有这样一种业务场景1：a系统在做活动前，需要给用户的手机...
rabitmq的producer发送消息的流程？
m0_63102097的博客
05-16 184
在与RabbitMQ服务器建立连接之后，生产者需要创建一个通道（Channel），通道是进行消息发布和接收的主要通信载体。总的来说，RabbitMQ的生产者发送消息的流程包括建立连接、创建通道、声明交换机、发布消息和错误处理等步骤。：生产者需要声明将要发送消息的交换机，确保交换机已经存在于RabbitMQ中。：在消息被发送到RabbitMQ之后，生产者应该处理可能出现的错误，比如连接断开、无法发送消息等异常情况。：当生产者不再需要与RabbitMQ通信时，需要关闭通道和连接，释放资源并结束通信。
（转） RabbitMQ学习之spring整合发送同步消息（注解实现）
07-06 141
http://blog.youkuaiyun.com/zhu_tianwei/article/details/40918477 上一篇文章通过xml配置rabbitmq的rabbitTemplate，本节将使用注解的形式实现同步消息的发送。 1.注解配置AnnotationConfiguration.Java [java]view plaincopy print? ...
RabbitMQ之基础入门
最新发布
07-28
RabbitMQ 是一个开源的消息中间件，主要用于实现系统间的异步通信和解耦。其核心概念包括生产者（Producer）、消费者（Consumer）、队列（Queue）、交换机（Exchange）和绑定（Binding）。生产者将消息发送到交换机，交换机根据绑定规则将消息路由到一个或多个队列中，消费者从队列中获取并处理消息 [^3]。 ### 核心组件与工作流程 - **生产者（Producer）**：负责生成消息并将其发送到交换机。 - **交换机（Exchange）**：接收来自生产者的消息，并根据绑定规则决定将消息发送到哪些队列。RabbitMQ 支持多种类型的交换机，如直连（Direct）、扇出（Fanout）、主题（Topic）和头部（Headers）交换机 [^2]。 - **队列（Queue）**：存储消息的缓冲区，直到消费者处理它们。 - **消费者（Consumer）**：从队列中获取消息并进行处理。 - **绑定（Binding）**：定义了交换机与队列之间的关系，通常通过路由键（Routing Key）来指定消息的路由规则 [^3]。 ### 消息确认机制 为了确保消息不会因为消费者崩溃而丢失，RabbitMQ 提供了手动确认（ACK）机制。消费者在处理完消息后，必须显式地向 RabbitMQ 发送确认信号，告知该消息已经成功处理。如果消费者在处理消息时发生错误或崩溃，RabbitMQ 将不会收到确认信号，并会将消息重新放入队列中，以便其他消费者可以处理它 [^1]。 ### 流量控制与公平分发 当多个消费者同时从同一个队列中消费消息时，可能会出现某些消费者负载过高的情况。为了解决这个问题，RabbitMQ 提供了 `basicQos` 方法，允许设置 `prefetchCount` 参数。通过将 `prefetchCount` 设置为 1，可以确保 RabbitMQ 不会在消费者尚未确认前一条消息之前向其发送新的消息。这样可以实现更公平的消息分发，避免某些消费者过载 [^1]。 ### 主题交换机（Topic Exchange） 主题交换机是一种灵活的路由方式，它使用通配符来匹配路由键。`*` 可以匹配一个单词，而 `#` 可以匹配零个或多个单词。这种方式非常适合需要根据多个条件进行路由的场景 [^2]。 ### 示例代码：使用 Python 和 `pika` 库发送和接收消息 ```python import pika # 连接到 RabbitMQ 服务器 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() # 声明一个名为 'hello' 的队列 channel.queue_declare(queue='hello') # 发送消息到 'hello' 队列 channel.basic_publish(exchange='', routing_key='hello', body='Hello World!') print(" [x] Sent 'Hello World!'") # 关闭连接 connection.close() ``` ```python import pika # 连接到 RabbitMQ 服务器 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() # 声明一个名为 'hello' 的队列 channel.queue_declare(queue='hello') # 定义回调函数，用于处理接收到的消息 def callback(ch, method, properties, body): print(f" [x] Received {body}") # 手动确认消息 ch.basic_ack(delivery_tag=method.delivery_tag) # 开始消费消息 channel.basic_consume(queue='hello', on_message_callback=callback) print(' [*] Waiting for messages. To exit press CTRL+C') # 启动消费者循环 channel.start_consuming() ``` ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值