RabbitMQ消息模式（消费端限流 、消息的ACK与重回队列 、TTL消息 、死信队列）

最新推荐文章于 2024-08-24 02:31:39 发布
最新推荐文章于 2024-08-24 02:31:39 发布
阅读量427 收藏
点赞数
分类专栏： RabbitMQ 文章标签： RabbitMQ 消息队列 死信队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wx1762813417/article/details/104622850
版权

文章目录

1、消费端限流

什么是消费端的限流？

  • 假设一个场景，首先，我们RabbitMQ服务器有上万条未处理的消息，我们随便打开一个消费者客户端，会出现下面情况：巨量的消息瞬间全部推送过来，但是我们单个客户端无法同时处理这么多数据！

消费端限流RabbitMQ提供的解决方案?

  • RabbitMQ提供了一种qos（服务质量保证）功能，即在非自动确认消息的前提下，如果一定数目的消息（通过基于Consumer或者Channel设置Qos的值）未被确认前，不进行消费新的消息
  • Void BasicQos(uint prefetchSize, ushort prefetchCount, bool global);
    prefetchSize：0 不限制消息大小
    prefetchCount：会告诉RabbitMQ不要同时给一个消费者推送多于N个消息，即一旦有N个消息还没有ack，则该Consumer将block（阻塞）掉，直到有消息ack
    Global：true\false是否将上面设置应用于Channel；简单来说，就是上面限制是Channel级别的还是Consumer级别

注意： prefetchSize和global这两项，RabbitMQ没有实现，暂且不研究；
prefetch_count在no_ask=false的情况下生效，即在自动应答的情况下，这两个值是不生效的；

自定义消费者：

package com.hyf.rabbitmqapi.limit;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import java.io.IOException;

/**
 * @author xhy
 * @site www.4399.com
 * @company xxx公司
 * @create 2020-03-02 23:32
 */
public class MyConsumer extends DefaultConsumer {

    private  Channel channel;

    public MyConsumer(Channel channel) {
        super(channel);
        this.channel = channel;
    }

    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.err.println("-----------consume message----------");
        System.err.println("consumerTag: " + consumerTag);
        System.err.println("envelope: " + envelope);
        System.err.println("properties: " + properties);
        System.err.println("body: " + new String(body));

        // 表示这条消息已处理完，推送下一条信息来。  false ： 代表手动签收
        channel.basicAck(envelope.getDeliveryTag(), false);

    }
}

生产端：

package com.hyf.rabbitmqapi.limit;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;

/**
 * @author xhy
 * @site www.4399.com
 * @company xxx公司
 * @create 2020-03-02 23:45
 */
public class Producer {

    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.59.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exChangeName = "test_qos_exchange";
        String routingKey   = "qos.save";

        String msg = "消费端限流处理。。。。";

        for (int i=0;i<5;i++){
            channel.basicPublish(exChangeName,routingKey,true,null,msg.getBytes());
        }
    }
}

消费端：

package com.hyf.rabbitmqapi.limit;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author xhy
 * @site www.4399.com
 * @company xxx公司
 * @create 2020-03-02 23:49
 */
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.59.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exChangeName = "test_qos_exchange";
        String exChangeType = "topic";
        String queueName    = "test_qos_queue";
        String routingKey   = "qos.#";


        channel.exchangeDeclare(exChangeName,exChangeType,true,false,null);
        channel.queueDeclare(queueName,true,false,false,null);
        channel.queueBind(queueName,exChangeName,routingKey);


        // 限流方式   第一件事就是 autoAck设置为 false
        channel.basicQos(0,1,false);

        /*
        * 参数 b：false  代表手动接收
        * */
        channel.basicConsume(queueName,false,new MyConsumer(channel));
    }
}

在这里插入图片描述

2、消息的ACK与重回队列

消费端手工ACK与NACK

  • 消费端进行消费的时候，如果由于业务异常我们可以进行日志的记录，然后进行补偿
    如果由于服务器宕机等严重问题，那么我们就需要手工进行ACK，保障消费端消费成功！

消费端的重回队列

  • 消费端重回队列是为了对没有处理成功的消息，把消息重新回递给Broker！
    一般我们在实际应用中，都会关闭重回队列，也就是设置为False；因为重回队列消息有很大概率依然会处理失败！

自定义消费者

package com.hyf.rabbitmqapi.ack;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import java.io.IOException;

/**
 * @author xhy
 * @site www.4399.com
 * @company xxx公司
 * @create 2020-03-02 23:32
 */
public class MyConsumer extends DefaultConsumer {

    private  Channel channel;

    public MyConsumer(Channel channel) {
        super(channel);
        this.channel = channel;
    }

    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.err.println("-----------consume message----------");
        System.err.println("body: " + new String(body));
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if((Integer) properties.getHeaders().get("num")==0){
            // 参数3  requeue: true 重回队列 / false  不 重回队列
            channel.basicNack(envelope.getDeliveryTag(),false,true);
        }else{
            channel.basicAck(envelope.getDeliveryTag(), false);
        }
    }
}

生产端：

package com.hyf.rabbitmqapi.ack;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.omg.CORBA.OBJ_ADAPTER;

import java.util.HashMap;
import java.util.Map;

/**
 * @author xhy
 * @site www.4399.com
 * @company xxx公司
 * @create 2020-03-02 23:45
 */
public class Producer {

    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.59.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exChangeName = "test_ack_exchange";
        String routingKey = "ack.save";

        for (int i = 0; i < 5; i++) {
            Map<String, Object> headers = new HashMap<String, Object>();
            headers.put("num",i);
            AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                    .deliveryMode(2)
                    .contentEncoding("UTF-8")
                    .headers(headers)
                    .build();
            String msg = "Hello RabbitMQ ACK Message " + i;
            channel.basicPublish(exChangeName, routingKey, true, properties, msg.getBytes());
        }
    }
}

消费端：

package com.hyf.rabbitmqapi.ack;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author xhy
 * @site www.4399.com
 * @company xxx公司
 * @create 2020-03-02 23:49
 */
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.59.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exChangeName = "test_ack_exchange";
        String exChangeType = "topic";
        String queueName    = "test_ack_queue";
        String routingKey   = "ack.#";


        channel.exchangeDeclare(exChangeName,exChangeType,true,false,null);
        channel.queueDeclare(queueName,true,false,false,null);
        channel.queueBind(queueName,exChangeName,routingKey);

        channel.basicConsume(queueName,false,new MyConsumer(channel));
    }
}

测试结果：
我在自定义消费者中用 0 代替消息未成功处理，其他的处理成功了，就会把它放到尾部，重新处理。
在这里插入图片描述

在这里插入图片描述

3、TTL消息

TTL是Time To Live的缩写，也就是生存时间
RabbitMQ支持消息的过期时间，在消息发送时可以进行指定
RabbitMQ支持队列的过期时间，从消息入队列开始计算，只要超过了队列的超时时间配置，那么消息自动的清除

注意：主要针对消息设置，跟交换机、队列、消费者设置毫无关系

自定义消费者：

package com.hyf.rabbitmqapi.ttl;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import java.io.IOException;

/**
 * @author xhy
 * @site www.4399.com
 * @company xxx公司
 * @create 2020-03-02 23:32
 */
public class MyConsumer extends DefaultConsumer {
    public MyConsumer(Channel channel) {
        super(channel);
    }
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.err.println("-----------consume message----------");
        System.err.println("body: " + new String(body));

        System.out.println("headers get my1 value: "+properties.getHeaders().get("my1"));
    }
}

消费端：

package com.hyf.rabbitmqapi.ttl;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author xhy
 * @site www.4399.com
 * @company xxx公司
 * @create 2020-03-02 23:49
 */
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.59.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exChangeName = "test_ttl_exchange";
        String exChangeType = "topic";
        String queueName    = "test_ttl_queue";
        String routingKey   = "ttl.#";


        channel.exchangeDeclare(exChangeName,exChangeType,true,false,null);
        channel.queueDeclare(queueName,true,false,false,null);
        channel.queueBind(queueName,exChangeName,routingKey);

        channel.basicConsume(queueName,false,new MyConsumer(channel));
    }
}

生产端：

package com.hyf.rabbitmqapi.ttl;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.util.HashMap;
import java.util.Map;

/**
 * @author xhy
 * @site www.4399.com
 * @company xxx公司
 * @create 2020-03-02 23:45
 */
public class Producer {

    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.59.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exChangeName = "test_ttl_exchange";
        String routingKey = "ttl.save";

        Map<String, Object> headers = new HashMap<String, Object>();
        headers.put("my1","1111");
        headers.put("my2","2222");

        for (int i = 0; i < 5; i++) {
            AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                    .deliveryMode(2)
                    .contentEncoding("UTF-8")
                    .expiration("10000")
                    .headers(headers)
                    .build();
            String msg = "Hello RabbitMQ ttl Message " + i;
            channel.basicPublish(exChangeName, routingKey, true, properties, msg.getBytes());
        }

        //5 记得要关闭相关的连接
        channel.close();
        connection.close();

    }
}

10之后，会进行一次清空。
在这里插入图片描述

4、死信队列

死信队列：DLX，Dead-Letter-Exchange

  • 利用DLX，当消息在一个队列中变成死信（dead message）之后，它能被重新publish到另一个Exchange，这个Exchange就是DLX

消息变成死信有以下几种情况

  • 消息被拒绝（basic.reject/basic.nack）并且requeue=false
    消息TTL过期
    队列达到最大长度

死信队列的特点

  • DLX也是一个正常的Exchange，和一般的Exchange没有区别，它能在任何的队列上被指定，实际上就是设置某个队列的属性；
  • 当这个队列中有死信时，RabbitMQ就会自动的将这个消息重新发布到设置的Exchange上去，进而被路由到另一个队列；
  • 可以监听这个队列中消息做相应的处理，这个特性可以弥补RabbitMQ3.0以前支持的immediate参数的功能；

死信队列设置

  • 首先需要设置死信队列的Exchange和Queue，然后进行绑定：
    Exchange：dlx.exchange
    Queue：dlx.queue
    RoutingKey：#
  • 然后我们进行正常声明交换机、队列、绑定，只不过我们需要在队列加上一个参数即可：
    Arguments.put(“x-dead-letter-exchange”,”dlx.exchange”)；
    这样消息在过期、requeue、队列在达到最大长度时，消息就可以直接路由到死信队列！

自定义消费者：

package com.hyf.rabbitmqapi.dlx;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import java.io.IOException;

public class MyConsumer extends DefaultConsumer {


    public MyConsumer(Channel channel) {
        super(channel);
    }

    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.err.println("-----------consume message----------");
        System.err.println("consumerTag: " + consumerTag);
        System.err.println("envelope: " + envelope);
        System.err.println("properties: " + properties);
        System.err.println("body: " + new String(body));
    }


}

生产端：

package com.hyf.rabbitmqapi.dlx;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * @author 小李飞刀
 * @site www.javaxl.com
 * @company
 * @create  2019-11-20 11:38
 */
public class Producer {
    public static void main(String[] args) throws Exception {

        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.59.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exchange = "test_dlx_exchange";
        String routingKey = "dlx.save";

        String msg = "Hello RabbitMQ DLX Message";

        for(int i =0; i<1; i ++){
            AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                    .deliveryMode(2)
                    .contentEncoding("UTF-8")
                    .expiration("10000")
                    .build();
            channel.basicPublish(exchange, routingKey, true, properties, msg.getBytes());
        }
    }
}

消费端：

package com.hyf.rabbitmqapi.dlx;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.util.HashMap;
import java.util.Map;

public class Consumer {
    public static void main(String[] args) throws Exception {


        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.59.128");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        // 这就是一个普通的交换机 和 队列 以及路由
        String exchangeName = "test_dlx_exchange";
        String routingKey = "dlx.#";
        String queueName = "test_dlx_queue";

        channel.exchangeDeclare(exchangeName, "topic", true, false, null);

        Map<String, Object> agruments = new HashMap<String, Object>();
        agruments.put("x-dead-letter-exchange", "dlx.exchange");
        //这个agruments属性，要设置到声明队列上
        channel.queueDeclare(queueName, true, false, false, agruments);
        channel.queueBind(queueName, exchangeName, routingKey);

        //要进行死信队列的声明:
        channel.exchangeDeclare("dlx.exchange", "topic", true, false, null);
        channel.queueDeclare("dlx.queue", true, false, false, null);
        channel.queueBind("dlx.queue", "dlx.exchange", "#");

        channel.basicConsume(queueName, true, new MyConsumer(channel));
    }
}

测试的是：消息TTL过期，进入死信队列
在这里插入图片描述

java男播完
关注
专栏目录
RabbitMQ精讲5：深入RabbitMQ高级特性-限流、ACK、TTL和死信队列
琦彦
04-12 4368
前言 自定义消费者 消息的限流（防止占用内存过多，节点宕机） 消息的ACK与重回队列 TTL消息 死信队列 1. 自定义消费者 1.1 消费端自定义监听 我们一般就在代码中编写while循环，进行consumer.nextDelivery方法进行获取下一条消息，然后进行消费处理！ 但是这种轮训的方式肯定是不好的，代码也比较low。 我们使用自定义的Consumer更加的方便，解耦性...
RabbitMQ的消息模式
大人的博客
03-11 1174
1.简单模式 简单模式是最简单的消息模式，它包含一个生产者、一个消费者和一个队列。生产者向队列里发送消息，消费者从队列中获取消息并消费。 2.工作模式 工作模式是指向多个互相竞争的消费者发送消息的模式，它包含一个生产者、两个消费者和一个队列。两个消费者同时绑定到一个队列上去，当消费者获取消息处理耗时任务时，空闲的消费者从队列中获取并消费消息。 ...
RabbitMQ之消息模式(一)
qq_44847231的博客
12-06 219
文章目录消息100%的投递幂等性概念Confirm确认消息Return返回消息自定义消费者 消息100%的投递 消息如何保障100%的投递成功？ 什么是生产端的可靠性投递？ 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点（Broker）确认应答 完善的消息进行补偿机制 BAT/TMD互联网大厂的解决方案： 消息落库，对消息状态进行打标 消息的延迟投递，做二次确认，回调检查 ...
【rabbitmq】之消费端手动ack
最新发布
weixin_41481354的博客
08-24 65
rabbitmq默认是自动ack，消费端只要消费，mq服务就会删除这条消息。我们想象以下场景：假如我们消费服务出现异常，这条消息被mq服务删除，当我们修复了消费服务，但是无法主动重新消费这条消息，这种业务逻辑显然是不可行的。正常业务逻辑应该是本地业务执行成功，手动ack这条消息。那有的小伙伴就说了，业务执行完毕，手动ack...
RabbitMQ消息模式(二)
what_to的博客
12-07 344
@TOC 1、消费端限流 什么是消费端的限流？ 假设一个场景，首先，我们RabbitMQ服务器有上万条未处理的消息，我们随便打开一个消费者客户端，会出现下面情况： 巨量的消息瞬间全部推送过来，但是我们单个客户端无法同时处理这么多数据！ 消费端限流RabbitMQ提供的解决方案 RabbitMQ提供了一种qos（服务质量保证）功能，即在非自动确认消息的前提下，如果一定数目的消息（通过基于Consum...
【Rabbitmq的消息模型】
m0_50116974的博客
08-06 1425
如上模型，如果是循环的分发方式，Consumer-1一次性被分到的消息为1，3，5号消息，Consumer-2一次性被分到的消息为2，4，6号消息。如果开启消息自动确认，那么一旦MQ把消息发送给消费者，那么该消息就会立即标记为删除。例如，有编号1-10的消息在MQ中，同时存在两个消费者，则消费者A分到的消息为1，3，5，7，9，消费者B分到的消息为2，4，6，8，10。的分发消息的方式，消费能力强的消费者就会被分到更多的消息，消费能力弱的消费者就会被分到更少的消息，该方式需要作额外设置。
消息模式 之 消费端限流、消息的ACK与重回队列、TTL消息、死信队列
qq_44641053的博客
12-07 304
消息模式 之 消费端限流、消息的ACK与重回队列、TTL消息、死信队列消费端限流消息的ACK 与 重回队列TTL 消息死信队列 本章知识： 1、消费端限流 2、消息的ACK与重回队列 3、TTL消息 4、死信队列 消费端限流 相关资料： 消息模式 之 消息100%投递、幂等性、Confirm确认消息、Return返回消息、自定义消费者 什么是消费端的限流？ 假设一个场景，首先，我们 RabbitM...
RabbitMQ 消费端限流、重回队列、TTL与死信队列
贵在坚持
09-01 606
RabbitMQ 为了保证消息投递的可靠性，其提供了很多相关的机制来应对各种问题的发生
RabbitMQ消费限流、重回队列、TTL和死信队列
阳某的博客
12-07 983
目录消费端限流消息的ACK与重回队列TTL消息死信队列 消费端限流 假设一个场景，由于我们的消费端突然全部不可用了，导致 rabbitMQ 服务器上有上万条未处理的消息，这时候如果没做任何现在，随便开启一个消费端客户端，就会导致巨量的消息瞬间全部推送过来，但是我们单个客户端无法同时处理这么多的数据，就会导致消费端变得巨卡，有可能直接崩溃不可用了 prefetchSize：0 prefetchCo...
RabbitMQ消息模式
weixin_43654482的博客
02-28 371
文章目录消息如何保证100%的投递消息100%的投递幂等性概念幂等性是什么Confirm确认消息理解Confirm消息确认机制如何实现Confirm确认消息Return返回消息自定义消费者 消息如何保证100%的投递 消息100%的投递 消息如何保障100%的投递成功 什么是生产端的可靠性投递？ 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点（Broker）确认应答 完善的消息进行...
RabbitMQ消息模式一
only老K的博客 qq:1025271924
03-03 365
博客内容消息如何100%投递幂等性概念Confirm确认消息Return返回信息自定义消费 消息如何100%投递 幂等性概念 Confirm确认消息 Return返回信息 自定义消费
RabbitMQ消息模式（消息100%的投递、幂等性概念）
weixin_42687829的博客
02-15 406
1、什么是生产端的可靠性投递 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点（Broker）确认应答 完善的消息进行补偿机制 2、BAT/TMD互联网大厂解决生产端的可靠性投递的方案 消息落库，对消息状态进行打标，流程图如下： 消息的延迟投递，做二次确认，回调检查，流程图如下： 3、幂等性是什么 可以参考数据库乐观锁机制，比如执行一条更新库存的 SQL 语句，在...
RabbitMQ消息模式（消息的ACK与重回队列）
weixin_42687829的博客
02-15 1075
消费端手工ACK与NACK 消费端进行消费的时候，如果由于业务异常我们可以进行日志的记录，然后进行补偿；如果由于服务器宕机等严重问题，那么我们就需要手工进行ACK，保障消费端消费成功，比如我们在消费端调用第三方接口，但这个第三方接口出现了问题导致接口调用失败，这时我们就要手动签收，使消息重回队列 消费端的重回队列 消费端重回队列是为了对没有处理成功的消息，把消息重新回递给Broker；一般我...
RabbitMQ消息模式2
xfz610614的博客
03-03 188
文章目录一、消费端限流什么是消费端的限流？消费端限流RabbitMQ提供的解决方案4示例代码二、消息的ACK与重回队列消费端手工ACK与NACK消费端的重回队列示例代码三、TTL消息TTL简介示例代码四、死信队列死信队列：DLX，Dead-Letter-Exchange消息变成死信有以下几种情况死信队列的特点死信队列设置示例代码 一、消费端限流 什么是消费端的限流？ 假设一个场景，首先，我们Rab...
10 RabbitMQ 高级特性ConsumerAck、TTL、DLX
weixin_68930048的博客
12-11 182
RabbitMQ 高级特性ConsumerAck、TTL、DLX
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值