原文作者：我辈李想
版权声明：文章原创，转载时请务必加上原文超链接、作者信息和本声明。
文章目录
前言
Rabbitmq消息队列，Windows安装RabbitMQ教程
一、基本概念
提到RabbitMQ，就不得不提AMQP协议。AMQP协议是具有现代特征的二进制协议。是一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。
先了解一下AMQP协议中间的几个重要概念：
Server：接收客户端的连接，实现AMQP实体服务。
Connection：连接，应用程序与Server的网络连接，TCP连接。
Channel：信道，消息读写等操作在信道中进行。客户端可以建立多个信道，每个信道代表一个会话任务。
Message：消息，应用程序和服务器之间传送的数据，消息可以非常简单，也可以很复杂。由Properties和Body组成。Properties为外包装，可以对消息进行修饰，比如消息的优先级、延迟等高级特性；Body就是消息体内容。
Virtual Host：虚拟主机，用于逻辑隔离。一个虚拟主机里面可以有若干个Exchange和Queue，同一个虚拟主机里面不能有相同名称的Exchange或Queue。
Exchange：交换器，接收消息，按照路由规则将消息路由到一个或者多个队列。如果路由不到，或者返回给生产者，或者直接丢弃。RabbitMQ常用的交换器常用类型有direct、topic、fanout、headers四种，后面详细介绍。
Binding：绑定，交换器和消息队列之间的虚拟连接，绑定中可以包含一个或者多个RoutingKey。
RoutingKey：路由键，生产者将消息发送给交换器的时候，会发送一个RoutingKey，用来指定路由规则，这样交换器就知道把消息发送到哪个队列。路由键通常为一个“.”分割的字符串，例如“com.rabbitmq”。
Queue：消息队列，用来保存消息，供消费者消费。
二、消息队列的基本要素
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
消息队列是一种中间件 ，用于在不同的组件或系统之间传递消息（进程间通讯的一种）。 它提供了一种可靠的机制（AMQP）来存储和传递消息，并确保消息的顺序性和可靠性。消息队列需要存储消息。
1.队列:queue
用于接入消息队列的出入口
2.交换机:exchange
用于存储的一种通道
3.事件:routing_key
用于记录的一种标记
4.任务:task
这里的任务就是处理程序，还可能包含回调函数
注:基于我们使用不同的要素组合，分化出了基础的生产消费模式和发布订阅模式。其中只使用队列和任务的方式划为生产消费模式，4个同时使用的方式划为发布订阅模式。
三、生产消费模式
消息队列处理的是进程间通讯问题，生产者和消费者正是2个进程的程序，代表了不同的组件或系统。
我们使用python来实现相关功能，可以通过pika这个三方库来实现。
1.安装pika
pip install pika -i https://pypi.tuna.tsinghua.edu.cn/simple
2.模拟生产者进程
这里的生产者进程可能是一个后端程序、也可能是一个py文件、也可能知识一条触发命令。
# !/usr/bin/env python
import pika
# ######################### 生产者 #########################
# 如果设置密码，那么就需要加以下一句话配置用户名与密码
credentials = pika.PlainCredentials("root", "123")
# host:ip地址 credentials:链接凭证
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost', credentials=credentials))
# 声明一个channel，类似数据库打开一个链接
channel = connection.channel()
# 创建一个队列，队列名称叫做hello
channel.queue_declare(queue='hello')
# 向hello这个队列里发送一个Hello World! exchange:如果当做一个普通队列，就为空
channel.basic_publish(exchange='', routing_key='hello', body='Hello World!')
print(" [x] Sent 'Hello World!'")
connection.close()
3.模拟消费者进程
消费者
# !/usr/bin/env python
import pika
# ########################## 消费者 ##########################
# 如果设置密码，那么就需要加以下一句话配置用户名与密码
credentials = pika.PlainCredentials("root", "123")
# host:ip地址 credentials:链接凭证
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost', credentials=credentials))
channel = connection.channel()
# channel.queue_declare(queue='hello')
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
# 取一个就关掉的方法
channel.stop_consuming()
# 去hello队列里拿数据，一但有数据，就执行callback
channel.basic_consume(callback, queue='hello', no_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
# 开始去取得意思【表示一直去队列中取会夯住】注意可以去一个就关掉
channel.start_consuming()
4.ACK消息确认机制
ACK机制是消费者从RabbitMQ收到消息并处理完成后，反馈给RabbitMQ，RabbitMQ收到反馈后才将次消息从队列中删除。
生产者
# !/usr/bin/env python
import pika
# ######################### 生产者 #########################
# 如果设置密码，那么就需要加以下一句话配置用户名与密码
credentials = pika.PlainCredentials("root", "123")
# host:ip地址 credentials:链接凭证
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost', credentials=credentials))
# 声明一个channel，类似数据库打开一个链接
channel = connection.channel()
# 创建一个队列，队列名称叫做hello
channel.queue_declare(queue='hello')
# 向hello这个队列里发送一个Hello World! exchange:如果当做一个普通队列，就为空
channel.basic_publish(exchange='', routing_key='hello', body='Hello World!')
print(" [x] Sent 'Hello World!'")
connection.close()
消费者
# !/usr/bin/env python
import pika
# ########################## 消费者 ##########################
# 如果设置密码，那么就需要加以下一句话配置用户名与密码
credentials = pika.PlainCredentials("root", "123")
# host:ip地址 credentials:链接凭证
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost', credentials=credentials))
channel = connection.channel()
# channel.queue_declare(queue='hello')
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
# 取值做确认工作
ch.basic_ack(delivery_tag=method.deliver_tag)
# 去hello队列里拿数据，一但有数据，就执行callback,
# no_ack=Flask必须在取值时做确认工作，否则值不会被取出
channel.basic_consume(callback, queue='hello', no_ack=False)
print(' [*] Waiting for messages. To exit press CTRL+C')
# 开始去取得意思【表示一直去队列中取会夯住】注意可以去一个就关掉
channel.start_consuming()
5.类的写法
这个类使用 pika 库进行与 RabbitMQ 的通信。当你使用 send_message() 或 receive_message() 、consume_messages方法时，Channel 对象必须是打开的。如果没有连接或者通道没有打开，这些方法将引发 ValueError 异常。
（1）新建MyRabbitMQ.py文件
文件包含rabbitmq的类，类中包含连接到RabbitMQ，并在连接对象上创建一个管道，然后就可以使用send_message()和receive_message()方法、consume_messages发送和接收消息，接收消息会调用回调方法。
下面是一个带有消费回调的完整 RabbitMQ 类
import threading
import pika
import time
class RabbitMQ:
_instance_lock = threading.Lock()
def __init__(self, host, port, username, password):
self.host = host
self.port = port
self.username = username
self.password = password
self.connection = None
self.channel = None
def connect(self, timeout=10):
start_time = time.time()
credentials = pika.PlainCredentials(self.username, self.password)
parameters = pika.ConnectionParameters(host=self.host,
port=self.port,
credentials=credentials)
while time.time() - start_time < timeout:
try:
self.connection = pika.BlockingConnection(parameters)
self.channel = self.connection.channel()
return True
except pika.exceptions.AMQPConnectionError:
time.sleep(1)
return False
def send_message(self, exchange, routing_key, message):
try:
self.channel.basic_publish(exchange=exchange,
routing_key=routing_key,
body=message,
properties=pika.BasicProperties(delivery_mode=2))
except AttributeError:
raise ValueError("Channel is not open. Call connect() before send_message().")
def receive_message(self, queue, auto_ack=False):
try:
method_frame, properties, body = self.channel.basic_get(queue=queue, auto_ack=auto_ack)
if method_frame:
return body.decode('utf-8')
else:
return None
except AttributeError:
raise ValueError("Channel is not open. Call connect() before receive_message().")
def consume_messages(self, queue, callback):
try:
self.channel.basic_consume(queue=queue, on_message_callback=callback, auto_ack=True)
self.channel.start_consuming()
except AttributeError:
raise ValueError("Channel is not open. Call connect() before consume_messages().")
def create_queue(self, name):
try:
self.channel.queue_declare(queue=name, durable=True)
except AttributeError:
raise ValueError("Channel is not open. Call connect() before create_queue().")
def bind_queue(self, queue, exchange, routing_key):
try:
self.channel.queue_bind(queue=queue, exchange=exchange, routing_key=routing_key)
except AttributeError:
raise ValueError("Channel is not open. Call connect() before bind_queue().")
def close(self):
try:
self.connection.close()
except AttributeError:
raise ValueError("Connection is not open. Call connect() before close().")
（2）基础RabiitMQ
基于队列_生产
创建RabiitMQ_生产.py文件，内容如下:
from MyRabbitMQ import RabbitMQ
if __name__ == '__main__':
print('RabbitMQ生产')
my_host = '127.0.0.1'
my_username = 'guest'
my_password = 'guest'
my_queue = 'hello'
my_exchange = 'BBB'
my_routing_key = 'hello'
rabbitmq = RabbitMQ(my_host, 5672, my_username, my_password)
if rabbitmq.connect():
rabbitmq.create_queue(my_queue)
rabbitmq.send_message('', my_queue, message='开始了')
else:
print("Failed to connect to RabbitMQ.")
基于队列_消费
from MyRabbitMQ import RabbitMQ
if __name__ == '__main__':
print('RabbitMQ消费')
my_host = '127.0.0.1'
my_username = 'guest'
my_password = 'guest'
my_queue = 'hello'
my_exchange = 'BBB'
my_routing_key = 'hello'
def callback(channel, method, properties, body):
print("Received message: %s" % body.decode('utf-8'))
channel.basic_ack(delivery_tag=method.delivery_tag)
rabbitmq = RabbitMQ(my_host, 5672, my_username, my_password)
if rabbitmq.connect():
rabbitmq.create_queue(my_queue)
rabbitmq.consume_messages(my_queue, callback)
else:
print("Failed to connect to RabbitMQ.")
在此例中，当一个新的消息从名为 my_queue 的队列中接收时，回调函数 callback 将被调用并打印消息内容。
注意：如果你的回调函数需要执行较复杂的操作（例如长时间运行或使用多线程），则你应该确保它是线程安全的，并且在操作完成后调用 ch.basic_ack，这样 RabbitMQ 就知道消息已经被处理并可以将其从队列中删除。
四、发布订阅模式
发布订阅模式的消费者是queue队列，需要绑定exchange和routing_key，实际使用时可能存在一个队列绑定多个routing_key,或多个queue绑定一个routing_key，所以在我们的消费者处理中，需要判断routing_key事件做必要的区分。
基于exchangs交换机的生产者
from MyRabbitMQ import RabbitMQ
if __name__ == '__main__':
print('RabbitMQ消费')
my_host = '127.0.0.1'
my_username = 'guest'
my_password = 'guest'
my_queue = 'hello'
my_exchange = 'BBB'
my_routing_key = 'hello'
rabbitmq = RabbitMQ(my_host, 5672, my_username, my_password)
if rabbitmq.connect():
rabbitmq.send_message(my_exchange, my_routing_key, message='开始了')
else:
print("Failed to connect to RabbitMQ.")
基于exchangs交换机的消费者
from MyRabbitMQ import RabbitMQ
if __name__ == '__main__':
print('RabbitMQ消费')
my_host = '127.0.0.1'
my_username = 'guest'
my_password = 'guest'
my_queue = 'hello'
my_exchange = 'BBB'
my_routing_key = 'hello'
def callback(channel, method, properties, body):
print("Received message: %s" % body.decode('utf-8'))
eventsDelivery = set()
eventsDelivery.add(config.Arim_Plan_Send)
eventsDelivery.add(config.Arim_SlabMatching_Start)
eventsDelivery.add(config.Arim_RollPlan_Rescheduled_Redis)
try:
print('算法事件:', method.routing_key)
if method.routing_key in eventsDelivery:
pass
else:
print('不需要处理的routing_key',method.routing_key)
except Exception as e:
print("算法出现异常: {}".format(e))
finally:
channel.basic_ack(delivery_tag=method.delivery_tag)
rabbitmq = RabbitMQ(my_host, 5672, my_username, my_password)
if rabbitmq.connect():
rabbitmq.create_queue(my_queue)
# rabbitmq.send_message(my_exchange, my_routing_key, message='开始了')
rabbitmq.bind_queue(my_queue, my_exchange, my_routing_key)
rabbitmq.consume_messages(my_queue, callback)
else:
print("Failed to connect to RabbitMQ.")
五、多消息队列
import pika
import random
from retry import retry
def on_message(channel, method_frame, header_frame, body)
print(method_frame.delivery_tag)
print(body)
print(header_frame)
channel.basic_ack(delivery_tag=method_frame.delivery_tag)
node1 = pika.URLParameters('amqp://node1')
node2 = pika.URLParameters('amqp://node2')
node3 = pika.URLParameters('amqp://node3')
all_endpoints = [node1, node2, node3]
@retry(pika.exceptions.AMQPConnectionError, delay=5, jitter(1, 3)
def consume():
random.shuffle(all_endpoints)
connection = pika.BlockingConnection(all_endpoints)
channel = connection.channel()
channel.basic_qos(prefetch_count=1)
channel.queue_declare('recovery-example', durable=False, auto_delete=True)
channel.basic_consume('recovery-example', on_message)
try:
channel.start_consuming()
except KeyboardInterrupt:
channel.stop_consuming()
connection.close()
except pika.excaptions.ConnectionClosedByBroker:
continue
consume()
六、pika线程安全
上边的实例中都是使用BlockingConnection来建立连接，BlockingConnection的设计就是阻塞的。可以使用非阻塞连接并消费消息。
import pika
def callback(channel, method, properties, body):
print(body)
channel.basic_ack(delivery_tag=method.delivery_tag)
def on_open(connection):
connection.channel(on_channel_open)
def on_channel_open(channel):
channel.basic_consume(callback, queue='queue1')
channel.basic_consume(callback, queue='queue2')
parameters = pika.URLParameters('amqp://guest:guest@localhost:5672/%2F')
connection = pika.SelectConnection(parameters=parameters,
on_open_callback=on_open)
try:
connection.ioloop.start()
except KeyboardInterrupt:
connection.close()
8302
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
