（面试宝典）超详细的RabbitMQ入门，看这篇就够了。

🏆作者简介，普修罗双战士，一直追求不断学习和成长，在技术的道路上持续探索和实践。
🏆多年互联网行业从业经验，历任核心研发工程师，项目技术负责人。
🎉欢迎 👍点赞✍评论⭐收藏

RabbitMQ 知识专栏学习

RabbitMQ知识云集	访问地址	备注
RabbitMQ知识点(1)	https://blog.csdn.net/m0_50308467/article/details/134537157	RabbitMQ专栏
RabbitMQ知识点(2)	https://blog.csdn.net/m0_50308467/article/details/134537277	RabbitMQ专栏
RabbitMQ知识点(3)	https://blog.csdn.net/m0_50308467/article/details/134537350	RabbitMQ专栏

🔎 RabbitMQ 入门学习(3)

🍁01、集群中的节点类型？

集群中的节点类型 集群中的节点类型有两种：主节点和从节点。主节点负责协调集群中的所有节点，并管理集群中的所有数据。从节点负责存储集群中的数据。

主节点是集群中的管理节点，负责协调集群中的所有节点，并管理集群中的所有数据。主节点通常是集群中性能最强的节点，并且具有足够的存储空间来存储集群中的数据。主节点还负责执行集群中的所有管理任务，例如创建和删除节点、配置节点、监控节点、故障排除节点等。

从节点是集群中的存储节点，负责存储集群中的数据。从节点通常是集群中性能较弱的节点，并且具有较小的存储空间。从节点不执行任何管理任务，只负责存储数据。

集群中的节点类型可以根据需要进行调整。例如，如果集群中的数据量很大，则可以增加从节点的数量。如果集群中的数据量很小，则可以减少从节点的数量。

🍁02、集群节点类型有几种？

集群节点类型 集群节点类型有两种：主节点和从节点。主节点负责协调集群中的所有节点，并管理集群中的所有数据。从节点负责存储集群中的数据。

主节点是集群中的管理节点，负责协调集群中的所有节点，并管理集群中的所有数据。主节点通常是集群中性能最强的节点，并且具有足够的存储空间来存储集群中的数据。主节点还负责执行集群中的所有管理任务，例如创建和删除节点、配置节点、监控节点、故障排除节点等。

从节点是集群中的存储节点，负责存储集群中的数据。从节点通常是集群中性能较弱的节点，并且具有较小的存储空间。从节点不执行任何管理任务，只负责存储数据。

集群中的节点类型可以根据需要进行调整。例如，如果集群中的数据量很大，则可以增加从节点的数量。如果集群中的数据量很小，则可以减少从节点的数量。

🍁03、Consumer Cancellation Notification 机制用于什么场景？

Consumer Cancellation Notification（消费者取消通知）机制用于处理消息队列中的消费者取消订阅的场景。当使用消息队列进行消息传递时，消费者可以订阅特定的消息队列或主题来接收消息。然而，有时候消费者可能需要取消订阅，不再接收消息。

在这种情况下，Consumer Cancellation Notification机制允许消费者向消息队列发送取消订阅的通知。一旦消息队列接收到取消订阅的通知，它将停止将消息发送给该消费者。这样可以避免将不必要的消息发送给不再需要的消费者，提高系统的效率和性能。

Consumer Cancellation Notification机制可以应用于各种场景，例如：

1. 动态调整消费者数量：当系统负载变化时，可以根据需要动态增加或减少消费者的数量。取消订阅通知可以用于通知消息队列停止向特定消费者发送消息。

2. 消费者故障处理：如果消费者发生故障或不可用，可以发送取消订阅通知，以便消息队列停止向该消费者发送消息。这有助于确保消息不会丢失，并且可以在消费者恢复正常之后重新分配未处理的消息。

3. 动态路由消息：根据消费者的订阅状态，消息队列可以动态路由消息到合适的消费者。取消订阅通知可以触发重新分配消息的过程，以确保消息被正确地路由到其他消费者。

总之，Consumer Cancellation Notification机制可以帮助管理消息队列中的消费者订阅状态，确保消息的有效传递，并提供灵活性和可靠性。

🍁04、为什么 heavy RPC 的使用场景下不建议采用 disk node ？

heavy RPC 的使用场景下不建议采用 disk node ，因为 disk node 的性能较低，不适合处理大量的 RPC 请求。

disk node 的性能较低，主要有以下几个原因：

• disk node 的 CPU 和内存资源较少，无法处理大量的 RPC 请求。
• disk node 的磁盘 I/O 性能较低，无法满足大量的 RPC 请求。
• disk node 的网络带宽较低，无法满足大量的 RPC 请求。

因此，在 heavy RPC 的使用场景下，不建议采用 disk node。

如果需要处理大量的 RPC 请求，建议使用 memory node。memory node 的 CPU 和内存资源较多，可以处理大量的 RPC 请求。memory node 的磁盘 I/O 性能较高，可以满足大量的 RPC 请求。memory node 的网络带宽较高，可以满足大量的 RPC 请求。

总之，在 heavy RPC 的使用场景下，建议使用 memory node，而不是 disk node。

🍁05、如何保证 RabbitMQ 不被重复消费？

RabbitMQ 是一个消息队列，它可以保证消息的顺序和可靠性。但是，如果没有采取额外的措施，RabbitMQ 可能会被重复消费。

以下是一些可以防止 RabbitMQ 被重复消费的方法：

• 使用消息确认。消息确认可以确保消息已经被消费者成功消费。
• 使用消息标签。消息标签可以用来标识消息的唯一性。
• 使用消息 TTL。消息 TTL 可以用来设置消息的过期时间。
• 使用消息队列的持久化功能。持久化功能可以确保消息即使在 RabbitMQ 服务器崩溃的情况下也不会丢失。

通过使用这些方法，可以有效地防止 RabbitMQ 被重复消费。

🍁06、如何避免消息重复投递或重复消费?

有以下几种方法可以避免消息重复投递或重复消费：

• 使用消息确认。消息确认可以确保消息已经被消费者成功消费。
• 使用消息标签。消息标签可以用来标识消息的唯一性。
• 使用消息 TTL。消息 TTL 可以用来设置消息的过期时间。
• 使用消息队列的持久化功能。持久化功能可以确保消息即使在消息队列服务器崩溃的情况下也不会丢失。

通过使用这些方法，可以有效地避免消息重复投递或重复消费。

🍁07、routing_key 和 binding_key 的最大长度是多少？

routing_key 和 binding_key 的最大长度是 255 个字符。

举例说明：

• routing_key 可以是 “foo”、“bar”、“baz” 等。
• binding_key 可以是 “foo.bar”、“bar.baz”、“baz.foo” 等。

routing_key 和 binding_key 是用来匹配消息的，所以它们的长度不能太长。如果长度太长，可能会导致消息匹配不准确。

🍁08、RabbitMQ 消息确认过程？

RabbitMQ 的消息确认过程如下：

1. 当消费者从队列中获取消息时，会发送一个确认消息给 RabbitMQ。
2. RabbitMQ 会将该消息标记为已确认。
3. 如果消费者在一定时间内没有发送确认消息，RabbitMQ 会将该消息重新发送给消费者。
4. 如果消费者在一定时间内仍然没有发送确认消息，RabbitMQ 会将该消息标记为丢失。

通过消息确认，可以确保消息不会丢失。

🍁09、RabbitMQ 如何实现延时队列?

RabbitMQ 可以通过以下两种方式实现延时队列：

• 使用插件。RabbitMQ 提供了一个插件，可以用来实现延时队列。使用插件实现延时队列，需要在 RabbitMQ 服务器上安装插件。
• 使用 exchange。RabbitMQ 提供了一个 exchange，可以用来实现延时队列。使用 exchange 实现延时队列，需要在 RabbitMQ 服务器上创建 exchange。

以下是一个使用 exchange 实现延时队列的例子：

1. 创建一个 exchange，并将其类型设置为 “x-delayed-message”。
2. 创建一个队列，并将其绑定到 exchange。
3. 在发送消息时，设置消息的 “x-delay” 属性。
4. 消费者可以从队列中获取消息。

当消息被发送到队列时，它会被延迟一段时间后才会被消费者获取。延迟时间由消息的 “x-delay” 属性指定。

🍁10、如何确保消息正确地发送至 RabbitMQ ？ 如何确保消息接收方消费了消息？

确保消息正确地发送至 RabbitMQ 可以通过以下几个步骤：

1. 建立连接：创建与 RabbitMQ 服务器的连接。
2. 创建通道：在连接上创建一个通道，用于消息的发布和接收。
3. 声明队列：在通道上声明一个队列，用于存储消息。
4. 发布消息：将消息发布到指定的队列中。
5. 消息确认：等待 RabbitMQ 发送确认消息，表示消息已经成功发送到队列中。

确保消息接收方消费了消息可以通过以下几个步骤：

1. 消费者连接：消费者建立与 RabbitMQ 服务器的连接。
2. 创建通道：在连接上创建一个通道，用于消息的接收。
3. 订阅队列：在通道上订阅要消费的队列。
4. 消费消息：从队列中获取消息并进行处理。
5. 消息确认：消费者发送确认消息给 RabbitMQ，表示消息已经成功消费。

通过消息确认机制，可以确保消息在发送和接收过程中的可靠性。如果消息发送或消费过程中出现异常，消息将会被重新发送或重新分发，以确保消息的可靠传递。

🍁11、为什么不应该对所有的 message 都使用持久化机制？

不应该对所有的 message 都使用持久化机制，因为持久化机制会增加消息的存储成本和网络传输成本。

持久化机制会将消息存储到磁盘上，这样即使 RabbitMQ 服务器崩溃，消息也不会丢失。但是，持久化机制也会增加消息的存储成本和网络传输成本。

因此，在使用持久化机制时，需要考虑以下因素：

• 消息的重要性。如果消息非常重要，那么应该使用持久化机制。
• 消息的数量。如果消息数量很多，那么使用持久化机制可能会增加存储成本和网络传输成本。
• 消息的大小。如果消息很大，那么使用持久化机制可能会增加存储成本和网络传输成本。

综合考虑以上因素，可以决定是否使用持久化机制。

🍁12、使用 Rabbitmq 的场景？

RabbitMQ 是一个消息队列，它可以用于以下场景：

• 异步通信：RabbitMQ 可以用于异步通信，即发送消息的一方不需要等待接收消息的一方确认消息已经收到。
• 解耦：RabbitMQ 可以用于解耦，即发送消息的一方和接收消息的一方可以独立工作，互不影响。
• 负载均衡：RabbitMQ 可以用于负载均衡，即将消息分发到多个消费者，从而提高系统的吞吐量。
• 消息持久化：RabbitMQ 可以用于消息持久化，即将消息存储到磁盘上，这样即使 RabbitMQ 服务器崩溃，消息也不会丢失。
• 消息分发：RabbitMQ 可以用于消息分发，即将消息分发到不同的队列，从而实现消息的分类和过滤。

总之，RabbitMQ 是一个非常灵活和强大的消息队列，它可以用于各种不同的场景。

🍁13、解耦、异步、削峰是什么？

解耦：解耦是指将两个或多个系统、组件或模块之间的相互依赖关系降低到最小程度，从而使它们可以独立地开发、测试和部署。

异步：异步是指在一个进程或线程执行某个任务时，另一个进程或线程可以继续执行其他任务，而不需要等待第一个任务完成。

削峰：削峰是指在高峰时段，将流量分散到平时时段，从而避免系统崩溃。

解耦、异步和削峰都是在软件开发中常用的设计模式，它们可以提高系统的灵活性、可扩展性和可靠性。

🍁14、交换器无法根据自身类型和路由键找到符合条件队列时，有哪些处理？

当交换器无法根据自身类型和路由键找到符合条件队列时，有以下几种处理方式：

• 丢弃消息。如果交换器的类型是 direct 或 topic，那么它会丢弃消息。如果交换器的类型是 fanout，那么它会将消息广播到所有绑定的队列。
• 将消息发送到默认队列。如果交换器设置了默认队列，那么它会将消息发送到默认队列。
• 将消息发送到死信队列。如果交换器设置了死信队列，那么它会将消息发送到死信队列。

默认队列和死信队列都是由 RabbitMQ 自动创建的。默认队列的名称是 “amq.default”，死信队列的名称是 “amq.deadletter”。

🍁15、cluster 中 node 的失效会对 consumer 产生什么影响？若是在 cluster 中创建了mirrored queue ，这时 node 失效会对 consumer 产生什么影响？

cluster 中 node 的失效会对 consumer 产生以下影响：

• 消费者可能会收到重复消息。
• 消费者可能会收到丢失的消息。
• 消费者可能会收到错误的消息。

如果在 cluster 中创建了 mirrored queue，这时 node 失效会对 consumer 产生以下影响：

• 消费者可能会收到重复消息。
• 消费者可能会收到丢失的消息。
• 消费者可能会收到错误的消息。

但是，由于 mirrored queue 是镜像队列，所以消费者仍然可以从其他 node 中获取消息。因此，消费者不会完全无法消费消息。

为了避免消费者收到重复消息、丢失消息或错误消息，可以使用以下方法：

• 使用消息确认机制。
• 使用消息持久化机制。
• 使用死信队列。

通过使用这些机制，可以确保消费者不会收到重复消息、丢失消息或错误消息。

🍁16、如何保证 RabbitMQ 消息的顺序性？

有以下几种方法可以保证 RabbitMQ 消息的顺序性：

• 使用 direct 交换器。direct 交换器将消息路由到与 routing key 完全匹配的队列。因此，如果消息的 routing key 是严格递增的，那么消息就会按照发送的顺序被消费。
• 使用 topic 交换器。topic 交换器将消息路由到与 routing key 部分匹配的队列。因此，如果消息的 routing key 是严格递增的，那么消息就会按照发送的顺序被消费。
• 使用 fanout 交换器。fanout 交换器将消息广播到所有绑定的队列。因此，如果消息的 routing key 是严格递增的，那么消息就会按照发送的顺序被消费。
• 使用死信队列。死信队列是专门用来存储消息的队列。如果消息在队列中停留的时间超过了指定的 TTL 时间，那么它就会被转发到死信队列。因此，如果消息的 TTL 时间是严格递增的，那么消息就会按照发送的顺序被消费。

通过使用这些方法，可以保证 RabbitMQ 消息的顺序性。

🍁17、如何保证RabbitMQ 的集群高可用的？

有以下几种方法可以保证 RabbitMQ 的集群高可用：

• 使用镜像队列。镜像队列是指在集群中创建多个相同的队列，并将它们绑定到相同的交换器。如果一个队列发生故障，则另一个队列可以继续提供服务。
• 使用分布式锁。分布式锁可以防止多个节点同时访问同一个资源。如果一个节点获取了分布式锁，则其他节点将无法访问该资源。
• 使用消息确认。消息确认可以确保消息已经被消费者成功消费。如果消费者没有确认消息，则消息将被重新发送到队列。
• 使用死信队列。死信队列是专门用来存储消息的队列。如果消息在队列中停留的时间超过了指定的 TTL 时间，则它将被转发到死信队列。

通过使用这些方法，可以保证 RabbitMQ 的集群高可用。

🍁18、多个消费者监听一个队列时，消息如何分发?

当多个消费者监听一个队列时，消息会按照以下方式分发：

1. 消费者会从队列中轮询消息。
2. 如果队列中有多个消息，则消费者会按照轮询顺序从队列中获取消息。
3. 如果队列中只有一个消息，则消费者会直接从队列中获取消息。

通过这种方式，可以保证多个消费者能够公平地获取消息。

🍁19、客户端连接到 cluster 中的任意 node 上是否都能正常工作？

客户端连接到 cluster 中的任意 node 上都可以正常工作。

RabbitMQ 是一个分布式消息队列，它可以通过多个节点组成一个集群。当客户端连接到 cluster 中的任意 node 上时，它可以访问整个集群中的所有资源。因此，客户端连接到 cluster 中的任意 node 上都可以正常工作。

但是，如果客户端连接到一个故障的 node 上，那么它可能会无法访问集群中的其他资源。因此，建议客户端连接到一个健康的 node 上。

🍁20、消费者接收消息过程？

消费者接收消息的过程如下：

1. 消费者连接到 RabbitMQ 服务器。
2. 消费者创建一个通道。
3. 消费者订阅一个队列。
4. 消费者从队列中获取消息。
5. 消费者处理消息。
6. 消费者确认消息。

通过以上步骤，消费者可以成功接收消息。

🍁21、消费者某些原因无法处理当前接受的消息如何来拒绝？

消费者在某些情况下可能无法处理当前接收的消息，可以使用以下方法来拒绝消息：

1. 使用 basic.reject 方法：消费者可以使用 basic.reject 方法来显式地拒绝消息。该方法可以指定是否将消息重新排队以供重新投递，或者直接将消息丢弃。

2. 使用 basic.nack 方法：消费者可以使用 basic.nack 方法来拒绝消息，并指定是否将消息重新排队以供重新投递。与 basic.reject 不同的是，basic.nack 还可以一次拒绝多个消息。

在拒绝消息时，可以选择将消息重新排队以供重新投递，或者直接将消息丢弃。这取决于具体的业务需求和消息的重要性。

🍁22、如何避免消息重复投递或重复消费？

有以下几种方法可以避免消息重复投递或重复消费：

• 使用消息确认机制。消息确认机制可以确保消息已经被消费者成功消费。如果消费者没有确认消息，则消息将被重新发送到队列。
• 使用消息标签。消息标签可以用来标识消息的唯一性。如果消费者收到了重复的消息，则可以根据消息标签进行判断。
• 使用消息 TTL。消息 TTL 可以用来设置消息的过期时间。如果消息在过期时间内没有被消费，则消息将被删除。
• 使用消息队列的持久化功能。持久化功能可以确保消息即使在 RabbitMQ 服务器崩溃的情况下也不会丢失。

通过使用这些方法，可以有效地避免消息重复投递或重复消费。

🍁23、RabbitMQ simple模式（即最简单的收发模式）？

RabbitMQ simple模式（即最简单的收发模式）

RabbitMQ simple模式是RabbitMQ最简单的收发模式，它只需要一个生产者和一个消费者。生产者将消息发送到队列，消费者从队列中获取消息。

以下是使用RabbitMQ simple模式的步骤：

1. 创建一个RabbitMQ实例。
2. 创建一个生产者。
3. 创建一个消费者。
4. 生产者将消息发送到队列。
5. 消费者从队列中获取消息。

以下是一个使用RabbitMQ simple模式的示例代码：

import pika

# 创建一个RabbitMQ实例
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建一个生产者
channel = connection.channel()

# 创建一个队列
channel.queue_declare(queue='hello')

# 生产者将消息发送到队列
channel.basic_publish(exchange='', routing_key='hello', body='Hello World!')

# 关闭连接
connection.close()
import pika

# 创建一个RabbitMQ实例
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建一个消费者
channel = connection.channel()

# 创建一个队列
channel.queue_declare(queue='hello')

# 消费者从队列中获取消息
def callback(ch, method, properties, body):
    print(body)

# 消费者订阅队列
channel.basic_consume(queue='hello', on_message_callback=callback)

# 启动消费者
channel.start_consuming()

通过使用RabbitMQ simple模式，我们可以实现最简单的消息收发。

🍁24、无法被路由的消息去了哪里?

无法被路由的消息会被发送到死信队列。死信队列是一个特殊的队列，用于存储无法被路由的消息。

当消息无法被路由时，有以下几种可能的原因：

• 消息的 routing key 不正确。
• 消息的 exchange 不存在。
• 消息的 exchange 没有绑定到任何队列。
• 消息的队列不存在。

如果消息无法被路由，那么它会被发送到死信队列。死信队列是一个特殊的队列，用于存储无法被路由的消息。死信队列可以由用户创建，也可以由 RabbitMQ 自动创建。

当消息被发送到死信队列时，会触发一个死信事件。死信事件可以由用户处理，也可以由 RabbitMQ 自动处理。如果用户没有处理死信事件，那么 RabbitMQ 会将死信消息重新发送到队列。

如果用户想要处理死信事件，可以使用 RabbitMQ 提供的 API 来实现。RabbitMQ 提供的 API 包括：

• basic.get_message：获取死信消息。
• basic.ack：确认死信消息。
• basic.nack：拒绝死信消息。

通过使用这些 API，用户可以实现对死信消息的处理。

🍁25、RabbitMQ概念里的channel、exchange 和 queue是逻辑概念，还是对应着进程实体？作用分别是什么？

在 RabbitMQ 的概念中，channel、exchange 和 queue 都是逻辑概念，而不是对应着具体的进程实体。

• Channel（通道）：Channel 是在连接（Connection）内部创建的虚拟连接。它是进行消息传输的主要工具。通过在同一个连接上创建多个通道，可以在不同的通道上进行并发的消息传输。每个通道都拥有自己的独立状态和配置信息，但它们共享相同的连接。使用通道可以减少网络开销，并提高消息传输的效率。

• Exchange（交换器）：Exchange 是消息的分发中心，用于接收生产者发送的消息，并根据特定的规则将消息路由到一个或多个队列。Exchange 接收消息，并根据消息的路由键（routing key）将消息发送到绑定的队列。Exchange 的类型包括 direct、topic、fanout、headers 等，不同的类型决定了消息的路由规则。

• Queue（队列）：Queue 是消息的存储区域，用于存储待被消费的消息。消费者从队列中获取消息并进行处理。每个队列都有一个名称，并且可以绑定到一个或多个交换器。消息在被发送到队列之前，需要通过交换器进行路由。

总结：Channel 是在连接内部创建的虚拟连接，用于进行消息传输；Exchange 是消息的分发中心，根据规则将消息路由到队列；Queue 是消息的存储区域，存储待被消费的消息。它们共同协作，实现了 RabbitMQ 的消息传输和分发机制。

🍁26、消费者接收消息过程？

消费者接收消息的过程如下：

1. 消费者连接到 RabbitMQ 服务器。
2. 消费者创建一个通道。
3. 消费者订阅一个队列。
4. 消费者从队列中获取消息。
5. 消费者处理消息。
6. 消费者确认消息。

如果消费者在一定时间内没有确认消息，RabbitMQ 会将该消息重新发送给消费者。

🍁27、RabbitMQ 上的一个 queue 中存放的 message 是否有数量限制？

RabbitMQ 上的一个 queue 中存放的 message 是有数量限制的。默认情况下，一个 queue 中可以存放 10000 条 message。如果 queue 中的消息数量超过了这个限制，那么 RabbitMQ 会自动删除最早的消息。

可以通过设置 queue 的 max-length 属性来修改 queue 中消息的数量限制。

🍁28、向不存在的 exchange 发 publish 消息会发生什么？向不存在的 queue 执行consume 动作会发生什么？

向不存在的 exchange 发 publish 消息会导致消息被丢弃。

向不存在的 queue 执行 consume 动作会导致消费者一直处于等待状态。

🍁29、消息如何保证幂等性？

消息可以通过以下方式保证幂等性：

• 使用消息 ID。消息 ID 是消息的唯一标识，可以用来保证消息不会被重复消费。
• 使用消息确认。消息确认可以确保消息已经被消费者成功消费。如果消息没有被确认，则消息会被重新发送。
• 使用消息持久化。消息持久化可以确保消息即使在 RabbitMQ 服务器崩溃的情况下也不会丢失。

通过使用这些方法，可以保证消息的幂等性。

🍁30、RabbitMQ 中消息可能有的几种状态?

RabbitMQ 中消息可能有的几种状态如下：

• 未确认：消息发送到队列后，还没有被消费者确认。
• 已确认：消息被消费者确认后，会从队列中删除。
• 已删除：消息从队列中删除。
• 已过期：消息在队列中停留的时间超过了 TTL 时间，会被自动删除。
• 已拒绝：消息被消费者拒绝后，会从队列中删除。

通过这些状态，可以了解消息的处理情况。