📕我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、优快云博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。
📘拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、SpringBoot、SpringMVC、SpringCloud、Mybatis、Dubbo、Zookeeper)，消息中间件底层架构原理(RabbitMQ、RocketMQ、Kafka)、Redis缓存、MySQL关系型数据库、 ElasticSearch全文搜索、MongoDB非关系型数据库、Apache ShardingSphere分库分表读写分离、设计模式、领域驱动DDD、Kubernetes容器编排等。
📙不定期分享高并发、高可用、高性能、微服务、分布式、海量数据、性能调优、云原生、项目管理、产品思维、技术选型、架构设计、求职面试、副业思维、个人成长等内容。
💡在这个美好的时刻，笔者不再啰嗦废话，现在毫不拖延地进入文章所要讨论的主题。接下来，我将为大家呈现正文内容。
🍊 RabbitMQ知识点之ACK/NACK：概述
在分布式系统中，消息队列扮演着至关重要的角色，它能够有效地解耦生产者和消费者，提高系统的可用性和伸缩性。然而，在实际应用中，如何确保消息的可靠传递和处理成为一个关键问题。这就引出了RabbitMQ中的ACK/NACK机制，它是保证消息传递可靠性的核心知识点。
想象一个场景，在一个复杂的电商系统中，订单服务需要处理大量的订单消息。如果订单服务在处理消息时突然崩溃，而消息没有被正确处理，那么可能会导致订单数据丢失或重复处理。为了防止这种情况发生，我们需要引入一种机制来确保消息在传递过程中能够被正确地确认和处理。
介绍RabbitMQ知识点之ACK/NACK：概述的重要性在于，它能够帮助我们理解消息队列中消息确认机制的基本原理和作用。ACK（Acknowledgement）即确认，表示消息已经被成功处理；而NACK（Negative Acknowledgement）即否定确认，表示消息处理失败。这两个机制对于确保消息的可靠性和系统的稳定性至关重要。
接下来，我们将深入探讨RabbitMQ知识点之ACK/NACK：基本概念，这将包括ACK/NACK的具体定义、触发条件以及如何在RabbitMQ中实现。随后，我们将进一步阐述ACK/NACK的作用与意义，解释为什么它们是确保消息队列可靠性的关键因素。
具体来说，我们将首先介绍ACK/NACK的基本概念，包括它们是如何与RabbitMQ的消息传递模型相结合的，以及它们是如何影响消息的生命周期的。然后，我们将探讨ACK/NACK在实际应用中的作用，比如如何通过它们来避免消息丢失、重复处理以及如何处理消息处理失败的情况。通过这些内容，读者将能够全面理解ACK/NACK在RabbitMQ中的重要性，并能够在实际项目中正确地使用它们来提高系统的健壮性。
🎉 消息确认机制
在RabbitMQ中，消息确认机制是确保消息正确传递到消费者的重要保障。它通过生产者与消费者之间的交互来确认消息是否被成功处理。下面，我们将详细探讨这一机制。
📝 生产者与消费者角色
在RabbitMQ中，生产者负责发送消息，而消费者负责接收并处理消息。生产者和消费者通过交换机（Exchange）和队列（Queue）进行通信。
| 角色 | 功能 |
|---|---|
| 生产者 | 发送消息到交换机 |
| 消费者 | 从队列中接收消息并处理 |
| 交换机 | 根据路由键将消息路由到相应的队列 |
| 队列 | 存储消息，等待消费者处理 |
🎉 手动确认与自动确认
在RabbitMQ中，消息确认机制分为手动确认和自动确认两种方式。
📝 手动确认
手动确认是指消费者在处理完消息后，主动向RabbitMQ发送一个确认信号，告知消息已被成功处理。这种方式可以确保消息的可靠性，但同时也增加了系统的复杂性。
channel.basicAck(deliveryTag, false);
📝 自动确认
自动确认是指消费者在从队列中获取消息并处理时，如果消息处理成功，RabbitMQ会自动将消息标记为已处理。这种方式简化了确认过程，但可能会丢失某些消息。
channel.basicConsume(queueName, autoAck);
🎉 NACK机制
NACK（Negative Acknowledgment）机制是RabbitMQ提供的一种消息拒绝机制。当消费者无法处理消息时，可以发送NACK信号，告知RabbitMQ拒绝该消息，并重新将其放入队列。
channel.basicNack(deliveryTag, false, true);
🎉 事务管理
事务管理是确保消息在发送和接收过程中的一致性。在RabbitMQ中，可以通过开启事务来保证消息的可靠性。
channel.txSelect();
// 发送消息
channel.basicPublish(exchange, routingKey, props, body);
// 提交事务
channel.txCommit();
🎉 消息持久化
消息持久化是指将消息存储在磁盘上，确保在系统重启后消息不会丢失。在RabbitMQ中，可以通过设置消息的持久化标志来实现。
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
.deliveryMode(2) // 消息持久化
.build();
🎉 消息重试策略
消息重试策略是指当消费者无法处理消息时，RabbitMQ会根据策略重新将消息发送给消费者。在RabbitMQ中，可以通过设置队列的过期时间和死信队列来实现。
channel.basicPublish(exchange, routingKey, props, body);
channel.queueDeclare(queueName, true, false, false, new HashMap<String, Object>() {
{
put("x-dead-letter-exchange", "deadLetterExchange");
put("x-dead-letter-routing-key", "deadLetterRoutingKey");
}});
🎉 异常处理
异常处理是确保系统稳定运行的重要环节。在RabbitMQ中，可以通过捕获异常来处理消息处理过程中的错误。
try {
// 处理消息
} catch (Exception e) {
// 异常处理
}
🎉 性能优化
性能优化是提高系统吞吐量的关键。在RabbitMQ中，可以通过以下方式优化性能：
- 使用批量消息发送
- 设置合适的队列长度
- 使用异步处理
通过以上内容，我们可以了解到RabbitMQ的消息确认机制、生产者与消费者角色、手动确认与自动确认、NACK机制、事务管理、消息持久化、消息重试策略、异常处理和性能优化等方面的知识。在实际应用中，我们需要根据具体场景选择合适的策略，以确保消息的可靠性和系统的稳定性。
🎉 消息确认机制：RabbitMQ中的ACK/NACK机制
在RabbitMQ中，消息确认机制是确保消息正确传递和消费的关键。它通过ACK（Acknowledgement）和NACK（Negative Acknowledgement）两种机制来实现。
📝 对比与列举：ACK与NACK的区别
| 特征 | ACK | NACK |
|---|---|---|
| 作用 | 确认消息已被正确处理 | 拒绝确认消息，请求重新发送 |
| 发送方 | 消费者 | 消费者 |
| 发送时机 | 消息处理成功后 | 消息处理失败时 |
| 结果 | 消息从队列中移除 | 消息重新入队 |
📝 消息传递过程
在RabbitMQ中，消息传递过程如下：
- 生产者将消息发送到交换器。
- 交换器根据路由键将消息路由到队列。
- 消费者从队列中获取消息。
- 消费者处理消息，并返回ACK或NACK。
📝 生产者与消费者行为
- 生产者：负责发送消息到RabbitMQ。
- 消费者：负责从RabbitMQ接收消息并进行处理。
📝 异常处理
当消费者在处理消息时发生异常，可以发送NACK请求，请求RabbitMQ重新发送该消息。
channel.basicAck(deliveryTag, false);
📝 事务管理
RabbitMQ支持事务，确保消息的原子性。在事务中，要么所有消息都成功发送，要么都不发送。
channel.txSelect();
// 发送消息
channel.basicPublish(exchange, routingKey, props, body);
// 提交事务
channel.txCommit();
📝 消息持久化
为了确保消息不会丢失，可以将消息设置为持久化。
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
.deliveryMode(2) // 消息持久化
.build();
📝 延迟消息
RabbitMQ支持延迟消息，允许消息在指定时间后发送。
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
.expiration("10000") // 延迟10秒
.build();
📝 死信队列
当消息被拒绝、过期或队列达到最大长度时，消息会被发送到死信队列。
channel.queueDeclare("dead-letter-queue", true, false, false, null);
📝 消息顺序性
RabbitMQ保证同一队列中的消息顺序性。
📝 分布式系统应用
RabbitMQ在分布式系统中应用广泛，如分布式任务队列、分布式锁等。
📝 性能优化
- 使用批量发送消息。
- 使用异步处理消息。
- 使用合适的交换器和队列类型。
📝 与Spring AMQP集成
Spring AMQP提供了RabbitMQ的封装，简化了消息传递过程。
@RabbitListener(queues = "queue-name")
public void processMessage(String message) {
// 处理消息
}
通过以上内容，我们可以了解到RabbitMQ中的ACK/NACK机制在消息传递过程中的重要作用，以及如何在实际项目中应用这些机制。
🍊 RabbitMQ知识点之ACK/NACK：工作原理
在分布式系统中，消息队列扮演着至关重要的角色，它能够有效地解耦生产者和消费者，提高系统的可用性和伸缩性。然而，在实际应用中，如何确保消息的可靠传递和正确处理，是一个需要深入探讨的问题。以RabbitMQ为例，其ACK/NACK机制正是为了解决这一问题而设计的。
场景问题：假设我们有一个复杂的分布式系统，其中一个服务负责处理用户订单，而另一个服务负责处理库存更新。订单服务在接收到新订单后，需要发送一个消息到库存服务，以便更新库存信息。如果在这个过程中，消息在传递过程中丢失或者处理失败，那么可能会导致订单和库存信息的不一致，从而引发一系列的问题。为了防止这种情况的发生，我们需要了解RabbitMQ的ACK/NACK机制。
介绍RabbitMQ知识点之ACK/NACK：工作原理的重要性：在消息队列中，ACK（Acknowledgement）和NACK（Negative Acknowledgement）机制是确保消息可靠传递的关键。ACK表示消息已经被成功处理，而NACK则表示消息处理失败，需要重新发送。通过引入ACK/NACK机制，我们可以保证消息的准确性和系统的稳定性，这对于维护高可用性和数据一致性至关重要。
接下来，我们将对RabbitMQ知识点之ACK/NACK：消息传递流程和确认机制进行详细阐述。首先，我们将介绍消息传递流程，包括消息的生产、传递和消费过程，以及如何在每个环节中正确地使用ACK/NACK。随后，我们将深入探讨确认机制的原理，包括自动确认和手动确认的区别，以及如何根据实际需求选择合适的确认模式。通过这些内容的介绍，读者将能够全面理解RabbitMQ的ACK/NACK机制，并在实际项目中正确应用。
🎉 RabbitMQ 消息传递流程
在 RabbitMQ 中，消息传递流程是确保消息能够从生产者发送到消费者的一系列步骤。下面，我们将详细探讨这一流程，并对比与列举其中的关键环节。
📝 消息传递流程概述
RabbitMQ 的消息传递流程可以概括为以下几个步骤：
- 生产者发送消息：生产者将消息发送到 RabbitMQ 的交换器（Exchange）。
- 交换器路由消息：交换器根据路由键（Routing Key）将消息路由到对应的队列（Queue）。
- 队列存储消息：消息被存储在队列中，等待消费者消费。
- 消费者从队列获取消息：消费者从队列中获取消息并进行处理。
- 消息确认：消费者处理完消息后，会向 RabbitMQ 发送确认（ACK）或拒绝（NACK）信号。
📝 消息传递流程对比与列举
以下表格对比了消息传递流程中的关键环节：
| 环节 | 描述 | 代码示例 |
|---|---|---|
| 生产者发送消息 | 生产者将消息发送到交换器 | ```python |
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel()
channel.exchange_declare(exchange='logs', exchange_type='direct') channel.queue_declare(queue='info') channel.queue_bind(queue='info', exchange='logs', routing_key='info')
channel.basic_publish(exchange='logs', routing_key='info', body='info message') connection.close()
| 交换器路由消息 | 交换器根据路由键将消息路由到队列 | ```python
# 🌟 交换器声明和队列绑定已在上述代码中完成
``` |
| 队列存储消息 | 消息被存储在队列中 | 无需代码示例，RabbitMQ 自动完成 |
| 消费者从队列获取消息 | 消费者从队列中获取消息并进行处理 | ```python
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
channel.basic_consume(queue='info', on_message_callback=callback, auto_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
``` |
| 消息确认 | 消费者处理完消息后，发送确认或拒绝信号 | ```python
# 🌟 在 callback 函数中，将 auto_ack 参数设置为 False
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
# 消费者处理完消息后，手动发送确认
channel.basic_ack(delivery_tag=method.delivery_tag)
``` |
### 🎉 ACK 机制
ACK（Acknowledgement）机制是 RabbitMQ 中确保消息传递可靠性的关键。以下是 ACK 机制的相关内容：
#### 📝 ACK 机制概述
1. **消费者确认**：消费者在处理完消息后，向 RabbitMQ 发送确认信号，表示消息已被成功处理。
2. **生产者确认**：生产者在消息发送到队列后，等待消费者发送确认信号。
3. **消息重试**：如果消费者在指定时间内未发送确认信号，RabbitMQ 会将消息重新发送给其他消费者。
#### 📝 ACK 机制对比与列举
以下表格对比了 ACK 机制中的关键环节：
| 环节 | 描述 | 代码示例 |
| --- | --- | --- |
| 消费者确认 | 消费者处理完消息后，发送确认信号 | ```python
# 🌟 在 callback 函数中，将 auto_ack 参数设置为 False
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
# 消费者处理完消息后，手动发送确认
channel.basic_ack(delivery_tag=method.delivery_tag)
``` |
| 生产者确认 | 生产者在消息发送到队列后，等待消费者发送确认信号 | 无需代码示例，RabbitMQ 自动完成 |
| 消息重试 | 如果消费者在指定时间内未发送确认信号，RabbitMQ 会将消息重新发送给其他消费者 | 无需代码示例，RabbitMQ 自动完成 |
### 🎉 NACK 机制
NACK（Negative Acknowledgement）机制是 RabbitMQ 中处理消息拒绝的一种机制。以下是 NACK 机制的相关内容：
#### 📝 NACK 机制概述
1. **消费者拒绝消息**：消费者在处理完消息后，向 RabbitMQ 发送拒绝信号，表示消息处理失败。
2. **消息重新入队**：RabbitMQ 将拒绝的消息重新入队，等待其他消费者处理。
#### 📝 NACK 机制对比与列举
以下表格对比了 NACK 机制中的关键环节：
| 环节 | 描述 | 代码示例 |
| --- | --- | --- |
| 消费者拒绝消息 | 消费者处理完消息后，发送拒绝信号 | ```python
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
# 消费者处理完消息后，手动发送拒绝信号
channel.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
``` |
| 消息重新入队 | RabbitMQ 将拒绝的消息重新入队，等待其他消费者处理 | 无需代码示例，RabbitMQ 自动完成 |
### 🎉 消息确认与消息拒绝
消息确认与消息拒绝是 RabbitMQ 中确保消息传递可靠性的重要机制。以下是这两个机制的相关内容：
#### 📝 消息确认
1. **消费者确认**：消费者在处理完消息后，向 RabbitMQ 发送确认信号，表示消息已被成功处理。
2. **生产者确认**：生产者在消息发送到队列后，等待消费者发送确认信号。
3. **消息重试**：如果消费者在指定时间内未发送确认信号，RabbitMQ 会将消息重新发送给其他消费者。
#### 📝 消息拒绝
1. **消费者拒绝消息**：消费者在处理完消息后，向 RabbitMQ 发送拒绝信号，表示消息处理失败。
2. **消息重新入队**：RabbitMQ 将拒绝的消息重新入队，等待其他消费者处理。
### 🎉 消息重试
消息重试是 RabbitMQ 中处理消息失败的一种机制。以下是消息重试的相关内容：
#### 📝 消息重试概述
1. **消费者重试**：消费者在处理完消息后，如果发现消息处理失败，会自动重新尝试处理该消息。
2. **生产者重试**：生产者在消息发送到队列后，如果消费者在指定时间内未发送确认信号，RabbitMQ 会将消息重新发送给其他消费者。
#### 📝 消息重试对比与列举
以下表格对比了消息重试中的关键环节：
| 环节 | 描述 | 代码示例 |
| --- | --- | --- |
| 消费者重试 | 消费者在处理完消息后，如果发现消息处理失败，会自动重新尝试处理该消息 | 无需代码示例，RabbitMQ 自动完成 |
| 生产者重试 | 生产者在消息发送到队列后，如果消费者在指定时间内未发送确认信号，RabbitMQ 会将消息重新发送给其他消费者 | 无需代码示例，RabbitMQ 自动完成 |
### 🎉 消费者确认与生产者确认
消费者确认与生产者确认是 RabbitMQ 中确保消息传递可靠性的重要机制。以下是这两个机制的相关内容：
#### 📝 消费者确认
1. **消费者确认**：消费者在处理完消息后，向 RabbitMQ 发送确认信号，表示消息已被成功处理。
2. **生产者确认**：生产者在消息发送到队列后，等待消费者发送确认信号。
#### 📝 生产者确认
1. **生产者确认**：生产者在消息发送到队列后，等待消费者发送确认信号。
### 🎉 事务管理
事务管理是 RabbitMQ 中确保消息传递一致性的重要机制。以下是事务管理的相关内容：
#### 📝 事务管理概述
1. **开启事务**：生产者在发送消息前，开启一个事务。
2. **发送消息**：生产者在事务中发送消息。
3. **提交事务**：生产者在消息发送成功后，提交事务，确保消息传递一致性。
#### 📝 事务管理对比与列举
以下表格对比了事务管理中的关键环节：
| 环节 | 描述 | 代码示例 |
| --- | --- | --- |
| 开启事务 | 生产者在发送消息前，开启一个事务 | ```python
channel.start_transaction()
``` |
| 发送消息 | 生产者在事务中发送消息 | ```python
channel.basic_publish(exchange='logs', routing_key='info', body='info message')
``` |
| 提交事务 | 生产者在消息发送成功后，提交事务，确保消息传递一致性 | ```python
channel.commit()
``` |
### 🎉 消息持久化
消息持久化是 RabbitMQ 中确保消息不会丢失的重要机制。以下是消息持久化的相关内容：
#### 📝 消息持久化概述
1. **设置消息持久化**：生产者在发送消息时，设置消息持久化标志。
2. **消息存储在磁盘**：RabbitMQ 将持久化的消息存储在磁盘上，确保消息不会丢失。
#### 📝 消息持久化对比与列举
以下表格对比了消息持久化中的关键环节：
| 环节 | 描述 | 代码示例 |
| --- | --- | --- |
| 设置消息持久化 | 生产者在发送消息时，设置消息持久化标志 | ```python
channel.basic_publish(exchange='logs', routing_key='info', body='info message', properties=pika.BasicProperties(delivery_mode=2,)))
``` |
| 消息存储在磁盘 | RabbitMQ 将持久化的消息存储在磁盘上，确保消息不会丢失 | 无需代码示例，RabbitMQ 自动完成 |
### 🎉 消息队列可靠性
消息队列可靠性是 RabbitMQ 中确保消息传递可靠性的重要指标。以下是消息队列可靠性的相关内容：
#### 📝 消息队列可靠性概述
1. **消息确认**：消费者在处理完消息后，向 RabbitMQ 发送确认信号，表示消息已被成功处理。
2. **消息持久化**：RabbitMQ 将持久化的消息存储在磁盘上，确保消息不会丢失。
3. **事务管理**：生产者在发送消息前，开启一个事务，确保消息传递一致性。
#### 📝 消息队列可靠性对比与列举
以下表格对比了消息队列可靠性中的关键环节：
| 环节 | 描述 | 代码示例 |
| --- | --- | --- |
| 消息确认 | 消费者在处理完消息后，向 RabbitMQ 发送确认信号，表示消息已被成功处理 | ```python
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
# 消费者处理完消息后，手动发送确认
channel.basic_ack(delivery_tag=method.delivery_tag)
``` |
| 消息持久化 | RabbitMQ 将持久化的消息存储在磁盘上，确保消息不会丢失 | ```python
channel.basic_publish(exchange='logs', routing_key='info', body='info message', properties=pika.BasicProperties(delivery_mode=2,)))
``` |
| 事务管理 | 生产者在发送消息前，开启一个事务，确保消息传递一致性 | ```python
channel.start_transaction()
channel.basic_publish(exchange='logs', routing_key='info', body='info message')
channel.commit()
``` |
### 🎉 错误处理
错误处理是 RabbitMQ 中确保系统稳定运行的重要机制。以下是错误处理的相关内容：
#### 📝 错误处理概述
1. **捕获异常**：在代码中捕获 RabbitMQ 相关异常。
2. **记录日志**：记录异常信息，方便问题排查。
3. **重试机制**：在出现异常时，尝试重新执行操作。
#### 📝 错误处理对比与列举
以下表格对比了错误处理中的关键环节：
| 环节 | 描述 | 代码示例 |
| --- | --- | --- |
| 捕获异常 | 在代码中捕获 RabbitMQ 相关异常 | ```python
try:
# RabbitMQ
最低0.47元/天 解锁文章
扫一扫
1329
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
