RabbitMQ入门：轻松掌握消息队列基础知识-原创手记-慕课网

概述

本文介绍了消息队列的基础知识，包括RabbitMQ的概念、作用和优势，详细讲解了RabbitMQ的安装与配置，并提供了生产者和消费者的示例代码。此外，还涉及了RabbitMQ的基本概念和常用命令。

RabbitMQ简介

RabbitMQ是什么

RabbitMQ 是一个开源的消息代理软件（也称消息中间件），它实现了高级消息队列协议（AMQP）。AMQP 是一个提供标准接口的协议，使得不同消息系统之间可以实现互操作。RabbitMQ 的设计目标是实现一个高度可靠、灵活的消息传递系统，它支持多种编程语言，包括但不限于Java、Python、Ruby、C++、Erlang等。

RabbitMQ的作用和优势

RabbitMQ 主要用于解耦应用程序组件，使得系统能够更高效地处理异步通信。其主要作用包括：

解耦系统：通过消息队列，服务之间可以解耦，发送者无需等待接收者，可以直接将消息发送到队列中。
负载均衡：消息队列可以将负载分散到多个消费者上，实现负载均衡。
错误处理：消息队列提供了重试机制，保证消息不会因为接收者的故障而丢失。
性能提升：异步处理方式可以提升系统的整体性能，使得系统更加灵活和稳定。

RabbitMQ的安装与配置

安装

RabbitMQ 可以在多种操作系统上安装，这里以 Linux 系统为例说明安装方法：

# 添加RabbitMQ的APT仓库
wget https://github.com/rabbitmq/signature-packages/releases/download/latest/rabbitmq-signature-key.asc
sudo apt-get update
sudo apt-get install curl
curl https://packages.rabbitmq.com/rabbitmq-signature-key.asc | sudo apt-key add -
echo "deb https://packages.rabbitmq.com/rabbitmq-erlang/debian/ buster main" | sudo tee /etc/apt/sources.list.d/rabbitmq.list
sudo apt-get update

# 安装RabbitMQ
sudo apt-get install rabbitmq-server

# 启动RabbitMQ服务
sudo systemctl enable rabbitmq-server
sudo systemctl start rabbitmq-server

配置

RabbitMQ 的配置可以通过编辑 rabbitmq.config 文件来完成。该文件通常位于 /etc/rabbitmq/ 目录下。以下是一个简单的配置示例，设置默认虚拟机名称：

[
    {rabbit, [
        {default_vhost, <<"my_vhost">>}
    ]}
].

RabbitMQ的基本概念

消息模型

RabbitMQ 的消息模型是基于生产者和消费者模型的。生产者发布消息，消费者接收消息。消息从生产者发送到交换器，然后根据交换器的类型和绑定规则被路由到一个或多个队列，最后由消费者从队列中接收消息。

交换器与队列

交换器（Exchange）：负责接收消息并将这些消息路由到一个或多个队列，交换器有多种类型，如 Direct、Fanout、Topic 等。
队列（Queue）：是实际存储消息的地方，消费者从队列中接收消息。
绑定（Binding）：交换器与队列之间的关联关系，定义了消息如何从交换器路由到队列。

生产者与消费者

生产者（Producer）：负责发送消息到交换器。
消费者（Consumer）：负责从队列中接收消息。

示例代码

生产者示例

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个交换器
channel.exchange_declare(exchange='logs', exchange_type='fanout')

# 发布消息到交换器
message = 'Hello World!'
channel.basic_publish(exchange='logs', routing_key='', body=message)

print(f"Sent message '{message}'")

# 关闭连接
connection.close()

消费者示例

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个交换器
channel.exchange_declare(exchange='logs', exchange_type='fanout')

# 声明一个队列
result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue

# 绑定交换器和队列
channel.queue_bind(exchange='logs', queue=queue_name, routing_key='info')

# 定义回调函数
def callback(ch, method, properties, body):
    print(f"Received message: {body}")

# 开始消费
channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)

print('Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
``

### 交换器、队列和绑定

#### 交换器类型

- **Direct**：将消息路由到匹配绑定键（routing key）的队列。
- **Fanout**：将消息路由到所有绑定到该交换器的队列。
- **Topic**：使用模式匹配来路由消息。
- **Headers**：基于消息头（headers）来路由消息。

#### 示例代码
**使用 Topic 交换器的生产者示例**
```python
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个交换器
channel.exchange_declare(exchange='topic_logs', exchange_type='topic')

# 发布消息到交换器
message = 'info: Hello World!'
channel.basic_publish(exchange='topic_logs', routing_key='info', body=message)

print(f"Sent message '{message}'")

# 关闭连接
connection.close()

使用 Topic 交换器的消费者示例

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个交换器
channel.exchange_declare(exchange='topic_logs', exchange_type='topic')

# 声明一个队列
result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue

# 绑定交换器和队列
channel.queue_bind(exchange='topic_logs', queue=queue_name, routing_key='info')

# 定义回调函数
def callback(ch, method, properties, body):
    print(f"Received message: {body}")

# 开始消费
channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)

print('Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

RabbitMQ的常用命令

启动与停止RabbitMQ服务

启动 RabbitMQ 服务：

sudo systemctl start rabbitmq-server

停止 RabbitMQ 服务：

sudo systemctl stop rabbitmq-server

查看节点信息

查看 RabbitMQ 节点信息：

sudo rabbitmqctl status

管理队列、交换器和绑定

管理队列

查看所有队列：

sudo rabbitmqctl list_queues

删除队列：

sudo rabbitmqctl delete_queue <queue_name>

管理交换器

查看所有交换器：

sudo rabbitmqctl list_exchanges

删除交换器：

sudo rabbitmqctl delete_exchange <exchange_name>

管理绑定

查看所有绑定：

sudo rabbitmqctl list_bindings

删除绑定：

sudo rabbitmqctl unbind_queue <queue_name> <exchange_name> <routing_key>

RabbitMQ的实际使用案例

发送简单消息

生产者示例

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个交换器
channel.exchange_declare(exchange='direct_logs', exchange_type='direct')

# 发布消息到交换器
message = 'Hello World!'
channel.basic_publish(exchange='direct_logs', routing_key='info', body=message)

print(f"Sent message '{message}'")

# 关闭连接
connection.close()

消费者示例

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个交换器
channel.exchange_declare(exchange='direct_logs', exchange_type='direct')

# 声明一个队列
result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue

# 绑定交换器和队列
channel.queue_bind(exchange='direct_logs', queue=queue_name, routing_key='info')

# 定义回调函数
def callback(ch, method, properties, body):
    print(f"Received message: {body}")

# 开始消费
channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)

print('Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

接收简单消息

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个队列
channel.queue_declare(queue='hello')

# 定义回调函数
def callback(ch, method, properties, body):
    print(f"Received message: {body}")

# 开始消费
channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)

print('Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

使用不同类型的交换器

Fanout 交换器

生产者示例

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个交换器
channel.exchange_declare(exchange='fanout_logs', exchange_type='fanout')

# 发布消息到交换器
message = 'Hello World!'
channel.basic_publish(exchange='fanout_logs', routing_key='', body=message)

print(f"Sent message '{message}'")

# 关闭连接
connection.close()

消费者示例

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个交换器
channel.exchange_declare(exchange='fanout_logs', exchange_type='fanout')

# 声明一个队列
result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue

# 绑定交换器和队列
channel.queue_bind(exchange='fanout_logs', queue=queue_name)

# 定义回调函数
def callback(ch, method, properties, body):
    print(f"Received message: {body}")

# 开始消费
channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)

print('Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

Topic 交换器

生产者示例

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个交换器
channel.exchange_declare(exchange='topic_logs', exchange_type='topic')

# 发布消息到交换器
message = 'info: Hello World!'
channel.basic_publish(exchange='topic_logs', routing_key='info', body=message)

print(f"Sent message '{message}'")

# 关闭连接
connection.close()

消费者示例

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个交换器
channel.exchange_declare(exchange='topic_logs', exchange_type='topic')

# 声明一个队列
result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue

# 绑定交换器和队列
channel.queue_bind(exchange='topic_logs', queue=queue_name, routing_key='info')

# 定义回调函数
def callback(ch, method, properties, body):
    print(f"Received message: {body}")

# 开始消费
channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)

print('Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

RabbitMQ的高级特性

消息持久化

消息持久化是指将消息存储到磁盘中，以确保在 RabbitMQ 服务器重启后消息不会丢失。持久化消息需要将消息和队列都设置为持久化。

示例代码

生产者示例

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))

# 创建信道
channel = connection.channel()

# 声明一个持久化的队列
channel.queue_declare(queue='hello', durable=True)

# 发布一个持久化消息
message = 'Hello World!'
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body=message,
                      properties=pika.BasicProperties(
                          delivery_mode=2  # 消息持久化
                      ))

print(f"Sent message '{message}'")

# 关闭连接
connection.close()

消费者示例


import pika

# 创建连接
connection = p Catalog of all the pages: 
1. RabbitMQ入门：轻松掌握消息队列基础知识
2. RabbitMQ简介
3. RabbitMQ的基本概念
4. RabbitMQ的常用命令
5. RabbitMQ的实际使用案例
6. RabbitMQ的高级特性