RabbitMQ实践-code

简单模式-生产与消费

producer生产者

import pika
import json
 
credentials = pika.PlainCredentials('guest', 'guest')
conn = pika.BlockingConnection(
    pika.ConnectionParameters(host='your robbitmq server', port=5672, virtual_host='/', credentials=credentials))
 
channel = conn.channel()
result = channel.queue_declare(queue='zy_test')
 
for i in range(100):
    message = json.dumps({'OrderId': f'1000{i}'})
    channel.basic_publish(exchange='', routing_key='zy_test', body=message)
    print(message)
 
conn.close()

consumer消费者

import pika
import json
 
credentials = pika.PlainCredentials('guest', 'guest')
conn = pika.BlockingConnection(
    pika.ConnectionParameters(host='your robbitmq server', port=5672, virtual_host='/', credentials=credentials))
 
channel = conn.channel()
# durable 持久化 消息不丢失
channel.queue_declare(queue='zy_test', durable=True)
# 负载均衡：使用basicQos( prefetchCount = 1)方法，来限制RabbitMQ只发不超过1条的消息给同一个消费者。当消息处理完毕后，有了反馈，才会进行第二次发送。
channel.basic_qos(prefetch_count=1)
 
def callback(ch, method, properties, body):
    ch.basic_ack(delivery_tag=method.delivery_tag)
    print(body.decode())
 
channel.basic_consume(queue='zy_test', on_message_callback=callback)
channel.start_consuming()

发布与订阅

发布与订阅要借助交换机（EXchange）的原理来实现：

EXchange一共有四种工作模式：fanout，direct，topic，headers（不常用）

1、fanout模式

fanout模式下，传递到exchange的消息将会转发到所有与其绑定的queue上。通俗理解为：发送给与exchange绑定的所有queue

• 不需要指定routing_key，即使指定了也是无效的
• 需要提前将exchange和queue绑定，多对多关系：一个exchange可以绑定多个queue，一个queue可以绑定多个exchange
• 需要先启动订阅者，此模式下的队列是consumer随机生成的，发布者仅仅发消息到exchange，由exchange转发消息至queue。

发布者：

import json
from time import sleep
 
import pika
 
credentials = pika.PlainCredentials('guest', 'guest')
conn = pika.BlockingConnection(
    pika.ConnectionParameters(host='your robbitmq server', port=5672, virtual_host='/', credentials=credentials))
 
channel = conn.channel()
# 声明exchange，由exchange指定消息在哪个队列传递，如不存在，则创建。durable = True 代表exchange持久化存储，False 非持久化存储
channel.exchange_declare(exchange='zy_test', exchange_type='fanout', durable=True)
 
for i in range(100):
    message = json.dumps({'OrderId': f'20000{i}'})
    # 向队列插入数值 routing_key是队列名。delivery_mode = 2 声明消息在队列中持久化，delivery_mod = 1 消息非持久化。routing_key 不需要配置
    channel.basic_publish(
        exchange='zy_test',
        routing_key='',
        body=message,
        properties=pika.BasicProperties(delivery_mode=2)
    )
    print(f'Sent: {message}')
    sleep(1)
conn.close()

订阅者：

import pika
 
credentials = pika.PlainCredentials('guest', 'guest')
conn = pika.BlockingConnection(
    pika.ConnectionParameters(host='your robbitmq server', port=5672, virtual_host='/', credentials=credentials))
 
channel = conn.channel()
channel.exchange_declare(exchange='logs', exchange_type='fanout')
# 创建临时队列,队列名传空字符，consumer关闭后，队列自动删除
result = channel.queue_declare(queue='', exclusive=True)
# 绑定exchange和队列queue，exchange 使我们能够确切地指定消息应该到哪个队列去
channel.queue_bind(exchange='zy_test', queue=result.method.queue)
 
 
# 回调函数，处理消息内容
def callback(ch, method, properties, body):
    ch.basic_ack(delivery_tag=method.delivery_tag)
    print(body.decode())
 
 
# auto_ack设置成 False，在调用callback函数时，未收到确认标识，消息会重回队列。True，无论调用callback成功与否，消息都被消费掉
channel.basic_consume(result.method.queue, callback, auto_ack=False)
channel.start_consuming()

2、direct模式

direct模式原理：消息发送至exchange，exchange根据路由键（routing_key）转达到对应的queue上；通俗的理解为：根据routing_key过滤。

• 可以使用默认exchange=''， 也可以自定义exchange
• direct模式不需要将exchange和queue，routing_key，queue进行绑定，当然可以绑定；
• 传递或接收消息时 需要指定 routing_key
• 需要先启动 订阅者，此模式下的consumer是随机生成的，发布者仅仅发布消息到exchange，由exchange转发消息至queue。如果后启动订阅者，则会丢失启动前的消息数据。

发布者：

import json
from time import sleep
 
import pika
 
credentials = pika.PlainCredentials('guest', 'guest')
conn = pika.BlockingConnection(
    pika.ConnectionParameters(host='your robbitmq server', port=5672, virtual_host='/', credentials=credentials))
 
channel = conn.channel()
channel.exchange_declare(exchange='zy_test_d', durable=True, exchange_type='direct')
for i in range(100):
    message = json.dumps({'OrderId': f'30000{i}'})
    # 向队列插入数值 routing_key是队列名。delivery_mode = 2 声明消息在队列中持久化，delivery_mod = 1 消息非持久化。routing_key 不需要配置
    channel.basic_publish(
        exchange='zy_test_d',
        routing_key='OrderId',
        body=message,
        properties=pika.BasicProperties(delivery_mode=2)
    )
    print(f'Sent: {message}')
    sleep(1)
conn.close()

订阅者：

import pika
 
credentials = pika.PlainCredentials('guest', 'guest')
conn = pika.BlockingConnection(
    pika.ConnectionParameters(host='your robbitmq server', port=5672, virtual_host='/', credentials=credentials))
 
channel = conn.channel()
channel.exchange_declare(exchange='zy_test_d', exchange_type='direct', durable=True)
# 创建临时队列,队列名传空字符，consumer关闭后，队列自动删除
result = channel.queue_declare(queue='', exclusive=True)
# 绑定exchange和队列queue，exchange 使我们能够确切地指定消息应该到哪个队列去
channel.queue_bind(exchange='zy_test_d', queue=result.method.queue, routing_key='OrderId')
 
 
# 回调函数，处理消息内容
def callback(ch, method, properties, body):
    ch.basic_ack(delivery_tag=method.delivery_tag)
    print(body.decode())
 
 
# auto_ack设置成 False，在调用callback函数时，未收到确认标识，消息会重回队列。True，无论调用callback成功与否，消息都被消费掉
channel.basic_consume(result.method.queue, callback, auto_ack=False)
channel.start_consuming()

3、topic模式

topic模式和第二种模式差不多，exchange 也是通过 路由键 routing_key 来转发消息到指定的 queue 。 _不同点是 routing_key 使用正则表达式支持模糊匹配_，但匹配规则又与常规的正则表达式不同，比如“#”是匹配全部，“*”是匹配一个词。
举例：routing_key =“#orderid#”，意思是将消息转发至所有 routing_key 包含 “orderid” 字符的队列中。代码和模式二 类似，就不贴出来了。

基于rabbitMQ的RPC

Callback queue 回调队列

一个客户端向服务器发送请求，服务器端处理请求后，将其处理结果保存在一个存储体中。而客户端为了获得处理结果，那么客户在向服务器发送请求时，同时发送一个回调队列地址 reply_to。

Correlation id 关联标识

一个客户端可能会发送多个请求给服务器，当服务器处理完后，客户端无法辨别在回调队列中的响应具体和那个请求时对应的。为了处理这种情况，客户端在发送每个请求时，同时会附带一个独有correlation_id属性，这样客户端在回调队列中根据correlation_id字段的值就可以分辨此响应属于哪个请求。

客户端发送请求

客户端在发送RPC请求到RPC请求队列时，客户端至少发送带有reply_to以及correlation_id两个属性的信息

服务端工作流

等待接受客户端发来RPC请求，当请求出现的时候，服务器从RPC请求队列中取出请求，进行处理后，将响应发送到reply_to指定的回调队列中

客户端接受处理结果

客户端等待回调队列中出现响应，当响应出现时，它会根据响应中correlation_id字段的值，将其返回给对应的应用

server端

import pika
 
 
def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)
 
 
# 处理RPC请求队列中数据，并回调
def on_request(ch, method, properties, body):
    n = int(body)
    print(f'[recv] n={n}')
    response = fib(n)
 
    ch.basic_publish(exchange='',
                     routing_key=properties.reply_to,
                     properties=pika.BasicProperties(correlation_id=properties.correlation_id),
                     body=str(response)
                     )
    ch.basic_ack(delivery_tag=method.delivery_tag)
 
# 鉴权
credentials = pika.PlainCredentials('guest', 'guest')
# 建立链接
conn = pika.BlockingConnection(
    pika.ConnectionParameters(host='your rabbitmq host', port=5672, virtual_host='/', credentials=credentials))
# 建立会话
channel = conn.channel()
# 声明RPC请求队列
channel.queue_declare(queue='rpc_queue')
# 负载均衡
channel.basic_qos(prefetch_count=1)
# 消费客户端的消息，并请求回调方法on_request
channel.basic_consume(queue='rpc_queue', on_message_callback=on_request)
channel.start_consuming()

client端

import uuid
import pika
 
 
class fibRpcClient:
    def __init__(self):
        self.__credentials = pika.PlainCredentials('guest', 'guest')
        self.conn = pika.BlockingConnection(pika.ConnectionParameters(
            host='your rabbitmq server', port=5672, virtual_host='/', credentials=self.__credentials
        ))
        # 定义回调消息会话
        self.channel = self.conn.channel()
        result = self.channel.queue_declare(queue='rpc_back', exclusive=True)
        self.callback_queue = result.method.queue
        self.correlation_id = str(uuid.uuid4())
        self.response = None
        # 收到回调消息，开始消费
        self.channel.basic_consume(
            on_message_callback=self.on_response,
            queue=self.callback_queue,
            auto_ack=False
        )
 
    # 收到消息后 数据处理方法
    def on_response(self, ch, method, properties, body):
        if self.correlation_id == properties.correlation_id:
            self.response = body
 
    def call(self, n):
        # 发送消息
        self.channel.basic_publish(
            exchange='',
            routing_key='rpc_queue',
            body=str(n),
            properties=pika.BasicProperties(
                reply_to=self.callback_queue,
                correlation_id=self.correlation_id
            )
        )
        print(f'[send] n={n}')
        # 没有收到相应，就一直非阻塞式的start_consumer
        while self.response is None:
            self.conn.process_data_events()
        print(f'[recv] result is {int(self.response)}')
 
if __name__ == '__main__':
    fib = fibRpcClient()
    fib.call(17)

持久化

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

1、queue 声明持久化

声明消息队列，消息将在这个队列传递，如不存在，则创建。
durable = True 代表消息队列持久化存储，False 非持久化存储

result = channel.queue_declare(queue = 'python-test',durable = True)

2、exchange 声明持久化

声明exchange，由exchange指定消息在哪个队列传递，如不存在，则创建。
durable = True 代表exchange持久化存储，False 非持久化存储

channel.exchange_declare(exchange = 'python-test', durable = True)

3、消息持久化

虽然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))

4、acknowledgement消息不丢失

消费者（consumer）调用callback函数时，会存在处理消息失败的风险，如果处理失败，则消息丢失。但是也可以选择消费者处理失败时，将消息回退给 rabbitmq ，重新再被消费者消费，这个时候需要设置确认标识。

auto_ack设置成 False，在调用callback函数时，未收到确认标识，消息会重回队列。
True，无论调用callback成功与否，消息都被消费掉 

channel.basic_consume(callback,queue = 'python-test', auto_ack= False)