Python中RabbitMQ的使用
一、简介
RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现的产品，RabbitMQ是一个消息代理，从“生产者”接收消息并传递消息至“消费者”，期间可根据规则路由、缓存、持久化消息。“生产者”也即message发送者以下简称P，相对应的“消费者”乃message接收者以下简称C，message通过queue由P到C，queue存在于RabbitMQ，可存储尽可能多的message，多个P可向同一queue发送message，多个C可从同一个queue接收message
1、关键词说明
Broker：消息队列服务器实体。
Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。
Queue：消息队列载体，每个消息都会被投入到一个或多个队列。
Binding：绑定，它的作用就是把exchange和queue按照路由规则绑定起来。
Routing Key：路由关键字，exchange根据这个关键字进行消息投递。
vhost：虚拟主机，一个broker里可以开设多个vhost，用作不同用户的权限分离。
producer：消息生产者，就是投递消息的程序。
consumer：消息消费者，就是接受消息的程序。
channel：消息通道，在客户端的每个连接里，可建立多个channel，每个channel代表一个会话任务。
2、消息队列运行机制
1、客户端连接到消息队列服务器，打开一个channel
2、客户端声明一个exchange，并设置相关属性
3、客户端声明一个queue，并设置相关属性
4、客户端使用routing key，在exchange和queue之间建立好绑定关系
5、客户端投递消息到exchange
6、exchange接收到消息后，就根据消息的key和已经设置的binding，将消息投递到一个或多个队列里
# 注:在声明一个队列后，如果将其持久化，则下次不需要进行声明，因为该队列已经在rabbitMQ中了！！！
3、exchange类型
1、direct交换机
特点：依据key进行投递
例如绑定时设置了routing key为”hello”，那么客户端提交的消息，只有设置了key为”hello”的才会投递到队列。
2、topic交换机
特点：对key模式匹配后进行投递，符号”#”匹配一个或多个词，符号” * ”匹配一个词
例如”abc.#”匹配”abc.def.ghi”，”abc.*”只匹配”abc.def”。
3、fanout交换机
特点：不需要key，采取广播模式，一个消息进来时，投递到与该交换机绑定的所有队列
4、消息确认
"""
当客户端从队列中取出消息之后，可能需要一段时间才能处理完成，如果在这个过程中，客户端出错了，异常退出了，而数据还没有处理完成，那么非常不幸，这段数据就丢失了，因为rabbitmq默认会把此消息标记为已完成，然后从队列中移除，
"""
消息确认是客户端从rabbitmq中取出消息，并处理完成之后，会发送一个ack告诉rabbitmq，消息处理完成，当rabbitmq收到客户端的获取消息请求之后，或标记为处理中，当再次收到ack之后，才会标记为已完成，然后从队列中删除。当rabbitmq检测到客户端和自己断开链接之后，还没收到ack，则会重新将消息放回消息队列，交给下一个客户端处理，保证消息不丢失，也就是说，RabbitMQ给了客户端足够长的时间来做数据处理。
在客户端使用no_ack来标记是否需要发送ack，默认是False，开启状态
二、构建环境
1、在windows环境下安装rabbitmq，教程如下：
https://juejin.cn/post/6992383077435572260
2、安装pika模块
python使用rabbitmq服务，可以使用现成的类库pika、txAMQP或者py-amqplib，这里选择了pika
在命令行中直接使用pip命令：
pip install pika
三、示例测试
示例测试内容就是从producer.py发送消息到RabbitMQ，consumer从RabbitMQ接受消息
producer.py
# 消息生产者
import json
import time
import pika
# 队列名称
queue = 'queue_test'
# 路由关键字
routing_key = 'hello'
# 消息交换机名称
exchange = 'exchange_test'
# 建立连接
hostname = '127.0.0.1'
port = 5672
Credentials = pika.PlainCredentials('guest', 'guest')
Connection = pika.BlockingConnection(
pika.ConnectionParameters(
host=hostname,
port=port,
virtual_host='/', # 虚拟主机
credentials=Credentials
)
)
# 连接建立成功后，建立通道
channel = Connection.channel()
# 创建exchange
channel.exchange_declare(exchange=exchange, exchange_type='direct', durable=True)
# 声明队列,生产者和消费者都要声明一个相同的队列，用来防止万一某一方挂了，另一方能正常运行
channel.queue_declare(queue=queue, durable=True)
# 把队列和消息交换机绑定
channel.queue_bind(queue=queue, exchange=exchange, routing_key=routing_key)
# 交换机; 队列名,写明将消息发往哪个队列; 消息内容
# routing_key在使用匿名交换机的时候才需要指定，表示发送到哪个队列,注意当未定义exchange时，routing_key需和queue的值保持一致
for i in range(200):
data = f'hello word{i}'
time.sleep(2)
channel.basic_publish(exchange=exchange, routing_key=routing_key, body=data)
print(f'发送。。。{i}')
Connection.close()
consumer.py
# 消息消费者
import pika
queue = 'queue_test'
hostname = 'localhost'
port = 5672
Credentials = pika.PlainCredentials('guest', 'guest')
ConnectionParam= pika.ConnectionParameters(host=hostname,port=port,credentials=Credentials)
Connection = pika.BlockingConnection(parameters=ConnectionParam)
# 连接建立成功后，建立通道
channel = Connection.channel()
# 创建exchange
channel.queue_declare(queue=queue,durable=True)
# 接受数据
def call_back(ch, method, properties, body):
print(" [x] Received %r" % (body,))
ch.basic_ack(delivery_tag=method.delivery_tag) # 发送ack消息
# 告诉RabbitMQ使用call_back来接受数据
channel.basic_consume(queue=queue,on_message_callback=call_back,auto_ack=False)#no_ack来标记是否需要发送ack，默认是False，开启状态
# 开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理,按ctrl+c退出
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
先运行producer.py发送消息
在运行consumer.py接收消息
再看web端的展示：http://localhost:15672/#/
可以看到队列中消息的数量以及双方放消息和取消息的时间段
显示一个队列
四、消息持久化
消息持久化 消息确认机制使得客户端在崩溃的时候，服务端消息不丢失，但是如果rabbitmq奔溃了呢？该如何保证队列中的消息不丢失？ 此就需要product在往队列中push消息的时候，告诉rabbitmq，此队列中的消息需要持久化，用到的参数：durable=True，再次强调，Producer和client都应该去创建这个queue，尽管只有一个地方的创建是真正起作用的：
channel.basic_publish(exchange='',
routing_key="test",
body=message,
properties=pika.BasicProperties(
delivery_mode = 2, # make message persistent
))
具体代码：
- product端：
# 建立连接
hostname = '127.0.0.1'
port = 5672
Credentials = pika.PlainCredentials('guest', 'guest')
Connection = pika.BlockingConnection(
pika.ConnectionParameters(
host=hostname,
port=port,
virtual_host='/', # 虚拟主机
credentials=Credentials
)
)
# 连接建立成功后，建立通道
channel = Connection.channel()
# 创建exchange
channel.exchange_declare(exchange=exchange, exchange_type='direct', durable=True)
# 声明队列,生产者和消费者都要声明一个相同的队列，用来防止万一某一方挂了，另一方能正常运行
channel.queue_declare(queue=queue, durable=True)
# 把队列和消息交换机绑定
channel.queue_bind(queue=queue, exchange=exchange, routing_key=routing_key)
# 交换机; 队列名,写明将消息发往哪个队列; 消息内容
# routing_key在使用匿名交换机的时候才需要指定，表示发送到哪个队列,注意当未定义exchange时，routing_key需和queue的值保持一致
for i in range(200):
data = f'hello word{i}'
time.sleep(2)
channel.basic_publish(exchange=exchange, routing_key=routing_key, body=data,properties=pika.BasicProperties(delivery_mode=2))
print(f'发送。。。{i}')
Connection.close()
- client端：
# 消息消费者
import pika
queue = 'queue_test'
hostname = 'localhost'
port = 5672
Credentials = pika.PlainCredentials('guest', 'guest')
ConnectionParam= pika.ConnectionParameters(host=hostname,port=port,credentials=Credentials)
Connection = pika.BlockingConnection(parameters=ConnectionParam)
# 连接建立成功后，建立通道
channel = Connection.channel()
# 创建exchange
channel.queue_declare(queue=queue,durable=True)
# 接受数据
def call_back(ch, method, properties, body):
print(" [x] Received %r" % (body,))
ch.basic_ack(delivery_tag=method.delivery_tag) # 发送ack消息
# 告诉RabbitMQ使用call_back来接受数据
channel.basic_consume(queue=queue,on_message_callback=call_back,auto_ack=False)#no_ack来标记是否需要发送ack，默认是False，开启状态
# 开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理,按ctrl+c退出
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
配置完之后，发现product往rabbitmq端push消息之后，重启rabbitmq，消息依然存在