【RabbitMQ高级特性】消息可靠性原理

于 2024-08-24 16:43:21 发布
阅读量521 收藏 7
点赞数 22
文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62533201/article/details/141501584
版权

1. 消息确认机制

1.1 介绍

我们可以看到RabbitMQ的消息流转图：

当消息从Broker投递给消费者的时候会存在以下两种情况：

  1. consumer消费消息成功
  2. consumer消费消息异常

如果说RabbitMQ在每次将消息投递给消费者的时候就将消息从Broker中删除，此时如果消息处理异常，就会造成消息丢失的情况！因此RabbitMQ提供了消息确认机制（Message Acknowledge），消费者可以设置autoAck参数来进行确认：

  • 自动确认：当设置autoAck参数为true时，RabbitMQ就会将自己发送出去的消息置为确认，并从内存和硬盘上移除，不管消费者是否消费消息成功，适用于消息可靠性要求不高的场景
  • 手动确认：当设置autoAck参数为false时，RabbitMQ会等待消费者显示调用Basic.Ack命令，如果确认消费成功则进行删除消息操作，适用于消息可靠性较高的场景

当autoAck参数设置为false的时候，消息会被分为两部分：一部分是等待进行投递的消息，另一部分是已经投递但是还没有等到消费者回复的消息，其结构如下：

从RabbitMQ的Web管理平台也可以看到这两种状态：
image.png

1.2 手动确认方法

消费者在收到消息之后，可以进行确认应答，也可以进行拒绝确认，RabbitMQ也提供的不同的确认方法API，在消费者端可以使用channel的以下三种不同API进行应答：

  1. 肯定应答：channel.basicAck(long deliveryTag, boolean multiple)

表示消息已经被消费者正确处理，通知RabbitMQ可以将消息进行移除了
参数说明：

  • deliveryTag：是消息的唯一标识，是一个64位递增的长整数，该参数由每个channel进行单独维护，即在每个channel内部deliveryTag是不重复的
  • multiple：是否进行批量确认，在某些情况下为了减少网络传输带宽，可以对连续的多个deliveryTag进行批量确认，当值设置为true的时候则会将ack<=deliveryTag的消息全部确认；如果值设置为false则只会将对应deliveryTag的消息进行确认
  1. 否定确认：channel.basicReject(long deliveryTag, boolean requeue)

表示消费者拒绝该消息
参数说明：

  • deliveryTag：参考basicAck
  • requeue：表示拒绝该消息之后该消息如何处理，如果设置为true，则RabbitMQ会重新将该消息放入队列，以便投递给下一个订阅的消费者；如果设置为false，则RabbitMQ会将该消息从队列中移除
  1. 否定确认：channel.basicNack(long deliveryTag, boolean multiple, boolean requeue)

表示消费者拒绝该消息，并且可以批量拒绝消息
参数说明（参考上方）

1.3 代码演示

下面我们基于Spring-AMQP演示消息的确认机制，该确认机制有三种模式可以配置（需要注意与上述client模式有些不同）：

1.3.1 NONE模式

该模式类似于上述讲的自动确认模式：即只要Broker将消息投递给消费者就会删除队列中的消息，而不管消费者有没有消费成功，可能会造成消息丢失场景！

  1. 配置确认机制为NONE模式：
spring:
  application:
    name: mq-advanced
  rabbitmq:
    username: guest
    password: guest
    host: 127.0.0.1
    port: 5672
    virtual-host: springboot-mq
    listener:
      simple:
        acknowledge-mode: NONE # NONE模式
  1. 发送消息
@RequestMapping("/none")
public String testNone() {
    rabbitTemplate.convertAndSend("", QueueConstant.ACK_QUEUE, "test none mode");
    return "消息发送成功!";
}
  1. 监听消息
@Component
public class AckListener {
    @RabbitListener(queues = QueueConstant.ACK_QUEUE)
    public void ackListener(Message message, Channel channel) {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        String body = new String(message.getBody(), StandardCharsets.UTF_8);
        System.out.println("接收到消息: " + body + " deliveryTag: " + deliveryTag);
        System.out.println("开始处理消息...");
        int ret = 3 / 0;
        System.out.println("消息处理完毕...");
    }
}

此时就会出现以下情况：在消费者中抛出异常，但是RabbitMQ中消息已经丢失！

1.3.2 AUTO模式（默认）

该模式作用如下：

  • 当消费者业务代码处理正常时就会对消息进行确认
  • 但是如果消费者业务代码中抛出了异常，就会对消息进行否定确认并重新投递
  1. 配置确认机制为AUTO模式：
spring:
  application:
    name: mq-advanced
  rabbitmq:
    username: guest
    password: guest
    host: 127.0.0.1
    port: 5672
    virtual-host: springboot-mq
    listener:
      simple:
        acknowledge-mode: AUTO # AUTO模式
  1. 发送消息
@RequestMapping("/none")
public String testNone() {
    rabbitTemplate.convertAndSend("", QueueConstant.ACK_QUEUE, "test none mode");
    return "消息发送成功!";
}
  1. 监听消息
@Component
public class AckListener {
    @RabbitListener(queues = QueueConstant.ACK_QUEUE)
    public void ackListener(Message message, Channel channel) {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        String body = new String(message.getBody(), StandardCharsets.UTF_8);
        System.out.println("接收到消息: " + body + " deliveryTag: " + deliveryTag);
        System.out.println("开始处理消息...");
        int ret = 3 / 0;
        System.out.println("消息处理完毕...");
    }
}

此时就会出现以下情况：在消费者中抛出异常，但是消息不会丢失，而是源源不断投递给可用的消费者！
image.png

1.3.3 MANUAL模式

该模式就可以进行手动确认：

  1. 配置确认机制为MANUAL模式：
spring:
  application:
    name: mq-advanced
  rabbitmq:
    username: guest
    password: guest
    host: 127.0.0.1
    port: 5672
    virtual-host: springboot-mq
    listener:
      simple:
        acknowledge-mode: MANUAL # MANUAL模式
  1. 发送消息
@RequestMapping("/none")
public String testNone() {
    rabbitTemplate.convertAndSend("", QueueConstant.ACK_QUEUE, "test none mode");
    return "消息发送成功!";
}
  1. 监听消息
@Component
public class AckListener {
    @RabbitListener(queues = QueueConstant.ACK_QUEUE)
    public void ackListener(Message message, Channel channel) throws IOException {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            String body = new String(message.getBody(), StandardCharsets.UTF_8);
            System.out.println("接收到消息: " + body + " deliveryTag: " + deliveryTag);
            System.out.println("开始处理消息...");
            int ret = 3 / 0;
            System.out.println("消息处理完毕...");
            channel.basicAck(deliveryTag, false);
        } catch (Exception e) {
            channel.basicReject(deliveryTag, true);
        }
    }
}

此时就会出现以下情况：如果处理成功，就会进行basicAck肯定确认，但是如果捕获到了异常就进行拒绝确认，并将消息重新入队投递给下一个消费者使用！
image.png

2. 持久化机制

2.1 介绍

我们再次回看RabbitMQ的消息流转图：

前面我们通过消息确认机制保证了Broker能够将消息可靠地投递给Consumer消费者端，但是现在还存在一个问题：当消息存储在Broker中，但是RabbitMQ服务器遇到断电重启的情况如何保证将消息恢复呢？RabbitMQ就提供了 持久化机制 ，在RabbitMQ中有以下三种持久化：

  1. 队列持久化
  2. 交换机持久化
  3. 消息持久化

2.2 队列持久化

队列的持久化是通过在声明队列的时候设置参数durable为true实现的

  • 如果队列不进行持久化，那么在重启的时候关于队列的元数据信息就会丢失（此时哪怕消息进行了持久化也无法恢复消息了，因为消息保存在队列中）
  • 如果将队列设置为持久化，此时队列相关的元数据就可以从硬盘上进行恢复，但是并不能保证内部的消息不丢失，如果想要让消息不丢失，还需要设置消息的持久化

我们之前所创建队列的代码默认设置为持久化：

/**
 * 声明持久化队列
 */
@Bean("persistQueue")
public Queue persistQueue() {
    return QueueBuilder
            .durable(QueueConstant.PERSIST_QUEUE)
            .build();
}

追踪durable方法源码：
image.png
继续追踪setDurable方法源码可以发现默认是进行持久化的！
image.png
如果我们想要设置队列为非持久化，可以使用如下代码：

/**
 * 声明非持久化队列
 */
@Bean("nonPersistQueue")
public Queue nonPersistQueue() {
    return QueueBuilder
            .nonDurable(QueueConstant.NON_PERSIST_QUEUE)
            .build();
}

2.3 交换机持久化

交换机的持久化是通过在声明交换机的时候设置参数durable为true实现的
同队列一样，只有设置为持久化，才会将有关交换机的元数据信息保存在硬盘上，在重启RabbitMQ服务器的时候才会读取然后恢复交换机数据信息，我们可以通过在声明交换机的时候设置durable(true | false)显示声明是否持久化：

/**
 * 声明持久化交换机
 */
@Bean("persistDirectExchange")
public DirectExchange persistDirectExchange() {
    return ExchangeBuilder
            .directExchange(ExchangeConstant.PERSIST_EXCHANGE)
            .durable(true)
            .build();
}
/**
 * 声明非持久化交换机
 */
@Bean("nonPersistDirectExchange")
public DirectExchange nonPersistDirectExchange() {
    return ExchangeBuilder
            .directExchange(ExchangeConstant.NON_PERSIST_EXCHANGE)
            .durable(false)
            .build();
}

2.4 消息持久化

如果想要让消息进行持久化，我们就需要设置消息的投递模式MessageProperties.deliveryMode为PERSISITENT，使用RabbitTemplate发送持久化消息代码如下：

@RestController
public class PersistController {
    @Resource
    private RabbitTemplate rabbitTemplate;

    @RequestMapping("/persist")
    public String sendPersist() {
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
        Message message = new Message("persist info".getBytes(), messageProperties);
        rabbitTemplate.convertAndSend(ExchangeConstant.PERSIST_EXCHANGE, "persist", message);
        return "发送成功!";
    }
}

如果想要设置消息的不持久化，则对应代码如下：

@RequestMapping("/nonPersist")
public String sendNonPersist() {
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT);
    Message message = new Message("non-persist info".getBytes(), messageProperties);
    rabbitTemplate.convertAndSend(ExchangeConstant.NON_PERSIST_EXCHANGE, "non-persist", message);
    return "发送成功!";
}

3. 发送方确认机制

3.1 介绍

我们再次回看RabbitMQ的消息流转图：

现在我们通过消息确认机制保证从Broker到Consumer链路上消息可靠性，通过持久化机制保证Broker内部消息可靠性，但是此时还存在着问题：如果说消息在生产者投递给Broker过程中由于网络等问题导致消息丢失、或者Broker处于重启等服务不可用状态该怎么办呢？即生产者如何保证消息能够可靠到达RabbitMQ服务器？
RabbitMQ为了解决这个问题，提供了以下两种机制：

  1. 事务机制（性能较低，此处不介绍）
  2. 发送方确认机制（Publisher Confirm）

在发送方确认机制中，可以配置以下两种模式：

  1. confirm确认模式：

确认模式指的是在发送者发送消息时设置一个ConfirmCallback的监听器，无论消息是否到达对应的Exchange，这个监听都会执行。如果消息到达对应的Exchange，则对应ACK参数为true，反之没有到达Exchange则ACK参数为false

  1. return回退模式

我们期待Exchange能够依据特定的路由规则将消息投递给对应的队列，但是如果设置的路由键错误或者队列不存在时导致消息迟迟没有投递给队列，此时我们希望可以将消息退回给生产者，退回模式指的是在发送者发送消息时设置一个ReturnsCallback的监听器对退回的消息进行处理

🔑 总结：确认模式和退回模式并不是互斥的，两者可以同时设置！确认模式主要解决的是保证消息可靠到达Exchange的问题，而退回模式保证的是消息可靠到达Queue的问题

3.2 代码演示

3.2.1 Confirm确认模式

配置步骤如下：

  1. 进行confirm模式配置
  2. 在发送方设置ConfirmCallback并发送消息
  3. 测试

接下来看实现步骤：

  1. 配置confirm模式开启
spring:
  application:
    name: mq-advanced
  rabbitmq:
    username: guest
    password: guest
    host: 127.0.0.1
    port: 5672
    virtual-host: springboot-mq
    publisher-confirm-type: correlated # 开启发送者确认模式
  1. 声明队列与交换机
public interface ExchangeConstant {
    String CONFIRM_EXCHANGE = "confirm.exchange";
}

public interface QueueConstant {
    String CONFIRM_QUEUE = "confirm.queue";
}

@Configuration
public class RabbitMQConfig {
    /**
     * 声明发送者确认模式队列
     */
    @Bean("confirmQueue")
    public Queue confirmQueue() {
        return QueueBuilder
        .durable(QueueConstant.CONFIRM_QUEUE)
        .build();
    }
    /**
     * 声明发送者确认模式交换机
     */
    @Bean("confirmExchange")
    public DirectExchange confirmExchange() {
        return ExchangeBuilder
        .directExchange(ExchangeConstant.CONFIRM_EXCHANGE)
        .durable(true)
        .build();
    }
    /**
     * 声明发送者确认模式交换机
     */
    @Bean("confirmBinding")
    public Binding confirmBinding(@Qualifier("confirmExchange") DirectExchange exchange, @Qualifier("confirmQueue") Queue queue) {
        return BindingBuilder
        .bind(queue)
        .to(exchange)
        .with("confirm");
    }
}
  1. 编写发送者代码
@Configuration
public class RabbitTemplateConfig {
    @Bean("rabbitTemplate")
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        return new RabbitTemplate(connectionFactory);
    }

    @Bean("confirmRabbitTemplate")
    public RabbitTemplate confirmRabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        // 设置confirm回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean b, String s) {
                System.out.println("执行了confirm方法...");
                if (b) {
                    // 到达交换机
                    System.out.println("消息id: " + (correlationData == null ? null : correlationData.getId())  + "到达交换机");
                } else {
                    // 没有到达交换机
                    System.out.println("消息id: " + (correlationData == null ? null : correlationData.getId()) + "没有到达交换机, 原因是: " + s);
                }
            }
        });
        return rabbitTemplate;
    }
}

@RestController
public class ConfirmController {
    @Resource(name = "confirmRabbitTemplate")
    private RabbitTemplate rabbitTemplate;
    @RequestMapping("/confirm")
    public String confirm() {
        // 发送消息
        CorrelationData correlationData = new CorrelationData("1");
        rabbitTemplate.convertAndSend(ExchangeConstant.CONFIRM_EXCHANGE, "confirm", "test confirm...", correlationData);
        return "发送消息成功!";
    }
}
  1. 测试接口

image.png
发现如果交换机名称设置正确则当消息到达交换机时回调被执行，我们尝试设置一个不存在的交换机名称查看现象：
image.png
此时就会走没有到达交换机的逻辑，此处就可以进行重新投递消息等业务逻辑！

💡 答疑解惑：为什么此处我们明确注入一个自己创建出来的RabbitTemplate，而不使用Spring提供的呢？有以下两点原因：

  1. 这是因为Spring默认配置Bean为单例的，因此如果使用Spring提供的RabbitTemplate设置回调函数则会影响其余接口同样使用回调
  2. 我们不能重复在controller层代码中重复多次调用setConfirmCallback回调，因为明确规定每个RabbitTemplate只能设置一次ConfirmCallback

3.2.2 Return退回模式

配置步骤如下：

  1. 进行return模式配置
  2. 在发送方设置setMandatory(true)表示进行退回
  3. 设置ReturnsCallback回调逻辑并发送消息
  4. 测试

接下来看实现步骤：

  1. 配置return模式开启（同confirm模式一致）
spring:
  application:
    name: mq-advanced
  rabbitmq:
    username: guest
    password: guest
    host: 127.0.0.1
    port: 5672
    virtual-host: springboot-mq
    publisher-confirm-type: correlated # 开启发送者确认模式
  1. 设置ReturnsCallback回调逻辑并发送消息
@Configuration
public class RabbitTemplateConfig {
    @Bean("rabbitTemplate")
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        return new RabbitTemplate(connectionFactory);
    }

    @Bean("confirmRabbitTemplate")
    public RabbitTemplate confirmRabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        // 设置confirm回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean b, String s) {
                System.out.println("执行了confirm方法...");
                if (b) {
                    // 到达交换机
                    System.out.println("消息id: " + (correlationData == null ? null : correlationData.getId())  + "到达交换机");
                } else {
                    // 没有到达交换机
                    System.out.println("消息id: " + (correlationData == null ? null : correlationData.getId()) + "没有到达交换机, 原因是: " + s);
                }
            }
        });
        // 设置return回调
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            public void returnedMessage(ReturnedMessage returnedMessage) {
                System.out.println("收到回退消息: " + returnedMessage);
            }
        });
        return rabbitTemplate;
    }
}

@RestController
public class ConfirmController {
    @Resource(name = "confirmRabbitTemplate")
    private RabbitTemplate rabbitTemplate;
    @RequestMapping("/confirm")
    public String confirm() {
        // 发送消息
        CorrelationData correlationData = new CorrelationData("1");
        rabbitTemplate.convertAndSend(ExchangeConstant.CONFIRM_EXCHANGE, "confirm", "test confirm...", correlationData);
        return "发送消息成功!";
    }

    @RequestMapping("/returns")
    public String returns() {
        // 发送消息
        CorrelationData correlationData = new CorrelationData("2");
        rabbitTemplate.convertAndSend(ExchangeConstant.CONFIRM_EXCHANGE, "confirm", "test return...", correlationData);
        return "发送消息成功!";
    }
}
  1. 下面进行测试（设置不存在的routingkey）

image.png
此时证明当消息长期存放在exchange中没有投递到queue的时候就会触发消息退回回调

米饭好好吃.
关注
  • 22
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【rabbitMq-2】 高级特性之消息可靠性
growing_duck的博客
10-19 236
文章内容输出来源：拉勾教育Java高薪训练营 希望记录的每一个点，都能真正掌握，而不是流水账 一：可靠性保证 消息虽然有异步、高并发的优点，但具有一定延时、数据弱一致性，甚至消息发送/消费失败等缺点。所以，我们可以从生产者端，服务器和消费者端来保证消息可靠性，如果这三端都能保证，消息可靠性也就OK了。 生产者端： 1. 异常捕获机制 客户端代码中的异常捕获，如果在业务逻辑执行过程中抛出异常，则重发或者回滚。 但是，没有异常不代表一定成功，所以此方案是最大努力保证。 注：也可以通过spr.
.Net使用RabbitMQ即时发消息Demo
10-18
RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）协议的一个开源消息系统，它由Erlang语言编写，提供了高可用性、可靠性和可扩展性。 描述中提到，这篇文章会通过示例代码详细讲解如何在.NET应用中使用...
RabbitMQ的高级特性--如何保证消息可靠性
李嘉图呀李嘉图的博客
02-02 3953
1.rabbitMQ临时队列 1.首先，我们无论何时连接RabbitMQ的时候，都需要一个新的，空的队列。我们可以使用随机的名 字创建队列，也可以让服务器帮我们生成随机的消息队列名字。 其次，一旦我们断开到消费者的连接，该队列应该自动删除。 2.创建临时队列方式如下： String queue = channel.queueDeclare().getQueue(); 上述代码我们声明了一个非持久化的、排他的、自动删除的队列，并且名字是服务器随机生成的...
MQ——RabbitMQ高级特性原理
庄小焱
09-25 535
摘要 本博文将介绍数据可靠性的一些细节，并展示RabbitMQ的几种已具备或衍生的高级特性，包括TTL、死信队列、延迟队列、优先级队列、RPC等，这些功能在实际使用中可以让某些应用的实现变得事半功倍。同时对源码进行详细的分析。 Rabbit的TTL Rabbit的死信队列 Rabbit的延迟队列 Rabbit的优先级队列 Rabbit的RPC ...
MQ——RabbitMQ高级特性原理2
庄小焱
09-25 1481
摘要 第9章介绍RabbitMQ相关的一些原理，主要内容包括RabbitMQ存储机制、磁盘和内存告警、流控机制、镜像队列。 RabbitMQ存储机制 RabbitMQ磁盘和内存告警 RabbitMQ流控机制 RabbitMQ镜像队列 ...
RabbitMQ高级特性
FYHannnnnn的博客
11-26 799
一，消息的可靠性 客户端代码中的异常捕获，包括生产者和消费者 消息发送过程通过try catch 方式捕获异常， 在异常处理理的代码块中执行行回滚业务操作或者执行行重发操作等。这是一种最大努力确保的方式， 并无法保证100%绝对可靠，因为这里没有异常并不代表消息就一定投递成功。 可以通过spring.rabbitmq.template.retry.enabled=true 配置开启发送端的重试 AMQP/RabbitMQ的事务机制 没有捕获到异常...
MQ——RabbitMQ高级特性3
庄小焱
10-10 959
摘要 本博文件详细的介绍RabbitMQ的消息追踪和均衡负载的相关的原理。 消息追踪 均衡负载 博文参考
RabbitMQ-高级特性
slxysyka的博客
02-28 2085
尚硅谷学习笔记-8 RabbitMQ高级特性 8.1 消息的可靠投递 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 · confirm 确认模式 · return 退回模式 rabbitmq 整个消息投递的路径为： producer—>rabbitmq broker—>exchange—>queue—>consumer l消息从 producer 到 exch
RabbitMQ消息中间件技术精讲.txt
01-21
- **可靠性**：RabbitMQ提供了多种机制来保证消息的可靠传输，例如持久化消息、确认机制等。 - **灵活性**：支持多种消息传递模式，可以根据不同的业务需求选择合适的模式。 - **扩展性**：支持水平扩展，可以通过...
RabbitMQ消息中间件技术精讲
10-28
### RabbitMQ消息中间件技术精讲 #### 一、RabbitMQ简介 ...通过以上详细介绍，我们不仅了解了RabbitMQ的基础知识，还掌握了其高级特性和实战技巧，这对于在实际项目中有效利用RabbitMQ解决复杂问题具有重要意义。
RabbitMQ消息中间件视频教程
05-14
RabbitMQ具有高可用性、灵活的路由机制、可靠的持久化特性以及良好的扩展性，能够满足大规模分布式系统中的消息传输需求。 #### 二、消息中间件的重要性 在现代软件架构设计中，消息中间件扮演着极其重要的角色。...
RabbitMQ实战 高效部署分布式消息队列 带目录 高清版 PDF
09-13
RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）协议的开源消息代理和队列服务器，它允许应用程序之间进行异步通信，从而提高系统的可扩展性和可靠性。作为Java开发的项目，RabbitMQ具有跨平台的特性，...
RabbitMQ的基础概念介绍
最新发布
m0_45164511的博客
08-22 1010
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。
rabbitMQ消息的可靠性
2302_77426533的博客
08-22 935
因网络问题连接MQ失败，解决在配置文件中配置失败后的重连机制(阻塞式的，影响业务)
前端与rabbitmq通信
xiaoliu_alone的博客
08-22 632
我这里只是使用了一种方式，据我了解，还存在amqp、mqtt等消息协议通信。后面会继续补充。
RabbitMQ如何保证消息不丢失
2301_76166241的博客
08-20 1268
可以选择用 RabbitMQ 提供的事务功能，就是生产者发送数据之前开启 RabbitMQ 事务channel.txSelect，然后发送消息，如果消息没有成功被 RabbitMQ 接收到，那么生产者会收到异常报错，此时就可以回滚事务channel.txRollback，然后重试发送消息；RabbitMQ 自己弄丢了数据，这个必须要开启 RabbitMQ消息的持久化，就是消息写入之后会持久化到磁盘，哪怕是 RabbitMQ 自己挂了，恢复之后会自动读取之前存储的数据，一般数据不会丢失。
[000-01-022].第06节：RabbitMQ中的交换机介绍
F-T-er
08-21 434
交换机的类型来决定。
RabbitMQ练习（Work Queues）
zkyqss的博客
08-21 913
在本练习中，将创建一个工作队列（Work Queue），它将被用来在多个工作者（Worker）之间分配需要较长时间来完成的任务（ time-consuming tasks）。工作队列（也称为任务队列）避免立即执行复杂任务：复杂任务往往是需要花费系统更多时间和更多资源进行处理的任务。工作队列的设计初衷是减少对即时资源的需求。在某些情况下，如果直接执行某些任务，可能会消耗大量计算资源，导致系统响应变慢或无法处理其他请求。延迟执行任务。
rabbitmq消息队列的底层原理和实现方法
07-08
RabbitMQ是一个使用AMQP（Advanced Message Queuing Protocol，高级消息队列协议）实现的开源消息队列系统。它基于消息队列的概念，提供了一种可靠的、可扩展的、灵活的消息传递模式。 底层原理： 1. Producer（生产者）使用AMQP协议将消息发送到RabbitMQ的Exchange（交换机）。 2. Exchange根据预设的规则（如路由键）将消息路由到一个或多个Queue（队列）。 3. Consumer（消费者）订阅并从队列中接收消息进行处理。 RabbitMQ的实现方法主要包括以下几个关键组件： 1. Exchange（交换机）：接收Producer发送的消息，并根据预设的规则将消息路由到一个或多个Queue。常见的Exchange类型有Direct、Topic、Fanout和Headers。 2. Queue（队列）：是消息的容器，可以持久化存储消息，Consumer从队列中获取消息进行消费。每个队列都有一个名称，并且可以绑定多个Exchange。 3. Binding（绑定）：用于将Exchange和Queue进行绑定，绑定时可以指定特定的规则，例如路由键、Headers等。 4. Routing Key（路由键）：Producer发送消息时，可以指定一个路由键，Exchange根据路由键将消息发送到匹配的Queue。 5. AMQP协议：RabbitMQ使用AMQP协议作为其通信协议，该协议定义了Producer、Exchange、Queue和Consumer之间的通信方式和规则。 通过以上组件的配合，RabbitMQ实现了高效、可靠的消息传递机制。它支持多种消息传递模式，例如点对点（Point-to-Point）和发布/订阅（Publish/Subscribe），并且具有可靠性、灵活性和可扩展性等优势。 需要注意的是，RabbitMQ还提供了各种高级特性，如消息的持久化、消息的优先级、消息确认机制等，以满足不同场景下的需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值