day11-rabbitmq

RabbitMQ：消息队列，用于独立程序通信

依赖语言：erlang

一、简单通信

# ---------------------------------------------
# send端(producer)
# 建立socket->声明管道->声明queue->通过一个exchange发送内容至queue->关闭连接
# ---------------------------------------------

import pika
# 通过这个实例先建立一个socket
# rabbitmq默认端口15672，在python中使用pika模块
# 所有的socket 传输都是bytes类型
connection = pika.BlockingConnection(pika.ConnectionParameters("localhost"))
# 声明一个管道
channel = connection.channel()
# 声明queue, 名为test
# durable持久化队列，重启rabbitmq服务不会丢队列，但会丢消息，durable服务端和客户端都需写明
channel.queue_declare(queue="hello", durable=True)
# 发送
# 一个生产者对应多个消费者是采用轮询机制，公平的依次发给每一个消费者，每个消费者消费1个
# 假如一个生产者对应3个消费者，生产者发第一条消息，第一个消费者消费，生产者发第二条信息，第二个消费者消费...
channel.basic_publish(exchange="",
                      routing_key="hello",   # queue的名字
                      body="hello world",   # body是发送内容
                      properties=pika.BasicProperties(delivery_mode=2,),    # 使消息持久化
                      )
print("[x] Sent 'hello world'")
# 关闭连接
connection.close()

 

# ---------------------------------------------
# receive端(consumers)
# 创建socket连接->创建管道->声明queue->创建回调函数callback->消费的消息->开启消费
# ---------------------------------------------


import pika
# 使用byte格式
# 建立一个socket连接
# 消费者和生产者不一定在同一台机器上
connection = pika.BlockingConnection(pika.ConnectionParameters("localhost"))
# 创建一个管道
channel = connection.channel()
# 如果你确认queue已经存在可不写，但我们不确定是生产者还是消费者先运行，如果消费者先运行，此时这个queue不存在，会直接报错
# durable持久化，重启rabbitmq服务不会丢消息，durable服务端和客户端都需写明
channel.queue_declare(queue="test", durable=True)


def callback(ch, method, properites, body):
    print("--->", ch, method, properites)
    print(" [x] Received %r" % body)
    # 手动确认消息已被消费
    ch.basic_ack(delivery_tag=method.delivery_tag)

# 设置消费限额，设置为1则表示当前在处理的消息超过1条就不给此消费端发消息
channel.basic_qos(prefetch_count=1)
# 消费消息
channel.basic_consume(
    callback,   # 如果收到消息，就调用callback函数来处理消息
    queue="test",    # queue的名字
    # no_ack=True,    # 表示不关心消息是否处理完，一般情况不加，如果客户端没有确认，rabbitmq不会把消息删除
    )
print(' [*] Waiting for messages. To exit press CTRL+C')

# 这个start只要一启动，就一直运行，它不止收一条，而是永远收下去，没有消息就在这边卡住
# 正式开始收消息
channel.start_consuming()

二、广播模式

生产者：

import pika
import sys

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

# ---------------------------------------------------------------
# 1. fanout广播模式
# fanout广播模式，实时消息，如果没有消费端接收就消息就没了
channel.exchange_declare(exchange='logs',
                         type='fanout')

message = "info: Hello World!"
# routing_key为空，广播模式不绑定队列
channel.basic_publish(exchange='logs',
                      routing_key='',
                      body=message)


# -----------------------------------------------------------------
# 2.direct广播模式, 实时消息，有选择地接收消息，关键字发送
channel.exchange_declare(exchange='direct_logs',
                         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)

# -----------------------------------------------------------------
# 3.topic更细致的消息过滤
channel.exchange_declare(exchange='topic_logs',
                         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" % message)
connection.close()

消费者：

import pika
import sys

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

# ---------------------------------------------------------------
# 1. fanout广播模式
channel.exchange_declare(exchange='logs',
                         type='fanout')

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

# 队列绑定转发器，消费者只会从队列里拿消息
channel.queue_bind(exchange='logs',
                   queue=queue_name)

# -----------------------------------------------------------------
# 2.direct广播模式

channel.exchange_declare(exchange='direct_logs',
                         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)

# 遍历绑定
for severity in severities:
    channel.queue_bind(exchange='direct_logs',
                       queue=queue_name,
                       routing_key=severity)

# -----------------------------------------------------------------
# 3.topic更细致的消息过滤
# 接收所有消息#
# 接收以mysql开头的消息: mysql.*
# 接收以info结尾的消息: *.info
channel.exchange_declare(exchange='topic_logs',
                         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" % body)

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

channel.start_consuming()

三、RPC=>remote procedure call

Client端：

import pika,uuid,time

class FibonacciRpcClient(object):
    "斐波那契数列rpc客户端"

    def __init__(self):
        self.connection = pika.BlockingConnection(pika.ConnectionParameters
                                                  (host="localhost"))
        self.channel = self.connection.channel()
        result = self.channel.queue_declare(exclusive=True)
        self.callback_queue = result.method.queue
        self.channel.basic_consume(self.on_response,no_ack=True,
                                   queue=self.callback_queue)

    def on_response(self, ch, method, props, body):
        print("---->", method, props)
        if self.corr_id == props.correlation_id:    # 我发过去的结果就是我想要的结果，保持数据的一致性
            self.response = body


    def call(self,n):
        self.response = None
        self.corr_id = str(uuid.uuid4())
        self.channel.publish(exchange="",
                             routing_key="rpc_queue",
                             properties=pika.BasicProperties(
                                 reply_to=self.callback_queue,
                                 correlation_id=self.corr_id),
                             body=str(n))
        while self.response is None:
            self.connection.process_data_events()   # 非阻塞版的start_consumer()
            print("no msg....")
            time.sleep(0.5)
        return int(self.response)

if __name__ == "__main__":
    fibonacci_rpc = FibonacciRpcClient()
    print(" [x] Requesting fib(30)")
    response = fibonacci_rpc.call(30)
    print(" [.] Got %r" % response)

Server端：

import pika
import time
connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))

channel = connection.channel()

channel.queue_declare(queue='rpc_queue')

def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)

def on_request(ch, method, props, body):
    n = int(body)

    print(" [.] fib(%s)" % n)
    response = fib(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)

channel.basic_qos(prefetch_count=1)
channel.basic_consume(on_request, queue='rpc_queue')

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