RabbitMQ消息中介之Python使用

 

本文介绍RabbitMQ在python下的基本使用 

 

 

1. RabbitMQ安装，安装RabbitMQ需要预安装erlang语言，Windows直接下载双击安装即可

　　RabbitMQ下载地址：http://www.rabbitmq.com/download.html

　　Erlang语言下载地址：http://www.erlang.org/downloads

 

2. RabbitMQ的基本使用

　　发送消息端

# -*- coding:utf-8 -*-
# Author:Wong Du

import pika

# 生成RabbitMQ连接对象
connection = pika.BlockingConnection(
    pika.ConnectionParameters("localhost")
)

# 建立连接管道
channel = connection.channel()

# 进行队列声明，指定消息要发送到的队列
# durable声明队列持久性，即RabbitMQ重启队列仍旧不丢失（不完全可靠）
# 对现有队列进行durable声明更改无法生效，只有重新声明一个新的队列才生效
channel.queue_declare(queue="hello4", durable=True)

# 发送消息到RabbitMQ消息队列里
channel.basic_publish(
    exchange='',    # 指定交换器
    routing_key="hello4",   # 要绑定的队列
    body="Nice to meet you22223333...",     # 要发送的消息
    properties=pika.BasicProperties(
        delivery_mode=2,        # 通过delivery_mode=2将队列内的消息持久化
    )
)

print("[x] sent 'Nice to meet you22233332...'")
connection.close()

　　接收消息端

# -*- coding:utf-8 -*-
# Author:Wong Du

import pika
import time

# 生成RabbitMQ连接对象
connection = pika.BlockingConnection(
    pika.ConnectionParameters("localhost")
)

# 建立连接管道
channel = connection.channel()

# 声明队列名
channel.queue_declare(queue="hello4", durable=True)

# 定义构建回调函数
def callback(ch, method, properties, body):
    print(ch)
    # time.sleep(20)
    print("[x] received %r" % body)
    # ch.basic_ack(delivery_tag= method.delivery_tag)　　# 接收端回复消息给rabbixmq，代表该消息处理已完成

# 默认情况下，RabbitMQ循环把消息发送给consumer，
# 通过basic_qos(prefetch_count=1)设置，可以在处理并确认完前一个消息之前，不再接收新信息
# 即实现“能者多劳”的效果
channel.basic_qos(prefetch_count=1)

channel.basic_consume(
    callback,
    queue="hello4",
    no_ack=True,  # 如果为True，rabbitmq会在consumer接收到数据时就删除队列中的消息
)

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

 

-----------------------拓展一吓，RabbitMQ消息转发类型：分类筛选，广播，正则匹配------------------------------

3. 分类筛选：RabbitMQ通过消息分类进行对应发送和接收

　　发送消息端

# -*- coding:utf-8 -*-
# Author:Wong Du

import pika
import sys

# 生成RabbitMQ连接对象
connection = pika.BlockingConnection(
    pika.ConnectionParameters('localhost')
)

# 建立连接管道
channel = connection.channel()

# 声明交换器和交换器转发消息类型；'direct'为分类筛选 型
channel.exchange_declare(exchange='_direct',
                         exchange_type='direct')

# 获取脚本命令：根据脚本命令，定义对应严重级别的消息（默认为info类消息）
severity = sys.argv[1] if len(sys.argv) > 1 else 'info'
# 获取要发送给RabbitMQ的消息（默认为Hello world!）
msg = "".join(sys.argv[2:]) or "Hello world!"
'''例：python direct分类筛选_producer.py info 无关痛痒的消息
        表示给RabbitMQ发送一条info级别的消息，消息内容：无关痛痒的消息
'''

channel.basic_publish(exchange='_direct',   # 指定交换器
                      routing_key=severity, # 指定要筛选的字段
                      body=msg              # 要发送给RabbitMQ的消息
)

print("----exec done----")
connection.close()

　　接收消息端

# -*- coding:utf-8 -*-
# Author:Wong Du

import pika
import sys

# 生成RabbitMQ连接对象
connection = pika.BlockingConnection(
    pika.ConnectionParameters('localhost')
)

# 建立连接管道
channel = connection.channel()

# 声明交换器和交换器消息转发类型；'direct'为分类筛选 型
channel.exchange_declare(exchange='_direct',
                         exchange_type='direct',)

# 声明随机独家管道，用以接收RabbitMQ的消息
Random_Queue = channel.queue_declare(exclusive=True)
# 获取管道名
queue_name = Random_Queue.method.queue

# 获取脚本命令；获取相应严重级别的消息，可多个严重级别
severities = sys.argv[1:]
if not severities:
    sys.stderr.write("\033[31;1mUsage: %s [info] [warning] [error]\033[0m" % sys.argv)
    exit()

for severity in severities:
    # 将交换器、队列和筛选分类绑定起来
    # 可以简单理解为：从交换器中通过rongting_key筛选消息后发送给queue
    channel.queue_bind(exchange='_direct',
                       queue=queue_name,
                       routing_key=severity)

# 定义消息回调函数
def callback(ch, method, properties, body):
    print(body)

channel.basic_consume(
    callback,   # 获取消息后交给回调函数进行处理
    queue=queue_name,   # 从指定queue中获取消息
    no_ack=True         # 如果为True，rabbitmq会在consumer接收到数据时就删除队列中的消息
)

print("[*] waiting for messages. To exit press CTRL+C...")
# 运行管道，一直接收消息，如无消息则为阻塞状态
channel.start_consuming()

 

4. 广播：RabbitMQ通过广播发送消息给多个consumer，广播模式下发送消息是实时的，没有即时接收，则丢失

　　发送消息端

# -*- coding:utf-8 -*-
# Author:Wong Du

'''
RabbitMQ交换器广播模式，
当producer发送消息给RabbitMQ时，
RabbitMQ会立即转发给所有当前在线的consumer，然后将消息删除
如当前没有在线的consumer，消息则会丢失
即RabbitMQ下交换器广播模式的消息是实时的，当时发送，当时接收
'''

import pika

# 生成RabbitMQ连接对象
connection = pika.BlockingConnection(
    pika.ConnectionParameters("localhost")
)

# 建立连接管道
channel = connection.channel()

# 声明交换器及交换器消息转发类型；'fanout'为广播类型
channel.exchange_declare(exchange="dudu",
                         # type="fanout",
                         exchange_type="fanout",)

msg = "Hello world! Nice to meet you..."
channel.basic_publish(exchange="dudu",  # 指定交换器
                      routing_key='',   # routing_key必须配置
                      body=msg)         # 要发送给RabbitMQ的消息

print("---exec done---")
connection.close()

　　接收消息端

# -*- coding:utf-8 -*-
# Author:Wong Du

'''
RabbitMQ交换器广播模式，
当producer发送消息给RabbitMQ时，
RabbitMQ会立即转发给所有当前在线的consumer，然后将消息删除
如当前没有在线的consumer，消息则会丢失
即RabbitMQ下交换器广播模式的消息是实时的，当时发送，当时接收
'''

import pika

# 生成RabbitMQ连接对象
connection = pika.BlockingConnection(
    pika.ConnectionParameters("localhost")
)

# 建立连接管道
channel = connection.channel()

# 声明交换器和交换器消息转发类型；'fanout'为广播类型
channel.exchange_declare(exchange="dudu",
                         exchange_type="fanout",)

# 声明随机独家队列，用以接收RabbitMQ发来的消息
Random_Queue = channel.queue_declare(exclusive=True)
# 获取队列名
queue_name = Random_Queue.method.queue

# 将交换器和队列绑定在一起
channel.queue_bind(exchange="dudu",
                   queue=queue_name,)

# 定义消息处理回调函数
def callback(ch, method, properties, body):
    print("[x] received %r" % body)

channel.basic_consume(
    callback,   # 接收到消息后通过回调函数处理
    queue=queue_name,   # 配置获取消息的队列
    # no_ack=True,        # consumer接收到消息后RabbitMQ即删除掉该消息
)

print("[*] waiting for messages. To exit press CTRL+C...")
# 运行管道，一直接收消息，如无消息则为阻塞状态
channel.start_consuming()

 

5. 正则匹配：RabbitMQ通过关键字标记发送消息，通过匹配关键字接收消息

　　发送消息端

# -*- coding:utf-8 -*-
# Author:Wong Du

'''
RabbitMQ交换器的topic正则匹配模式，
可理解为direct分类筛选的升级版，
既能通过关键字标记消息内容，也能通过正则匹配标记关键字
'''

import pika
import sys

# 生成RabbitMQ连接对象
connection = pika.BlockingConnection(
    pika.ConnectionParameters('localhost')
)

# 建立连接管道
channel = connection.channel()

# 声明交换器和交换器消息转发类型；'topic'为正则匹配类型
channel.exchange_declare(exchange='_topic',
                         exchange_type='topic')

# 获取脚本命令；word用来标记msg，msg为消息内容本身
word = sys.argv[1] if len(sys.argv) > 1 else 'any.info'
msg = " ".join(sys.argv[2:]) or "Hello world!"


channel.basic_publish(
    exchange='_topic',      # 指定交换器
    routing_key=word,       # 配置标记关键字
    body=msg                # 要发送给RabbitMQ的消息内容
)

print("----exec done----")
connection.close()

　　接收消息端

# -*- coding:utf-8 -*-
# Author:Wong Du

'''
RabbitMQ交换器的topic正则匹配模式，
可理解为direct分类筛选的升级版，
既能通过关键字标记消息内容，也能通过正则匹配标记关键字
'''

import pika
import sys

# 生成RabbitMQ连接对象
connection = pika.BlockingConnection(
    pika.ConnectionParameters('localhost')
)

# 建立连接管道
chanel = connection.channel()

# 声明交换器和交换器消息转发类型；'topic'为匹配类型
chanel.exchange_declare(exchange='_topic',
                        exchange_type='topic')

# 声明随机独家队列，用以接收RabbitMQ发来的消息
Random_Queue = chanel.queue_declare(exclusive=True)
# 获取随机队列队列名
queue_name = Random_Queue.method.queue

# 获取脚本命令；即匹配规则
severities = sys.argv[1:]
if not severities:
    print("Usage: %s [*.info] [mysql.*] [#]" % sys.argv)
    exit(1)

for severity in severities:
    # 对交换器、队列、匹配规则进行绑定
    chanel.queue_bind(exchange='_topic',
                      queue=queue_name,
                      routing_key=severity,)

# 构建消息处理回调函数
def callback(ch, method, properties, body):
    print(body)

chanel.basic_consume(
    callback,
    queue=queue_name,
    no_ack=True,
)

print("[*] waiting for messages. To exit press CTRL+C...")
# 运行管道，一直接收消息，如无消息则为阻塞状态
chanel.start_consuming()