首页手记 RabbitMQ教程：新手入门与实践指南

RabbitMQ教程：新手入门与实践指南

标签：

中间件

概述

RabbitMQ是一款开源的消息代理软件，广泛应用于消息传递和任务分发等场景。本文将详细介绍RabbitMQ的环境搭建、核心概念解析以及基本操作，帮助新手快速入门。此外，文章还提供了丰富的示例代码，帮助读者更好地理解和实践RabbitMQ教程。

RabbitMQ教程：新手入门与实践指南

RabbitMQ简介

RabbitMQ是什么

RabbitMQ是一款开源的消息代理软件（也称为消息中间件），它使用AMQP（高级消息队列协议）进行消息的路由和传递。AMQP为消息的传输定义了一套标准的协议和消息格式。RabbitMQ能够轻松地将消息从一个应用发送到另一个应用，并支持多种编程语言和平台。

RabbitMQ的主要特性

RabbitMQ具有以下主要特性：

高可用性：RabbitMQ支持集群模式，通过节点间的复制和故障转移，确保了消息系统的高可用性。
多种消息队列模式：支持发布/订阅、路由、请求/响应等多种消息传递模式。
灵活性：支持多种编程语言和平台，包括Java、Python、Ruby、C、C++等。
可扩展性：通过水平扩展和负载均衡，可以很好地处理大流量的消息传递。
安全性：支持SSL/TLS安全传输，提供了用户名密码认证等多种安全机制。
管理界面：提供了一个Web管理界面，便于管理和监控消息队列。

RabbitMQ的应用场景

RabbitMQ广泛应用于各种消息传递场景，以下是一些典型的应用场景：

异步通信：在分布式系统中，使用消息队列可以实现异步通信，解耦系统组件。
任务分发：将任务通过消息队列分发到多个工作者节点，执行并返回结果。
流量削峰：在高并发场景下，使用消息队列可以缓冲请求，平滑流量。
日志聚合：将不同来源的日志消息发送到RabbitMQ，再由订阅者进行处理和存储。
事件驱动架构：可以将事件通过消息队列传递给多个消费者，实现灵活的事件处理。

RabbitMQ环境搭建

RabbitMQ的下载与安装

下载

访问RabbitMQ的官方网站下载最新版本的RabbitMQ，下载地址为https://www.rabbitmq.com/download.html。

安装

安装RabbitMQ的过程分为几个步骤：

安装Erlang：RabbitMQ基于Erlang语言实现，因此需要先安装Erlang。可以通过RabbitMQ官网提供的Erlang安装包进行安装。
安装RabbitMQ：下载RabbitMQ的安装包并解压，然后按照安装说明进行安装。

以下是在Linux环境下安装RabbitMQ的示例步骤：

# 下载Erlang安装包
wget https://packages.erlang-solutions.com/erlang/erlang-solutions_2.0_all.deb && sudo dpkg -i erlang-solutions_2.0_all.deb

# 安装Erlang
sudo apt-get update && sudo apt-get install erlang

# 下载RabbitMQ安装包
wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.11.1/rabbitmq-server_3.11.1-1_all.deb

# 安装RabbitMQ
sudo dpkg -i rabbitmq-server_3.11.1-1_all.deb

RabbitMQ的启动与停止

RabbitMQ可以通过命令行启动、停止和重启。以下是操作命令：

# 启动RabbitMQ
sudo systemctl start rabbitmq-server

# 停止RabbitMQ
sudo systemctl stop rabbitmq-server

# 重启RabbitMQ
sudo systemctl restart rabbitmq-server

RabbitMQ的管理界面使用

RabbitMQ自带了一个Web管理界面，可以通过以下步骤访问：

启动RabbitMQ管理插件：

sudo rabbitmq-plugins enable rabbitmq_management

访问管理界面：打开浏览器并访问http://localhost:15672，默认的用户名和密码分别为guest和guest。如果需要修改默认的用户名和密码，可以通过以下命令：
```
rabbitmqctl add_user your_username your_password
rabbitmqctl set_user_tags your_username administrator
rabbitmqctl set_permissions -p / your_username ".*" ".*" ".*"
```

RabbitMQ核心概念解析

交换器（Exchange）

交换器是RabbitMQ的核心概念，它负责接收消息并将其路由到队列中。消息的路由可以根据交换器的类型以及消息的路由键（routing key）来决定。

下面是几种常见的交换器类型：

direct交换器：基于路由键进行精确匹配。
fanout交换器：将消息广播到所有绑定的队列，不考虑路由键。
topic交换器：支持通配符的路由键匹配。
headers交换器：不使用路由键，而是根据消息头的值来路由消息。

示例代码

以下是一个使用Python的pika库创建一个direct交换器的示例：

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_logs', exchange_type='direct')

connection.close()

队列（Queue）

队列是存储消息的容器。消息会被发送到队列中，然后由消费者从队列中取出并处理。队列可以持久化，即使RabbitMQ服务重启，队列中的消息也不会丢失。

示例代码

以下是一个创建持久化队列的示例：

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello', durable=True)

connection.close()

绑定（Binding）

绑定是交换器和队列之间的关联。消息会根据绑定关系被路由到相应的队列。绑定关系需要指定路由键，以决定消息是否会被路由到该队列。

示例代码

以下是一个绑定队列到交换器的示例：

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='logs', exchange_type='fanout')
channel.queue_declare(queue='logs_queue')

channel.queue_bind(exchange='logs', queue='logs_queue')

connection.close()

消息（Message）

消息是RabbitMQ中传输的基本单元。消息由两部分组成：路由键和消息体。路由键用于路由消息，消息体是实际需要传递的数据。

示例代码

以下是一个发送消息的示例：

import pika

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()

RabbitMQ的基本操作

生产者与消费者的定义

生产者（Producer）负责发送消息到交换器，消费者（Consumer）从队列中接收并处理消息。生产者和消费者之间通过交换器和队列进行通信。

生产者示例代码

以下是一个简单的生产者示例：

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')

print(" [x] Sent 'Hello World!'")
connection.close()

消费者示例代码

以下是一个简单的消费者示例：

import pika

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

channel.basic_consume(queue='hello', 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.exchange_declare(exchange='logs', exchange_type='fanout')

channel.basic_publish(exchange='logs',
                      routing_key='',
                      body='An event has occurred!')

connection.close()

# 订阅者1
import pika

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

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)

channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)

print(' [*] Waiting for logs. To exit press CTRL+C')
channel.start_consuming()

# 订阅者2
import pika

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

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)

channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)

print(' [*] Waiting for logs. To exit press CTRL+C')
channel.start_consuming()

路由模式

路由模式是根据路由键将消息路由到特定的队列。生产者发送消息时指定路由键，交换器根据路由键将消息路由到相应的队列。

示例代码

以下是一个路由模式的示例：

# 生产者
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='topic_logs', exchange_type='topic')

channel.basic_publish(exchange='topic_logs',
                      routing_key='kern.critical',
                      body='This is a critical message')

channel.basic_publish(exchange='topic_logs',
                      routing_key='kern.info',
                      body='This is an info message')

connection.close()

# 消费者
import pika

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

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='kern.*')

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
import time

def on_request(ch, method, props, body):
    n = int(body)
    print(" [.] Got %r" % n)
    response = "%d" % (n * n)
    ch.basic_publish(exchange='',
                     routing_key=props.reply_to,
                     properties=pika.BasicProperties(correlation_id = props.correlation_id),
                     body=str(response))
    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='rpc_queue')

channel.basic_consume(queue='rpc_queue', on_message_callback=on_request)

print(" [x] Awaiting RPC requests")
channel.start_consuming()

# 客户端（请求者）
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='rpc_queue')

corr_id = str(uuid.uuid4())

response = None

def on_response(ch, method, props, body):
    if corr_id == props.correlation_id:
        global response
        response = body
        ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_publish(exchange='',
                      routing_key='rpc_queue',
                      properties=pika.BasicProperties(reply_to='rpc_queue', correlation_id=corr_id),
                      body='5')

channel.basic_consume(queue='rpc_queue', on_message_callback=on_response)

channel.start_consuming()
print(' [.] Got %r' % response)

RabbitMQ的错误处理与监控

错误处理机制

RabbitMQ提供了多种错误处理机制，包括消息持久化、消息处理超时、死信队列等。通过这些机制，可以确保消息的可靠传输和处理。

示例代码

以下是一个使用消息持久化和死信队列的示例：

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='logs', exchange_type='fanout')
channel.queue_declare(queue='logs_queue', arguments={'x-message-ttl': 10000, 'x-dead-letter-exchange': 'dlx', 'x-dead-letter-routing-key': 'logs.dlx'})

channel.basic_publish(exchange='logs',
                      routing_key='',
                      body='This message will expire',
                      properties=pika.BasicProperties(delivery_mode=pika.constants.PERSISTENT_DELIVERY_MODE))

connection.close()

监控功能介绍

RabbitMQ提供了丰富的监控功能，包括消息队列的实时监控、节点状态监控、性能统计等。通过监控可以及时发现和解决系统中的问题。

示例代码

以下是一个使用RabbitMQ管理界面查看队列状态的示例：

import pika
import requests

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='example_queue')

response = requests.get('http://localhost:15672/api/queues/%2F/example_queue')
print(response.json())

connection.close()

日志管理与查看

RabbitMQ支持日志管理，可以记录系统运行中的各种事件。通过日志可以追踪系统运行的状态和问题。

示例代码

以下是一个查看RabbitMQ日志的示例：

# 查看RabbitMQ日志
sudo tail -n 50 /var/log/rabbitmq/rabbit@localhost.log

# 使用Python的requests库查看RabbitMQ管理界面的日志
import requests

url = 'http://localhost:15672/api/log/mgmt'
response = requests.get(url, auth=('guest', 'guest'))
print(response.json())

RabbitMQ实践案例

简单消息传递案例

示例代码

以下是一个简单的消息传递示例：

# 发布者
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello, world!')

print(' [x] Sent message')
connection.close()

# 订阅者
import pika

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)

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

实时通知系统设计

实现实时通知系统，可以通过RabbitMQ的消息传递机制，将通知消息发送到多个订阅者。

示例代码

以下是一个实现实时通知系统的示例：

# 发布者
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='logs', exchange_type='fanout')

channel.basic_publish(exchange='logs',
                      routing_key='',
                      body='A new event has occurred!')

print(' [x] Sent event notification')
connection.close()

# 订阅者
import pika

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

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)

channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)

print(' [*] Waiting for logs. To exit press CTRL+C')
channel.start_consuming()

批量处理任务分配

批量处理任务分配可以通过RabbitMQ的消息队列，将任务分发到多个工作者节点进行处理。

示例代码

以下是一个批量处理任务分配的示例：

# 发布者
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='task_queue', durable=True)

for task in ['task1', 'task2', 'task3']:
    channel.basic_publish(exchange='',
                          routing_key='task_queue',
                          body=task,
                          properties=pika.BasicProperties(
                              delivery_mode=pika.spec.PERSISTENT_DELIVERY_MODE
                          ))

print(' [x] Sent %r' % task)
connection.close()

# 工作者
import pika
import time
import random

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    print(" [x] Processing task")
    time.sleep(random.randint(1, 4))
    print(" [x] Done")
    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='task_queue', durable=True)

channel.basic_qos(prefetch_count=1)
channel.basic_consume(queue='task_queue', on_message_callback=callback)

print(' [*] Waiting for tasks. To exit press CTRL+C')
channel.start_consuming()

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

炎炎设计

手记
篇

粉丝

74

获赞与收藏

371

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

Pandas 入门教程

25个小节 18488 336

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

RabbitMQ教程：新手入门与实践指南

RabbitMQ是什么

RabbitMQ的主要特性

RabbitMQ的应用场景

RabbitMQ的下载与安装

下载

安装

RabbitMQ的启动与停止

RabbitMQ的管理界面使用

交换器（Exchange）

示例代码

队列（Queue）

示例代码

绑定（Binding）

示例代码

消息（Message）

示例代码

生产者与消费者的定义

生产者示例代码

消费者示例代码

发布与订阅模式

示例代码

路由模式

示例代码

请求响应模式

示例代码

错误处理机制

示例代码

监控功能介绍

示例代码

日志管理与查看

示例代码

简单消息传递案例

示例代码

实时通知系统设计

示例代码

批量处理任务分配

示例代码

阅读免费教程