python消息队列RabbitMQ

tags:

python3
python基础

categories:

RabbitMQ
消息队列
RPC实现

文章目录

python消息队列RabbitMQ

一、消息队列RabbitMQ介绍

1. 1 RabbitMQ安装
1.2 RabbitMQ基本使用
1.3 RabbitMq 常用设置

二、RabbitMq 持久化
三、RabbitMq广播模式

3.1 fanout模式
3.2 direct 模式
3.3 更细致的消息过滤topic

四、RabbitMQ的rpc实现

一、消息队列RabbitMQ介绍

消息队列提出：我们知道在Python中有
- 线程QUEUE：threading QUEUE 同一进程下线程之间数据的交互
- 进程QUEUE：父进程与子进程进行交互，或者同属于同一父进程下多个子进程进行交互
如果两个独立的进程(可以是不同语言写的)想要交互通信，或者两台机器之间想要进行通信。
消息队列有RabbitMQ(比较火)，ZeroMQ，ActiveMQ …
RabbitMq 是实现了高级消息队列协议（AMQP）的开源消息代理中间件。消息队列是一种应用程序对应用程序的通行方式，应用程序通过写消息，将消息传递于队列，由另一应用程序读取完成通信。而作为中间件的 RabbitMq 无疑是目前最流行的消息队列之一。
RabbitMq 应用场景广泛：
- 系统的高可用：日常生活当中各种商城秒杀，高流量，高并发的场景。当服务器接收到如此大量请求处理业务时，有宕机的风险。某些业务可能极其复杂，但这部分不是高时效性，不需要立即反馈给用户，我们可以将这部分处理请求抛给队列，让程序后置去处理，减轻服务器在高并发场景下的压力。
- 分布式系统，集成系统，子系统之间的对接，以及架构设计中常常需要考虑消息队列的应用。

1. 1 RabbitMQ安装

erlang 语言开发的。所以安装RabbitMQ之前先安装erlang
到erlang官网： https://www.erlang.org/downloads 下载 OTP 22.2 Windows 64-bit Binary File
安装配置erlang：加入环境变量D:\Erlang\bin
输入cmd，再输入erl，看到版本号就说明erlang安装成功了。
erl和RabbitMQ版本对应关系：https://www.rabbitmq.com/which-erlang.html
RabbitMQ官网：https://www.rabbitmq.com/
安装好之后。进入安装目录D:\RabbitMQ\rabbitmq_server-3.7.24\sbin
运行命令：rabbitmq-plugins enable rabbitmq_management
然后打开浏览器，输入localhost:15672 输入默认账号和密码guest和guest。登录成功

rabbitmqct1.bat list_queues #查看队列

1.2 RabbitMQ基本使用

python连接RabbitMQ的模块有：pika, Celery,Haigha(官网给出)
RabbitMQ也支持其他种类的语言。(官网可查)
安装python模块pika: pip install pika
官方教程网址：https://www.rabbitmq.com/getstarted.html
实现最简单的队列通信

#product.py服务器生产者
import pika


'''
    连接参数 host,port(默认5672),virtual_host,credentials(验证)
    credentials = pika.PlainCredentials('shampoo', '123456')  # mq用户名和密码验证
    虚拟队列需要指定参数 virtual_host，如果是默认的可以不填。
'''
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明queue(给队列起名)
channel.queue_declare(queue='hello')

# n RabbitMQ a message can never be sent directly to the queue, it always needs to go through an exchange.
# 基本发送
channel.basic_publish(exchange='', # 图中的X,不用深究。知道默认为''就行
                      routing_key='hello', # queue名字
                      body='Hello World!') # 发送的内容
print("消息发送完毕")
connection.close()

# consumer.py 客户端消费者
import pika

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

# 这里在声明一次hello的原因。如果消费者先运行，hello生产者还不存在就会报错。
# 如果确定服务器端先启动，队列名确定叫hello。下面也可以不写(推荐写上呀！！！兄弟)
channel.queue_declare(queue='hello')


def callback(ch, method, properties, body):
    '''
    :param ch: 管道的内存对象
    :param method:
    :param properties:
    :param body:
    :return:
    '''
    import time
    print("开始")
    time.sleep(10)
    print("Received %r" % body)
    ch.basic_ack(delivery_tag=method.delivery_tag)


# 消费消息，如果收到消息就调用callback处理消息。从hello队列中收消息。
# auto_ack 自动确认，消息处理完给服务器发消息
channel.basic_consume('hello', callback, True)

print('等待接收消息，关闭按CTRL+C')
channel.start_consuming()

1.3 RabbitMq 常用设置

远程连接rabbitmq server的话，需要配置权限
- 首先在rabbitmq server上创建一个用户
- 同时还要配置权限，允许从外面访问

# 创建账号
rabbitmqctl add_user admin 123456
# 设置用户角色
rabbitmqctl set_user_tags admin administrator
# 设置用户权限
rabbitmqctl set_permissions -p "/“oldlu” .""."".*"
# 设置完成后可以查看当前用户和角色(需要开启服务)
rabbitmqctl list_users

轮询处理消息。假如开启多个消费者，生产者发送消息后，先发送到先启动的消费者以此循环。
如果消费者处理消息时宕机啦。消费者（consumer）调用callback函数时，会存在处理消息失败的风险，如果处理失败，则消息丢失。但是也可以选择消费者处理失败时，将消息回退给 rabbitmq ，重新再被消费者消费，这个时候需要设置确认标识。
- auto_ack 自动确认False情况(默认) channel.basic_consume(‘hello’, callback, True)
- ch.basic_ack(delivery_tag=method.delivery_tag) 手动确认。如果不确认配置了False，任务只要有客户端它会一直重复做下去。
如果服务器生产者宕机的话，如果没有持久化，那肯定全都不见了。
如果Rabbit只管按顺序把消息发到各个消费者身上，不考虑消费者负载的话，很可能出现，一个机器配置不高的消费者那里堆积了很多消息处理不完，同时配置高的消费者却一直很轻松。为解决此问题，可以在各个消费者端，配置perfetch=1,意思就是告诉RabbitMQ在我这个消费者当前消息还没处理完的时候就不要再给我发新消息了。解决方法：客户端加入下面一句

# 客户端最多存一条
channel.basic_qos(prefetch_count=1)

二、RabbitMq 持久化

MQ默认建立的是临时 queue 和 exchange，如果不声明持久化，一旦 rabbitmq 挂掉，queue、exchange 将会全部丢失。所以我们一般在创建 queue 或者 exchange 的时候会声明持久化。客户端和服务器端都需要设置。

queue 队列持久化

# 声明消息队列，消息将在这个队列传递，如不存在，则创建。durable=True 代表消息队列持久化存储，False 非持久化存储
result = channel.queue_declare(queue='python-test',durable=True)

exchange 声明持久化

# 声明exchange，由exchange指定消息在哪个队列传递，如不存在，则创建.durable = True 代表exchange持久化存储，False 非持久化存储
channel.exchange_declare(exchange='python-test', durable=True)

注意：如果已存在一个非持久化的 queue 或 exchange ，执行上述代码会报错，因为当前状态不能更改 queue 或 exchange 存储属性，需要删除重建。如果 queue 和 exchange 中一个声明了持久化，另一个没有声明持久化，则不允许绑定。

消息持久化
虽然 exchange 和 queue 都申明了持久化，但如果消息只存在内存里，rabbitmq 重启后，内存里的东西还是会丢失。所以必须声明消息也是持久化，从内存转存到硬盘。

# 向队列插入数值 routing_key是队列名。delivery_mode = 2 声明消息在队列中持久化，delivery_mod = 1 消息非持久化
    channel.basic_publish(exchange = '',routing_key = 'python-test',body = message,properties=pika.BasicProperties(delivery_mode=2))

三、RabbitMq广播模式

之前的例子都基本都是1对1的消息发送和接收，即消息只能发送到指定的queue里，但有些时候你想让你的消息被所有的Queue收到，类似广播的效果，这时候就要用到exchange了。
发布订阅和简单的消息队列区别在于，发布订阅会将消息发送给所有的订阅者，而消息队列中的数据被消费一次便消失。所以，RabbitMQ实现发布和订阅时，会为每一个订阅者创建一个队列，而发布者发布消息时，会将消息放置在所有相关队列中。
Exchange在定义的时候是有类型的，以决定到底是哪些Queue符合条件，可以接收消息
- fanout: 所有bind到此exchange的queue都可以接收消息
- direct: 通过routingKey和exchange决定的那个唯一的queue可以接收消息
- topic:所有符合routingKey(此时可以是一个表达式)的routingKey所bind的queue可以接收消息

3.1 fanout模式

在这里插入图片描述

消息是实时的。 fanout类似收音机，服务器端发送时，客户端已经启动可以收到。客户端没启动它不会给你存着，就没收到之前信息。

# fanout_publisher.py
import pika
import sys

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

channel.exchange_declare('logs', 'fanout')

#message = ' '.join(sys.argv[1:]) or "info: Hello World!"
message = "info: Hello World!"

# 广播模式下queue不用写。
channel.basic_publish(exchange='logs',
                      routing_key='',
                      body=message)
print(" [x] Sent %r" % message)
connection.close()

# _*_coding:utf-8_*_
import pika

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

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

# 不指定queue名字,rabbit会随机分配一个名字,exclusive=True会在使用此queue的消费者断开后,自动将queue删除
result = channel.queue_declare('', exclusive=True)
# 上面随机生成的queue
queue_name = result.method.queue

# queue 绑定到logs转发器上, 通过自动生成的queue连接转发器
channel.queue_bind(exchange='logs',
                queue=queue_name)

print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
    print(" [x] %r" % body)


channel.basic_consume(queue_name, callback, True)

channel.start_consuming()

3.2 direct 模式

有选择的接收消息(exchange type=direct)RabbitMQ还支持根据关键字发送，即：队列绑定关键字，发送者将数据根据关键字发送到消息exchange，exchange根据关键字判定应该将数据发送至指定队列。
和fanout一样消息是实时的。
python direct_consumer.py error warning (输入接收的消息类型)

# direct_publisher
import pika
import sys

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

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

severity = sys.argv[1] if len(sys.argv) > 1 else 'info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'

channel.basic_publish(exchange='direct_logs',
                      routing_key=severity,
                      body=message)
print(" [x] Sent %r:%r" % (severity, message))
connection.close()

# direct_consumer
import pika
import sys

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

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

result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

# 获取输入的级别列表
severities = sys.argv[1:]
if not severities:
    sys.stderr.write("Usage: %s [info] [warning] [error]\n" % sys.argv[0])
    sys.exit(1)

# 所有发到severity参数的消息都收，其他的consumer中没有这个参数
for severity in severities:
    channel.queue_bind(exchange='direct_logs',
                       queue=queue_name,
                       routing_key=severity)

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

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

channel.basic_consume(queue_name, callback, True)
channel.start_consuming()

3.3 更细致的消息过滤topic

在这里插入图片描述
匹配关键字发送.info，比如消息后缀名为.info。相对于direct写死更加灵活。

python topic_consumer.py *.info
python topic_consumer.py *.error mysql.*
python topic_publisher.py test.error

# topic_publisher
import pika
import sys

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

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

routing_key = sys.argv[1] if len(sys.argv) > 1 else 'anonymous.info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'
channel.basic_publish(exchange='topic_logs',
                      routing_key=routing_key,
                      body=message)
print(" [x] Sent %r:%r" % (routing_key, message))
connection.close()

# topic_consumer.py
import pika
import sys

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

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

result = channel.queue_declare('', exclusive=True)
queue_name = result.method.queue

binding_keys = sys.argv[1:]
if not binding_keys:
    sys.stderr.write("Usage: %s [binding_key]...\n" % sys.argv[0])
    sys.exit(1)

for binding_key in binding_keys:
    channel.queue_bind(exchange='topic_logs',
                       queue=queue_name,
                       routing_key=binding_key)

print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
    print(" [x] %r:%r" % (method.routing_key, body))

四、RabbitMQ的rpc实现