RabbitMQ（五）

最新推荐文章于 2024-06-16 23:12:58 发布
最新推荐文章于 2024-06-16 23:12:58 发布
阅读量1.3k 收藏 29
点赞数 16
分类专栏： rabbitMQ 文章标签： rabbitmq 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43869269/article/details/137066635
版权

死信队列和延迟队列

死信队列

死信的概念

先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。

应用场景:为了保证订单业务的消息数据不丢失，需要使用到RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中.还有比如说: 用户在商城下单成功并点击去支付后在指定时间未支付时自动失效。

死信消息是RabbitMQ为我们做的一层保证，其实我们也可以不使用死信队列，而是在消息消费异常时，将消息主动投递到另一个交换机中，或者将消息重新投递到一个队列然后设置过期时间，来进行延时消费。

死信的来源

  • 消息在队列的存活时间超过设置的生存时间（TTL)时间。
  • 消息队列的消息数量已经超过最大队列长度。
  • 消息被拒绝，使用 channel.basicNack 或 channel.basicReject ，并且此时requeue 属性被设置为false。

在这里插入图片描述

如何配置死信队列

配置死信队列，大概可以分为以下步骤：

  1. 配置业务队列，绑定到业务交换机上
  2. 为业务队列配置死信交换机和路由key
  3. 为死信交换机配置死信队列

注意：

  • 一般情况下会为每一个业务队列都配置一个相对应的死信队列，也可以多个业务队列共用一个死信队列。要注意的是业务队列和死信队列的交换机要区分开。

  • 并不是直接声明一个公共的死信队列，然后所有死信消息就自己跑到死信队列里去了，而是为每个需要使用死信的业务队列配置一个死信交换机，这里同一个项目的死信交换机可以共用一个，然后为每个业务队列分配一个单独的路由key

  • 重要的业务一般都是建议单独配置一条死信队列

创建config类
@Configuration
public class RabbitMQConfig {
 
    public static final String BUSINESS_EXCHANGE_NAME = "business.exchange";
    public static final String BUSINESS_QUEUEA_NAME = "business.queuea";
    public static final String BUSINESS_QUEUEB_NAME = "business.queueb";
    public static final String DEAD_LETTER_EXCHANGE = "deadletter.exchange";
    public static final String DEAD_LETTER_QUEUEA_ROUTING_KEY = "deadletter.queuea.routingkey";
    public static final String DEAD_LETTER_QUEUEB_ROUTING_KEY = "deadletter.queueb.routingkey";
    public static final String DEAD_LETTER_QUEUEA_NAME = "deadletter.queuea";
    public static final String DEAD_LETTER_QUEUEB_NAME = "deadletter.queueb";
 
    // 声明业务Exchange
    @Bean("businessExchange")
    public FanoutExchange businessExchange(){
        return new FanoutExchange(BUSINESS_EXCHANGE_NAME);
    }
 
    // 声明死信Exchange
    @Bean("deadLetterExchange")
    public DirectExchange deadLetterExchange(){
        return new DirectExchange(DEAD_LETTER_EXCHANGE);
    }
 
    // 声明业务队列A
    @Bean("businessQueueA")
    public Queue businessQueueA(){
        Map<String, Object> args = new HashMap<>(2);
	// x-dead-letter-exchange    这里声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE);
	// x-dead-letter-routing-key  这里声明当前队列的死信路由key
        args.put("x-dead-letter-routing-key", DEAD_LETTER_QUEUEA_ROUTING_KEY);
        return QueueBuilder.durable(BUSINESS_QUEUEA_NAME).withArguments(args).build();
    }
 
    // 声明业务队列B
    @Bean("businessQueueB")
    public Queue businessQueueB(){
        Map<String, Object> args = new HashMap<>(2);
	// x-dead-letter-exchange    这里声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE);
	// x-dead-letter-routing-key  这里声明当前队列的死信路由key
        args.put("x-dead-letter-routing-key", DEAD_LETTER_QUEUEB_ROUTING_KEY);
        return QueueBuilder.durable(BUSINESS_QUEUEB_NAME).withArguments(args).build();
    }
 
    // 声明死信队列A
    @Bean("deadLetterQueueA")
    public Queue deadLetterQueueA(){
        return new Queue(DEAD_LETTER_QUEUEA_NAME);
    }
 
    // 声明死信队列B
    @Bean("deadLetterQueueB")
    public Queue deadLetterQueueB(){
        return new Queue(DEAD_LETTER_QUEUEB_NAME);
    }
 
    // 声明业务队列A绑定关系
    @Bean
    public Binding businessBindingA(@Qualifier("businessQueueA") Queue queue,
                                    @Qualifier("businessExchange") FanoutExchange exchange){
        return BindingBuilder.bind(queue).to(exchange);
    }
 
    // 声明业务队列B绑定关系
    @Bean
    public Binding businessBindingB(@Qualifier("businessQueueB") Queue queue,
                                    @Qualifier("businessExchange") FanoutExchange exchange){
        return BindingBuilder.bind(queue).to(exchange);
    }
 
    // 声明死信队列A绑定关系
    @Bean
    public Binding deadLetterBindingA(@Qualifier("deadLetterQueueA") Queue queue,
                                    @Qualifier("deadLetterExchange") DirectExchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(DEAD_LETTER_QUEUEA_ROUTING_KEY);
    }
 
    // 声明死信队列B绑定关系
    @Bean
    public Binding deadLetterBindingB(@Qualifier("deadLetterQueueB") Queue queue,
                                      @Qualifier("deadLetterExchange") DirectExchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(DEAD_LETTER_QUEUEB_ROUTING_KEY);
    }
}
配置文件

pom文件引入spring-boot-starter-amqp 和 spring-boot-starter-web 的依赖

spring:
  rabbitmq:
    host: localhost
    password: guest
    username: guest
    listener:
      type: simple
      simple:
      	  # 监听器抛出异常而拒绝的消息是否被重新放回队列。默认值为true（重新放回队列）。
          default-requeue-rejected: false 
          # 消息确认方式
          # none意味着没有任何的应答会被发送。
		  # manual意味着监听者必须通过调用Channel.basicAck()来告知所有的消息。
		  # auto意味着容器会自动应答，除非MessageListener抛出异常，这是默认配置方式。
          acknowledge-mode: manual
业务队列消费者代码
@Slf4j
@Component
public class BusinessMessageReceiver {
 
    @RabbitListener(queues = BUSINESS_QUEUEA_NAME)
    public void receiveA(Message message, Channel channel) throws IOException {
        String msg = new String(message.getBody());
        log.info("收到业务消息A：{}", msg);
        boolean ack = true;
        Exception exception = null;
        try {
            if (msg.contains("deadletter")){
                throw new RuntimeException("dead letter exception");
            }
        } catch (Exception e){
            ack = false;
            exception = e;
        }
        if (!ack){
            log.error("消息消费发生异常，error msg:{}", exception.getMessage(), exception);
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
        } else {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }
    }
 
    @RabbitListener(queues = BUSINESS_QUEUEB_NAME)
    public void receiveB(Message message, Channel channel) throws IOException {
        System.out.println("收到业务消息B：" + new String(message.getBody()));
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}
死信队列消费者代码
@Component
public class DeadLetterMessageReceiver {
 
 
    @RabbitListener(queues = DEAD_LETTER_QUEUEA_NAME)
    public void receiveA(Message message, Channel channel) throws IOException {
        System.out.println("收到死信消息A：" + new String(message.getBody()));
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
 
    @RabbitListener(queues = DEAD_LETTER_QUEUEB_NAME)
    public void receiveB(Message message, Channel channel) throws IOException {
        System.out.println("收到死信消息B：" + new String(message.getBody()));
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

延迟队列

延迟队列概念

延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。 延迟队列机制和死信 TTL过期相似 , 但延迟队列对时间的控制较灵活, 应用应用场景广泛。

延迟队列使用场景

  1. 订单在十分钟之内未支付则自动取消
  2. 新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。
  3. 用户注册成功后，如果三天内没有登陆则进行短信提醒。
  4. 用户发起退款，如果三天内没有得到处理则通知相关运营人员。
  5. 预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议

RabbitMQ 中的TTL

TTL 是什么呢？TTL是RabbitMQ中一个消息或者队列的属性，表明一条消息或者该队列中的所有消息的最大存活时间， 单位是毫秒。换句话说，如果一条消息设置了TTL属性或者进入了设置TTL属性的队列，那么这条消息如果在TTL设置的时间内没有被消费，则会成为"死信"。如果同时配置了队列的TTL和消息的TTL，那么较小的那个值将会被使用，有两种方式设置TTL。

RabbitMQ TTL 配置

  • RabbitMQ可以针对Queue和Message设置x-message-ttl，来控制消息的生存时间，如果超时则消息变为dead letter
  • RabbitMQ的Queue可以配置x-dead-letter-exchange和x-dead-letter-routing-key（可选）两个参数，用来控制队列内出现的dead letter，dead letter到达死信队列交换机后则按照这两个参数重新路由。
1、队列设置TTL

在创建队列的时候设置队列的x-message-ttl属性

@Bean
public Queue queue() {
	Map<String, Object> args = new HashMap<>(2);
	args.put("x-message-ttl", 30000);// 设置超时时间30s
	return QueueBuilder.durable(TAXI_OVER_QUEUE).withArguments(args).build();
}
2、消息设置TTL

另一种方式便是针对每条消息设置TTL，代码如下：

AMQP.BasicProperties.Builder builder = new AMQP.BasicProperties.Builder();
builder.expiration("6000");// 当前消息TTL为60s
AMQP.BasicProperties properties = builder.build();
channel.basicPublish(exchangeName, routingKey, mandatory, properties, "msg body".getBytes());
3、两者区别

如果设置了队列的TTL属性，那么一旦消息过期，就会被队列丢弃(如果配置了死信队列被丢到死信队 列中)，而第二种方式，消息即使过期，也不一定会被马上丢弃，因为消息是否过期是在即将投递到消费者之前判定的，如果当前队列有严重的消息积压情况，则已过期的消息也许还能存活较长时间；另外，还需 要注意的一点是，如果不设置TTL，表示消息永远不会过期，如果将TTL设置为0，则表示除非此时可以 直接投递该消息到消费者，否则该消息将会被丢弃。

实现延时队列

我们现在知道了死信队列、TTL，只要把二者相融合，就能实现延时队列了。

延时队列，不就是想要消息延迟多久被处理吗，TTL则刚好能让消息在延迟多久之后成为死信，另一方面，成为死信的消息都会被投递到死信队列里，这样只需要消费者一直消费死信队列里的消息就万事大吉了，因为里面的消息都是希望被立即处理的消息。

在这里插入图片描述

配置类文件代码
@Configuration 
public class TtlQueueConfig { 
    public static final String X_EXCHANGE = "X"; 
    public static final String QUEUE_A = "QA"; 
    public static final String QUEUE_B = "QB"; 
 
    public static final String Y_DEAD_LETTER_EXCHANGE = "Y"; 
    public static final String DEAD_LETTER_QUEUE = "QD"; 
 
    // 声明xExchange 
    @Bean("xExchange") 
    public DirectExchange xExchange(){ 
        return new DirectExchange(X_EXCHANGE); 
    } 
    // 声明yExchange 
    @Bean("yExchange") 
    public DirectExchange yExchange(){ 
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE); 
    } 
 
    //声明队列A ttl为10s并绑定到对应的死信交换机 
    @Bean("queueA") 
    public Queue queueA(){ 
        Map<String, Object> args = new HashMap<>(3); 
        //声明当前队列绑定的死信交换机 
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE); 
        //声明当前队列的死信路由key 
        args.put("x-dead-letter-routing-key", "YD"); 
        //声明队列的TTL 
        args.put("x-message-ttl", 10000); // 如果需要生产者来声明TTL则注释这行
        return QueueBuilder.durable(QUEUE_A).withArguments(args).build(); 
    } 
    
    // 声明队列A绑定X交换机 
    @Bean 
    public Binding queueaBindingX(@Qualifier("queueA") Queue queueA, 
                                  @Qualifier("xExchange") DirectExchange xExchange){ 
        return BindingBuilder.bind(queueA).to(xExchange).with("XA"); 
    } 
 
    //声明队列B ttl为40s并绑定到对应的死信交换机 
    @Bean("queueB") 
    public Queue queueB(){ 
        Map<String, Object> args = new HashMap<>(3); 
        //声明当前队列绑定的死信交换机 
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE); 
        //声明当前队列的死信路由key 
        args.put("x-dead-letter-routing-key", "YD"); 
        //声明队列的TTL 
        args.put("x-message-ttl", 40000); 
        return QueueBuilder.durable(QUEUE_B).withArguments(args).build(); 
    } 
    
    //声明队列B绑定X交换机 
    @Bean 
    public Binding queuebBindingX(@Qualifier("queueB") Queue queue1B, 
                                  @Qualifier("xExchange") DirectExchange xExchange){ 
        return BindingBuilder.bind(queue1B).to(xExchange).with("XB"); 
    } 
 
 
    //声明死信队列QD 
    @Bean("queueD") 
    public Queue queueD(){ 
        return new Queue(DEAD_LETTER_QUEUE); 
    } 
    //声明死信队列QD绑定关系 
    @Bean 
    public Binding deadLetterBindingQAD(@Qualifier("queueD") Queue queueD, 
                                        @Qualifier("yExchange") DirectExchange yExchange){ 
        return BindingBuilder.bind(queueD).to(yExchange).with("YD"); 
    } 
}
生产者代码
@GetMapping("sendExpirationMsg/{message}/{ttlTime}") 
public void sendMsg(@PathVariable String message,@PathVariable String ttlTime) { 
    // 生产者设置延时时间方式，需要注释配置代码中第30行
    rabbitTemplate.convertAndSend("X", "XC", message, correlationData ->{ 
        correlationData.getMessageProperties().setExpiration(ttlTime); 
        return correlationData; 
    }); 
    log.info("当前时间：{},发送一条时长{}毫秒TTL信息给队列C:{}", new Date(),ttlTime, message); 
}

以上代码看起来似乎没什么问题，但是在最开始的时候，就介绍过如果使用在消息属性上设置TTL的方式，消息可能并不会按时“死亡“，因为RabbitMQ只会检查第一个消息是否过期，如果过期则丢到死信队列， 如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。

Rabbitmq 插件实现延迟队列

上述问题的解决方式是使用Rabbitmq 插件实现延迟队列（https://www.rabbitmq.com/community-plugins.html）。下载rabbitmq_delayed_message_exchange插件，然后解压放置到RabbitMQ的插件目录。

在这里插入图片描述

安装插件后只要将配置文件中的交换机改为延迟交换机

配置类文件代码
@Configuration 
public class DelayedQueueConfig { 
    public static final String DELAYED_QUEUE_NAME = "delayed.queue"; 
    public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange"; 
    public static final String DELAYED_ROUTING_KEY = "delayed.routingkey"; 
 
    @Bean 
    public Queue delayedQueue() { 
        return new Queue(DELAYED_QUEUE_NAME); 
    } 
    //自定义交换机 我们在这里定义的是一个延迟交换机 
    @Bean 
    public CustomExchange delayedExchange() { 
        Map<String, Object> args = new HashMap<>(); 
        //自定义交换机的类型 
        args.put("x-delayed-type", "direct"); 
       return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false, 
args); 
    } 
    @Bean 
    public Binding bindingDelayedQueue(@Qualifier("delayedQueue") Queue queue, 
                                 @Qualifier("delayedExchange") CustomExchange 
delayedExchange) { 
        return 
BindingBuilder.bind(queue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs(); 
    } 
}
生产者代码
public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange"; 
public static final String DELAYED_ROUTING_KEY = "delayed.routingkey"; 
 
@GetMapping("sendDelayMsg/{message}/{delayTime}") 
public void sendMsg(@PathVariable String message,@PathVariable Integer delayTime) { 
    rabbitTemplate.convertAndSend(DELAYED_EXCHANGE_NAME, DELAYED_ROUTING_KEY, message, 
correlationData ->{ 
        correlationData.getMessageProperties().setDelay(delayTime); 
        return correlationData; 
}); 
log.info(" 当 前 时 间 ： {}, 发送一条延迟{}毫秒的信息给队列 delayed.queue:{}", new 
Date(),delayTime, message); 
}
陈淀夏Coder
关注
  • 16
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitMQ五种消息模型
weixin_45099622的博客
08-06 4261
rabbitMQ提供了6种消息模型，但是第六种其实是RPC(远程过程调用)，并不是MQ，所以是5种模式。 其中5种消息模型分为两类： 第一种和第二种是点对点 第三，四，五种是一对多，都属于订阅模型，只不过是进行路由的方式不同。 第六种RPC远程调用也可不算做模式 本文参照网站：https://www.rabbitmq.com/getstarted.html 一，一对一简单模式 概念 生产者将消息发送到“ hello”队列。使用者从该队列接收消息。 图解 “ P”是我们的生产者 “
rabbitmq五种工作模式应用场景
GY4396的博客
05-07 1550
** rabbitmq的五种工作模式 ** 简单模式 1个生产者将消息交给默认的交换机(AMQP default) 2 交换机获取消息后交给绑定这个生产者的队列(关系是通过队列名称完成) 3 监听当前队列的消费者获取消息,执行消费逻辑 应用场景:短信,聊天 场景：有一个oa系统，用户通过接收手机验证码进行注册，页面上点击获取验证码后，将验证码放到消息队列，然后短信服务从队列中获取到验证码，并发送给用户 工作模式(轮询) 1 生产者将消息交个交换机 2 交换机交给绑定的队列 3 队列由多个消费者同时监听,
rabbitmq五种消息模型
qq_38905668的博客
04-25 694
交换机负责接收消息并根据消息的路由键将消息路由到一个或多个队列。消息持久化是RabbitMQ中的另一个重要特性，它确保消息、队列和交换机在服务器重启后依然存在。- 适用于复杂的消息路由场景，如根据不同的话题或事件类型路由消息。- 消息发送到交换机，交换机将消息发送到所有绑定的队列。- 生产者将消息发送到队列，消费者从队列中获取消息。- 每个消费者有自己的队列，都能接收到所有消息。- 适用于需要将不同消息路由到不同队列的场景。- 队列是存储消息的缓冲区，可以缓存消息。- 队列可以使用通配符订阅感兴趣的消息。
RabbitMQ五种消息模式
qq_43390704的博客
12-21 3456
1，简单模式 工作的流程: 当生产者生产消息后,将消息发往队列. 当队列中有消息时,消费者会实时的监听队列中的消息.如果有消息则会执行消息 2，工作模式 默认的传统队列是为均摊消费，存在不公平性；如果每个消费者速度不一样的情况下，均摊消费是不公平的，应该是能者多劳。 采用工作队列 在通道中只需要设置basicQos为1即可，表示MQ服务器每次只会给消费者推送1条消息必须手动ack确认之后才会继续发送。channel.basicQos(1); public class ...
rabbitmq 五种模式
Jornici的博客
02-05 2012
1、简单模式 2、工作队列模式 3、发布订阅模式 4、路由模式 5、topic通配符模式
中间件_RabbitMQ五种消息模型
故常无，欲以观其妙；常有，欲以观其徼；
05-18 3288
RabbitMQ 提供了5种常用消息模型。但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。
RabbitMQ五种工作模式
热门推荐
weixin_41882200的博客
05-21 1万+
RabbitMQ五种工作模式 1、简单队列 一个生产者对应一个消费者！！ 2、work 模式 一个生产者对应多个消费者，但是一条消息只能有一个消费者获得消息！！！ 轮询分发就是将消息队列中的消息，依次发送给所有消费者。一个消息只能被一个消费者获取。 3、发布/订阅模式 一个消费者将消息首先发送到交换器，交换器绑定到多个队列，然后被监听该队列的消费者所接收并消费。 ps:X表示交换器，在RabbitMQ中，交换器主要有四种类型:direct、fanout、topic、headers，这里的交换器是 fa
RabbitMQ五大模式轻松理解
风影浪子
06-13 7290
简要概括RabbitMQ工作模式：1、简单模式 HelloWorld 2、工作队列模式 Work Queue 3、发布订阅模式 Publish/subscribe 4、路由模式 Routing 5、通配符模式 Topic
RabbitMQ 五种基本模式demo（Java版本）
Ember_Sky
08-14 623
RabbitMQ 五种基本模式demo（Java版本） 代码非本人所写，只是将代码稍微做了些改动，在自己的环境中运行起来了，侵删 五种模式都需要引用的文件 ConnectionUtils.java 创建并设置factory的基本属性，并返回新创建的connection package test.rabbitmq.rabbitmq.mq5s; import com.rabbitmq.client.*; import java.io.IOException; import java.util.concur
03RabbitMq-SpringBoot整合RabbitMq五种模式
niannujiao6的博客
02-08 1215
一、Fanout模式 生产者 1.导入amqp协议依赖 <!--rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency>
RabbitMQ五种模式
07-01
没有1个积分的私聊我哈，我给你免费 消息队列中间件（简称消息中间件）是指利用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在...
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
rabbitMq 5种消息模型测试代码
07-18
rabbitMq 5种消息模型测试代码
RabbitMQ.xmind
11-12
RabbitMQ知识体系的脑图结构。 主要包括概念、MQ的分类、主流的MQ产品、RabbitMQ的五种消息模型、死信队列、延时队列，如何使用RabbitMQ及关于RabbitMQ的面试题。
sprngboot整合 rabbitMQ
11-15
rabbitMq 五种模式 简单模式：一个生产者，一个消费者 工作模式：一个生产者，多个消费者 发布订阅模：又叫无路由键交换机模式，队列绑定到交换机，当发送消息到交换机时，绑定到该交换机的队列都会监听到 Direct...
RabbitMq 延迟队列
最新发布
WindwirdBird的博客
06-16 125
延迟消息队列在我们工作中使用的场景特别多，比如超时未支付取消订单，异步业务时间有时间间隔，等等，今天我们就来聊一聊使用消息延迟队列。
消息队列-RabbitMQ-延时队列实现
Nanki_的博客
06-16 155
DLX,全称为Dead-Letter-Exchange,死信交换机，死信邮箱。当消息在一个队列中变成死信之后，它能重新发送到另外一个交换器中，这个交换器就是DLX，绑定DLX的队列就称为死信队列。● 消息被拒(Basic.Reject/Basic.Nack)且requeue = false。● 消息TTL（消息的存活时间）过期。● 队列满了，无法再添加。
RabbitMQ消息的可靠传输和防止消息丢失
lw_jack的博客
06-16 290
import org} }} }} }@Bean@Bean@Bean通过以上步骤，你可以在Spring Cloud项目中使用RabbitMQ并确保消息不会丢失。消息和队列的持久化：确保消息和队列都是持久化的。发布确认。
【RabbitMQ】初识 RabbitMQ
书山有路，学海无涯。记录成长，追逐梦想
06-13 1036
RabbitMQ 是目前应用相当广泛的消息中间件（其他同类的消息处理中间件有 ActiveMQ、Kafka 等）。在企业级应用、微服务应用中，RabbitMQ 担当着十分重要的角色。例如，在业务服务模块中解耦、异步通信、高并发限流、超时业务、数据延迟处理 等都可以使用 RabbitMQ。
rabbitmq五种消息类型
08-29
RabbitMQ支持五种消息类型： 1. 简单消息：最基本的消息类型，只包含消息体。 2. 工作队列：多个消费者从同一个队列中接收消息，每个消息只被一个消费者处理。 3. 发布/订阅：一个生产者发送消息到多个消费者，每...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值