【RabbitMQ】RabbitMQ 消息的可靠性 —— 生产者和消费者消息的确认,消息的持久化以及消费失败的重试机制

这篇具有很好参考价值的文章主要介绍了【RabbitMQ】RabbitMQ 消息的可靠性 —— 生产者和消费者消息的确认,消息的持久化以及消费失败的重试机制。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。


前言:消息的可靠性问题

在现代分布式应用程序中,消息队列扮演了至关重要的角色,允许系统中的各个组件之间进行异步通信。这种通信模式提供了高度的灵活性和可伸缩性,但也引入了一系列的挑战,其中最重要的之一是消息的可靠性。

首先让我们来了解一下,在消息队列中,消息从生产者发送到交换机,再到队列,最后到消费者,有哪些情况会导致消息的丢失?

  • 发送时丢失:

    • 生产者发送的消息未送达交换机;
    • 消息到达交换机后未到达队列;
  • MQ 宕机,队列中的消息会丢失;

  • 消费者接收到消息后未消费就宕机了。

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq确保消息队列的可靠性是分布式系统中不可或缺的一部分,因此我们需要采取措施来应对这些挑战。为了解决上述消息可靠性问题,RabbitMQ提供了一系列的机制和最佳实践,以确保消息在整个传递过程中得到妥善处理和保护。

本文将深入探讨如何应对这些挑战,介绍消息队列中的关键概念,并详细讨论 RabbitMQ 提供的解决方案,包括生产者消息的确认、消息的持久化、消费者消息的确认以及消息消费失败的重试机制。这些措施将有助于确保消息队列在应用程序中的可靠性和稳定性。

一、生产者消息的确认

1.1 生产者确认机制

RabbitMQ 提供了 publisher confirm 机制,这是一种用于解决消息发送过程中可能出现的丢失问题的机制。当消息发送到 RabbitMQ 后,系统会返回一个结果给消息的发送者,以指示消息的处理状态。这个结果有两种可能的值:

  • publisher-confirm,发送者确认:

    • 消息成功投递到交换机,系统返回 ack(确认)。
    • 消息未能成功投递到交换机,系统返回 nack(未确认)。
  • publisher-return,发送者回执:

    • 消息成功投递到交换机,但是没有成功路由到队列,系统返回 ACK,同时提供路由失败的原因。

这个确认机制的目的是确保消息在发送到消息队列后,发送者能够获得有关消息处理状态的明确反馈,从而可以采取适当的措施,例如重发消息或记录失败信息。

需要注意的是,为了实现这一机制,需要为每条消息设置一个全局唯一的标识符,以便区分不同的消息,避免在确认过程中出现冲突。

例如下图所示:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq

确保消息生产者能够获得有关消息状态的反馈是确保消息可靠性的关键一步,因为它有助于解决消息可能在发送期间丢失的问题。这是构建可靠的消息队列系统中的重要组成部分。

1.2 实现生产者消息的确认

下面将通过一个 Java 的 Spring Boot 项目来演示如何实现生产者消息的确认。这个项目的结构如下:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
这个项目有两个模块,其中 consumer 负责对消息的消费,而 publisher 负责发送消息。下面是在 publisher 模块中实现消息确认的具体步骤:

  1. publisher 服务中的 application.yml 文件中添加如下配置:
spring:
  rabbitmq:
    publisher-confirm-type: correlated
    publisher-returns: true
    template:
      mandatory: true

对这个配置的详细说明:

  • publish-confirm-type:开启 publisher-confirm 功能,这里支持两种类型:
    • simple:同步等待 confirm 结果,直到超时;
    • correlated:异步回调,定义ConfirmCallback,MQ返回结果时会回调这个 ConfirmCallback
  • publish-returns:开启 publish-return 功能,同样是基于 callback 机制,不过是定义 ReturnCallback
  • template.mandatory:定义消息路由失败时的策略。true,则调用 ReturnCallbackfalse,则直接丢弃消息。
  1. RabbitTemplate 配置 ReturnCallback
@Configuration
@Slf4j
public class CommonConfig implements ApplicationContextAware {

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        // 获取 RabbitTemplate 对象
        RabbitTemplate rabbitTemplate = applicationContext.getBean(RabbitTemplate.class);
        // 配置 ReturnCallBack
        rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
            // 记录日志
            log.error("消息发送到队列失败,响应码:{},失败原因:{},交换机:{},路由 Key:{},消息:{}",
                    replyCode, replyText, exchange, routingKey, message.toString());
            // 如果有需要,接下来可以重发消息,或者执行其他通知逻辑
        });
    }
}

由于每个 RabbitTemplate 只能配置一个 ReturnCallback,并且 RabbitTemplate 在Spring 中是一个全局对象,因此需要在项目启动过程中配置。

上述代码就是一个 Spring Boot 的配置类,通常用于在项目启动时配置一些全局的设置。在这个配置类中,实现了 ApplicationContextAware 接口,用于获取 Spring 应用上下文(ApplicationContext)对象。主要作用是配置 RabbitMQ 的 ReturnCallback,以处理消息发送到队列失败的情况。

  1. 发送消息,指定消息的 ID以及消息的 ConfirmCallback
@Test
public void testSendMessage2SimpleQueue() throws InterruptedException {
    String routingKey = "simple.test";
    // 1. 准备消息
    String message = "hello, spring amqp!";
    // 2. 准备 CorrelationDate
    // 2.1.消息ID
    CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
    // 2.2.准备 ConfirmCallback
    correlationData.getFuture().addCallback(confirm -> {
        // 消息发送成功
        // 判断结果
        if(confirm != null && confirm.isAck()){
            // ACK
            log.debug("消息投递到交换机成功!消息 ID: {}", correlationData.getId());
        } else {
            // NACK
            log.error("消息投递到交换机失败!消息 ID: {}", correlationData.getId());
        }
    }, throwable -> {
        // 发送失败
        // 记录日志
        log.error("消息发送失败!", throwable);
        // 重发消息...
    });
    // 3. 发送消息
    rabbitTemplate.convertAndSend("amq.topic", routingKey, message, correlationData);
}

这是一个 Java 测试方法,用于发送消息到 RabbitMQ 队列,并指定消息的 ID 以及 ConfirmCallback(确认回调)。以下是对这段代码的详细解释:

  1. testSendMessage2SimpleQueue: 这是一个测试方法,用于演示如何发送消息到名为 “simple.test” 的 RabbitMQ 队列。

  2. String routingKey = "simple.test";: 定义了消息的路由键,这是用于将消息路由到特定队列的关键。

  3. 准备消息:将要发送的消息内容存储在 message 变量中。

  4. 准备 CorrelationData

    • CorrelationData 用于关联消息的 ID。
    • 使用 UUID.randomUUID().toString() 生成一个全局唯一的消息 ID。
  5. 准备 ConfirmCallback

    • CorrelationData.getFuture().addCallback(confirm -> { ... }, throwable -> { ... }) 定义了 ConfirmCallback,该回调会在消息的发送状态发生变化时触发。
    • ConfirmCallback 中,判断了消息是否成功投递到交换机:
      • 如果 confirm 不为 null 且 confirm.isAck()true,则表示消息成功到达交换机,记录一条成功的日志。
      • 否则,如果消息未成功到达交换机,则记录一条失败的日志。
    • throwable 回调中,处理了发送失败的情况,记录了失败的日志,可以在这里添加重发消息或其他失败处理逻辑。
  6. 发送消息:

    • 使用 rabbitTemplate.convertAndSend("amq.topic", routingKey, message, correlationData); 发送消息到 RabbitMQ。
    • 参数包括交换机名称、路由键、消息内容和关联的 CorrelationData

这段代码演示了如何发送消息并在消息状态变化时使用 ConfirmCallback 处理消息的确认情况。通过关联消息 ID 和 ConfirmCallback,可以确保消息的可靠性,根据确认情况采取适当的措施。

1.3 验证生产者消息的确认

下面通过可以运行上述测试代码来查看生产者的消息确认情况:

  1. 正常发送消息

直接执行测试方法,可以发现消息成功投递到交换机:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq

  1. 发送消息失败

此时,将交换机的名称改成一个错误不存在的:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq然后再次执行测试方法:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
发现此时消息投递到交换机失败,说明此时返回的是 NACK,并且提示了错误的原因是找不到名为 aamq.topic的交换机。

  1. 成功发送消息,但是路由失败

此时将交换机的名称修改回来,但是将路由 Key 修改成错误的:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
然后执行测试方法:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq通过输出的日志可以发现,消息成功投递到了交换机,但是由于路由 Key 不正确,导致路由不到 simple,queue,从而触发调用了上文配置的ReturnCallback

二、消息的持久化

在通过上文的生产者消息确认机制之后,确保了消息能够正确的发送到队列中,但是这并不意味着消息就安全了。因为 RabbitMQ 默认是内存储存的,如果出现了 RabbitMQ 宕机的情况,那么此时队列中的消息还是会丢失。要确保消息能够真正的安全,我们还需要实现消息的持久化。

2.1 演示消息的丢失

例如,现在 simple.queue 中存在 3 条消息:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
这些消息是通过 RabbitMQ 自带的交换机 amp.topic 进行转发的:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq

然后我们重启一下 RabbitMQ 服务,看一看队列中的消息是否还存在:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
此时我们重新服务 RabbitMQ 的控制台,发现连 simple.queue 都消失了:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
但是RabbitMQ自带的 amp.topic 交换机还存在:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq 说明,这个交换机是持久化储存的,如果仔细观察可以发现,这些所有的交换机的 Features 都带有一个 D ,即持久化 Durable。

因此要让我们自己创建的队列或者交换机也能持久存在,就可以否选上 Durable 这个选项:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq

2.2 声明持久化的交换机和队列

通过上文我们知道了可以在 RabbitMQ 的控制台创建交换机和队列的时候可以勾选 Durable 来达到持久化的目的,但是如果使用代码来创建持久化的交换机和队列呢?下面我将使用 Java 代码来演示这个过程:

由于消费者comsumer在启动的时候可以帮我们创建交换机和队列,因此将交换机和队列的声明交给 consumer 来完成。

  1. 声明持久化的交换机
@Configuration
public class CommonConfig {
    @Bean
    public DirectExchange simpleDirect(){
        // DirectExchange的构造方法有三个参数:交换机名称、是否持久化、当没有 queue 与其绑定时是否自动删除
        return new DirectExchange("simple.direct", true, false);
    }
}
  1. 声明持久化的队列持久化
@Configuration
public class CommonConfig {

		// ...
		
    @Bean
    public Queue simpleQueue(){
        // 使用QueueBuilder构建队列,其中使用 durable 方法就是持久化的
        return QueueBuilder.durable("simple.queue").build();
    }
}

当完成了上面两步之后,我们可以启动 consumer 服务:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmqrabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
此时,我们发现成功创建了simple.direct交换机和 simple.queue 队列,并且它们都是持久的。然后停止consumer 服务,在 RabbitMQ 的控制台中向 simple.queue 添加一条消息:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
然后再次重启 RabbitMQ 服务,发现刚才创建的交换机和队列都还在,但是消息却没有了:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq因为我刚才添加的是非持久化的消息:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq

2.3 发送持久化的消息

同样,在控制台添加消息的时候可以设置消息的持久化和非持久化,下面让我来演示然后在使用 Java 代码发送持久化的消息:

@Test
public void testDurableMessage() {
    // 1. 准备消息
    Message message = MessageBuilder.withBody("hello, simple.queue".getBytes(StandardCharsets.UTF_8))
            .setDeliveryMode(MessageDeliveryMode.PERSISTENT)
            .build();
    // 2. 发送消息
    rabbitTemplate.convertAndSend("simple.queue", message);
}

在发送持久化的消息需要使用MessageBuilder来构建消息,其中withBody用于指定消息体;setDeliveryMode用来设置消息的发送类型,可以是持久化的,也可以是非持久化的;build 与构建消息。

完成上述代码之后,我们可以执行这个测试方法:

查看 RabbitMQ 的控制台,发现成功发送了消息,并且其中的 delivery_mode 为 2,代表的就是持久化:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq

再次重启 RabbitMQ 服务:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq

此时发现刚才的消息并没有丢失,至此我们就完成了持久化消息的发送,进一步确保了消息的可靠性。另外,其实在使用 Spring AMQP 创建的交换机,队列和发送的消息都是持久化的。

三、消费者消息的确认

3.1 配置消费者消息确认

RabbitMQ 同样也支持消费者确认机制,即当消费者处理消息后可以向 MQ 发送 ack 回执,当 MQ 收到 ack 回执后才会删除该消息。而Spring AMQP 则允许配置三种确认模式:

  • manual:在代码中手动 ack,需要在业务代码结束后,调用Spring AMQP 提供的 API 发送 ack,但是这种情况存在代码侵入的问题。
  • auto:基于 AOP 自动发送 ack,由 Spring 监测 listener 代码是否出现异常,没有异常则返回 ack;抛出异常则返回 nack;
  • none:关闭 ack,MQ 假定消费者获取消息后会成功处理,因此消息投递后立即被删除。

实现消费者的确认机制的方式就是是修改application.yml文件,添加下面配置:

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1
        acknowledge-mode: auto # none,关闭ack;manual,手动ack;auto:自动 ack

3.2 演示 none 模式

此时,我们将消费者的确认模式改为 none

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
消息处理逻辑:

@Slf4j
@Component
public class SpringRabbitListener {
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue(String msg) {
        System.out.println("消费者接收到simple.queue的消息:【" + msg + "】");
        // 模拟异常
        System.out.println(1/0);
        log.info("消费者处理消息成功!");
    }
}

在这里,使用 System.out.println(1/0)来模拟异常的产生。

此时,在 simple.queue 中存在一条消息:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq

然后,我们将断点设置到如下位置:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq调试运行,可以发现,在 none 模式下,只有消费者接收到了消息,RabbitMQ 就会立即删除队列中的消息。
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
在这种none模式下,队列中的消息并不可靠,当消费者消费消息失败的时候不应该理解删除,而是应该重新发送或者采取其他措施来保证消息的可靠性。

3.3 演示 auto 模式

接下来让我们演示一下 auto 模式:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
同样在simple.queue中准备一条消息:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq然后调试运行刚才的代码:

此时发现consumer成功接收到了消息:
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq并且,此时 simple.queue 中消息的状态变成了 Unacked
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
如果,此时放行代码,发现消费者还是会继续接收到这条消息:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
此时,如果取消断点,并放开代码,会发现此时的消费者就会一直死循环的接收到这条消息。

通过上面的演示可以发现,尽管在 auto 模式下保证了消息的不丢失,但是此时如果消费者出现了异常,就会死循环的接收并尝试处理同一条消息。面对这个问题,还需要采取其他措施来进行处理,例如下文消费者消费失败的重试机制。

四、消息消费失败的重试机制

4.1 本地重试机制

当消费者出现异常后,消息会不断 requeue(重新入队)到队列,再重新发送给消费者,然后再次异常,再次 requeue,无限循环,导致 MQ的消息处理的压力大大提高,给 MQ 服务器带来不必要的压力:

rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq

我们可以利用 Spring 的 retry 机制,在消费者出现异常时利用本地重试,而不是无限制的 requeue 到 MQ 队列,使用这个重试机制需要在 application.yml 添加如下配置:

spring:
  rabbitmq:
    listener:
      simple:
        retry:
          enabled: true # 开启消费者失败重试
          initial-interval: 1000 # 初识的失败等待时长为1秒
          multiplier: 1 # 失败的等待时长倍数,下次等待时长 = multiplier * last-interval
          max-attempts: 3 # 最大重试次数
          stateless: true # true无状态;false 有状态。如果业务中包含事务,这里改为 false

完成了上面的配置之后,再次重启 consumer
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq

发现,消费者在本地重试了三次,最终还是失败,然后就放弃重试,并且simple.queue 中的消息也删除了。

4.2 失败消息的处理策略

在开启重试模式后,重试次数耗尽,如果消息依然失败,则需要有 MessageRecoverer 接口来处理,它包含三种不同的实现:

  • RejectAndDontRequeueRecoverer:重试次数耗尽后,直接 reject,丢弃消息,这是默认采取的方式;
  • ImmediateRequeueMessageRecoverer:重试次数耗尽后,返回 nack,消息重新入队;
  • RepublishMessageRecoverer:重试耗尽后,将失败消息投递到指定的交换机。

下面演示一下 RepublishMessageRecoverer 处理模式:

  1. 首先,定义接收失败消息的交换机、队列及其绑定关系:
@Bean
public DirectExchange errorMessageExchange() {
    return new DirectExchange("error.direct");
}

@Bean
public Queue errorQueue() {
    return new Queue("error.queue", true);
}

@Bean
public Binding errorBinding() {
    return BindingBuilder.bind(errorQueue()).to(errorMessageExchange()).with("error");
}

  1. 然后,定义RepublishMessageRecoverer
@Bean
public MessageRecoverer republishMessageRecoverer(RabbitTemplate rabbitTemplate) {
    return new RepublishMessageRecoverer(rabbitTemplate, "error.direct", "error");
}

当我们注册了 RepublishMessageRecoverer Bean 对象之后,就会自动覆盖 Spring 提供的默认的 RejectAndDontRequeueRecoverer 的 Bean 对象。

当完成了上述的所有配置之后,首先在 simple.queue 中准备一条消息,然后再启动 consumer
rabbitmq查看生产者,RabbitMQ,微服务,rabbitmq
最终发现,处理失败的消息最终转发到了 error.queue 队列了。文章来源地址https://www.toymoban.com/news/detail-752296.html

到了这里,关于【RabbitMQ】RabbitMQ 消息的可靠性 —— 生产者和消费者消息的确认,消息的持久化以及消费失败的重试机制的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • RabbitMQ之生产者可靠性

    有的时候由于网络波动,可能会出现客户端连接RabbitMQ失败的情况。通过配置我们可以开启 连接失败后 的重连机制 注:当网络不稳定的时候,利用重试机制可以有效提高消息发送的成功率。不过SpringAMQP提供的重试机制是阻塞式的重试,也就是说多次重试等待的过程中,当前

    2024年01月22日
    浏览(47)
  • RabbitMQ生产者的可靠性

    目录 MQ使用时会出现的问题 生产者的可靠性 1、生产者重连 2、生产者确认 3、数据持久化 交换机持久化 队列持久化 消息持久化 LazyQueue懒加载 MQ使用时会出现的问题 发送消息时丢失: 生产者发送消息时连接MQ失败 生产者发送消息到达MQ后未找到 Exchange 生产者发送消息到达

    2024年02月08日
    浏览(41)
  • RabbitMQ --- 消息可靠性

    消息队列在使用过程中,面临着很多实际问题需要思考:      消息从发送,到消费者接收,会经理多个过程: 其中的每一步都可能导致消息丢失,常见的丢失原因包括: 发送时丢失: 生产者发送的消息未送达exchange 消息到达exchange后未到达queue MQ宕机,queue将消息丢失 co

    2024年02月14日
    浏览(49)
  • RabbitMQ-保证消息可靠性

    消息从发送,到消费者接收,会经理多个过程: 其中的每一步都可能导致消息丢失,常见的丢失原因包括: 发送时丢失: 生产者发送的消息未送达exchange 消息到达exchange后未到达queue MQ宕机,queue将消息丢失 consumer接收到消息后未消费就宕机 针对这些问题,RabbitMQ分别给出了

    2024年02月07日
    浏览(52)
  • RabbitMQ消息的可靠性

    面试题: Rabbitmq怎么保证消息的可靠性? 1.消费端消息可靠性保证: 消息确认(Acknowledgements) : 消费者在接收到消息后,默认情况下RabbitMQ会自动确认消息(autoAck=true)。为保证消息可靠性,可以设置autoAck=false,使得消费者在处理完消息后手动发送确认(basicAck)。如果消费

    2024年04月14日
    浏览(73)
  • rabbitmq消息可靠性之消息回调机制

    rabbitmq消息可靠性之消息回调机制 rabbitmq在消息的发送与接收中,会经过上面的流程,这些流程中每一步都有可能导致消息丢失,或者消费失败甚至直接是服务器宕机等,这是我们服务接受不了的,为了保证消息的可靠性,rabbitmq提供了以下几种机制 生产者确认机制 消息持久

    2024年02月08日
    浏览(56)
  • RabbitMQ保证消息的可靠性

    消息从发送,到消费者接收,会经理多个过程: 其中的每一步都可能导致消息丢失,常见的丢失原因包括: 发送时丢失: 生产者发送的消息未送达exchange 消息到达exchange后未到达queue MQ宕机,queue将消息丢失 consumer接收到消息后未消费就宕机 针对这些问题,RabbitMQ分别给出了

    2024年02月19日
    浏览(49)
  • RabbitMQ高级篇---消息可靠性

    1、消息可靠性: 消息从发送到消费者接受,会经历多个过程,每个消息传递的过程都可能导致消息的丢失: 常见的丢失原因: 发送时消息丢失原因: 生产者发送的消息未送达exchange 消息到达exchange后未到达queue MQ宕机,queue将消息丢失 consumer接收到消息后未消费就宕机 Rab

    2024年01月20日
    浏览(52)
  • RabbitMQ如何保证消息可靠性

    目录 1、RabbitMQ消息丢失的可能性 1.1 生产者消息丢失场景 1.2 MQ导致消息丢失 1.3 消费者丢失 2、如何保证生产者消息的可靠性 2.1 生产者重试机制 2.2 生产者确认机制 2.3 实现生产者确认 2.3.1 配置yml开启生产者确认 2.3.2 定义ReturnCallback 2.3.3 定义ConfirmCallback 3、MQ消息可靠性 3.1

    2024年02月20日
    浏览(57)
  • RabbitMQ 能保证消息可靠性吗

    手把手教你,本地RabbitMQ服务搭建(windows) 消息队列选型——为什么选择RabbitMQ RabbitMQ灵活运用,怎么理解五种消息模型 推或拉? RabbitMQ 消费模式该如何选择 死信是什么,如何运用RabbitMQ的死信机制? 前面我们在做MQ组件选型时,提到了rabbitMQ的消息可靠性,那么它到底可靠

    2024年02月16日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包