Python RabbitMQ Demo
fanout消息订阅模式
-
生产者
# 生产者代码 import pika credentials = pika.PlainCredentials('guest', 'guest') # mq用户名和密码 # 虚拟队列需要指定参数 virtual_host，如果是默认的可以不填。 connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1', credentials=credentials)) # 建立rabbit协议的通道 channel = connection.channel() # fanout: 所有绑定到此exchange的queue都可以接收消息（实时广播） # direct: 通过routingKey和exchange决定的那一组的queue可以接收消息（有选择接受） # topic： 所有符合routingKey(此时可以是一个表达式)的routingKey所bind的queue可以接收消息（更细致的过滤） channel.exchange_declare('logs', exchange_type='fanout') #因为是fanout广播类型的exchange，这里无需指定routing_key for i in range(10): channel.basic_publish(exchange='logs', routing_key='', body='Hello world！%s' % i) # 关闭与rabbitmq server的连接 connection.close() -
消费者
import pika credentials = pika.PlainCredentials('guest', 'guest') # BlockingConnection:同步模式 connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1', credentials=credentials)) channel = connection.channel() #作为好的习惯，在producer和consumer中分别声明一次以保证所要使用的exchange存在 channel.exchange_declare(exchange='logs', exchange_type='fanout') # 随机生成一个新的空的queue，将exclusive置为True，这样在consumer从RabbitMQ断开后会删除该queue # 是排他的。 result = channel.queue_declare('', exclusive=True) # 用于获取临时queue的name queue_name = result.method.queue # exchange与queue之间的关系成为binding # binding告诉exchange将message发送该哪些queue channel.queue_bind(exchange='logs', queue=queue_name) # 定义一个回调函数来处理消息队列中的消息，这里是打印出来 def callback(ch, method, properties, body): # 手动发送确认消息 print(body.decode()) # 告诉生产者，消费者已收到消息 #ch.basic_ack(delivery_tag=method.delivery_tag) # 如果该消费者的channel上未确认的消息数达到了prefetch_count数，则不向该消费者发送消息 channel.basic_qos(prefetch_count=1) # 告诉rabbitmq，用callback来接收消息 # 默认情况下是要对消息进行确认的，以防止消息丢失。 # 此处将no_ack明确指明为True，不对消息进行确认。 channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True) # 自动发送确认消息 # 开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理 channel.start_consuming()
rabbitmq延迟队列
-
MQ类
""" Created on Fri Aug 3 17:00:44 2018 """ import pika,json,logging class RabbitMQClient: def __init__(self, conn_str='amqp://guest:guest@127.0.0.1/%2f'): self.exchange_type = "direct" self.connection_string = conn_str self.connection = pika.BlockingConnection(pika.URLParameters(self.connection_string)) self.channel = self.connection.channel() self._declare_retry_queue() #RetryQueue and RetryExchange logging.debug("connection established") def close_connection(self): self.connection.close() logging.debug("connection closed") def declare_exchange(self, exchange): self.channel.exchange_declare(exchange=exchange, exchange_type=self.exchange_type, durable=True) def declare_queue(self, queue): self.channel.queue_declare(queue=queue, durable=True,) def declare_delay_queue(self, queue,DLX='RetryExchange',TTL=60000): """ 创建延迟队列 :param TTL: ttl的单位是us，ttl=60000 表示 60s :param queue: :param DLX:死信转发的exchange :return: """ arguments={} if DLX: #设置死信转发的exchange arguments[ 'x-dead-letter-exchange']=DLX if TTL: arguments['x-message-ttl']=TTL print(arguments) self.channel.queue_declare(queue=queue, durable=True, arguments=arguments) def _declare_retry_queue(self): """ 创建异常交换器和队列，用于存放没有正常处理的消息。 :return: """ self.channel.exchange_declare(exchange='RetryExchange', exchange_type='fanout', durable=True) self.channel.queue_declare(queue='RetryQueue', durable=True) self.channel.queue_bind('RetryQueue', 'RetryExchange','RetryQueue') def publish_message(self,routing_key, msg,exchange='',delay=0,TTL=None): """ 发送消息到指定的交换器 :param exchange: RabbitMQ交换器 :param msg: 消息实体，是一个序列化的JSON字符串 :return: """ if delay==0: self.declare_queue(routing_key) else: self.declare_delay_queue(routing_key,TTL=TTL) if exchange!='': self.declare_exchange(exchange) self.channel.basic_publish(exchange=exchange, routing_key=routing_key, body=msg, properties=pika.BasicProperties( delivery_mode=2, type=exchange )) self.close_connection() print("message send out to %s" % exchange) logging.debug("message send out to %s" % exchange) def start_consume(self,callback,queue='#',delay=1): """ 启动消费者，开始消费RabbitMQ中的消息 :return: """ if delay==1: queue='RetryQueue' else: self.declare_queue(queue) self.channel.basic_qos(prefetch_count=1) try: self.channel.basic_consume( # 消费消息 queue, # 你要从那个队列里收消息 callback, # 如果收到消息，就调用callback函数来处理消息 ) self.channel.start_consuming() except KeyboardInterrupt: self.stop_consuming() def stop_consuming(self): self.channel.stop_consuming() self.close_connection() def message_handle_successfully(channel, method): """ 如果消息处理正常完成，必须调用此方法， 否则RabbitMQ会认为消息处理不成功，重新将消息放回待执行队列中 :param channel: 回调函数的channel参数 :param method: 回调函数的method参数 :return: """ channel.basic_ack(delivery_tag=method.delivery_tag) def message_handle_failed(channel, method): """ 如果消息处理失败，应该调用此方法，会自动将消息放入异常队列 :param channel: 回调函数的channel参数 :param method: 回调函数的method参数 :return: """ channel.basic_reject(delivery_tag=method.delivery_tag, requeue=False) -
生产者
from rabbitmq_demo import RabbitMQClient print("start program") client = RabbitMQClient() msg1 = '{"key":"10秒钟后执行"}' client.publish_message('test-delay',msg1,delay=1,TTL=10000) print("message send out") -
消费者
from rabbitmq_demo import RabbitMQClient import json print("start program") client = RabbitMQClient() def callback(ch, method, properties, body): msg = body.decode() print(msg) # 如果处理成功，则调用此消息回复ack，表示消息成功处理完成。 RabbitMQClient.message_handle_successfully(ch, method) queue_name = "RetryQueue" client.start_consume(callback,queue_name,delay=0)
RPC远程过程调用
-
生产者
# 生产者代码 import pika import uuid # 在一个类中封装了connection建立、queue声明、consumer配置、回调函数等 class FibonacciRpcClient(object): def __init__(self): # 建立到RabbitMQ Server的connection self.connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1', credentials=pika.PlainCredentials('guest', 'guest'))) self.channel = self.connection.channel() # 声明一个临时的回调队列 result = self.channel.queue_declare('', exclusive=True) self._queue = result.method.queue # 此处client既是producer又是consumer，因此要配置consume参数 # 这里的指明从client自己创建的临时队列中接收消息 # 并使用on_response函数处理消息 # 不对消息进行确认 self.channel.basic_consume(queue=self._queue, on_message_callback=self.on_response, auto_ack=True) self.response = None self.corr_id = None # 定义回调函数 # 比较类的corr_id属性与props中corr_id属性的值 # 若相同则response属性为接收到的message def on_response(self, ch, method, props, body): print(body) if self.corr_id == props.correlation_id: print(body, '----') self.response = body def call(self, n): # 初始化response和corr_id属性 self.corr_id = str(uuid.uuid4()) # 使用默认exchange向server中定义的rpc_queue发送消息 # 在properties中指定replay_to属性和correlation_id属性用于告知远程server # correlation_id属性用于匹配request和response self.channel.basic_publish(exchange='', routing_key='rpc_queue', properties=pika.BasicProperties( reply_to=self._queue, correlation_id=self.corr_id, ), # message需为字符串 body=str(n)) while self.response is None: self.connection.process_data_events() return int(self.response) # 生成类的实例 fibonacci_rpc = FibonacciRpcClient() print(" [x] Requesting fib(30)") # 调用实例的call方法 response = fibonacci_rpc.call(31) print(" [.] Got %r" % response) -
消费者
# 消费者代码，这里以生成斐波那契数列为例 import pika # 建立到达RabbitMQ Server的connection connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1', credentials=pika.PlainCredentials('guest', 'guest'))) channel = connection.channel() # 声明一个名为rpc_queue的queue 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) # 回调函数，从queue接收到message后调用该函数进行处理 def on_request(ch, method, props, body): # 由message获取要计算斐波那契数的数字 n = int(body) print(" [.] fib(%s)" % n) # 调用fib函数获得计算结果 channel.basic_consume(queue='', on_message_callback=on_request, auto_ack=True) channel.start_consuming()
单生产者消费者模型
-
生产者
# 生产者代码 import pika credentials = pika.PlainCredentials("guest","guest") # mq用户名和密码，没有则需要自己创建 # 虚拟队列需要指定参数 virtual_host，如果是默认的可以不填。 connection = pika.BlockingConnection(pika.ConnectionParameters(host="127.0.0.1", credentials=credentials)) # 建立rabbit协议的通道 channel = connection.channel() # 声明消息队列，消息将在这个队列传递，如不存在，则创建。durable指定队列是否持久化 channel.queue_declare(queue='python-test', durable=False) # message不能直接发送给queue，需经exchange到达queue，此处使用以空字符串标识的默认的exchange # 向队列插入数值 routing_key是队列名 channel.basic_publish(exchange='', routing_key='python-test', body='Hello wo5555555') # 关闭与rabbitmq server的连接 connection.close() -
消费者
# 消费者代码 import pika credentials = pika.PlainCredentials("guest","guest") # BlockingConnection:同步模式 connection = pika.BlockingConnection(pika.ConnectionParameters(host="127.0.0.1", credentials=credentials)) channel = connection.channel() # 申明消息队列。当不确定生产者和消费者哪个先启动时，可以两边重复声明消息队列。 channel.queue_declare(queue='python-test', durable=False) # 定义一个回调函数来处理消息队列中的消息，这里是打印出来 def callback(ch, method, properties, body): # 手动发送确认消息 ch.basic_ack(delivery_tag=method.delivery_tag) print(body.decode()) # 告诉生产者，消费者已收到消息 # 告诉rabbitmq，用callback来接收消息 # 默认情况下是要对消息进行确认的，以防止消息丢失。 # 此处将auto_ack明确指明为True，不对消息进行确认。 channel.basic_consume('python-test', on_message_callback=callback) # auto_ack=True) # 自动发送确认消息 # 开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理 channel.start_consuming()
消息分发模型
-
生产者
# 生产者代码 import pika credentials = pika.PlainCredentials('guest', 'guest') # mq用户名和密码 # 虚拟队列需要指定参数 virtual_host，如果是默认的可以不填。 connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1', credentials=credentials)) # 建立rabbit协议的通道 channel = connection.channel() # 声明消息队列，消息将在这个队列传递，如不存在，则创建。durable指定队列是否持久化。确保没有确认的消息不会丢失 channel.queue_declare(queue='rabbitmqtest', durable=True) # message不能直接发送给queue，需经exchange到达queue，此处使用以空字符串标识的默认的exchange # 向队列插入数值 routing_key是队列名 # basic_publish的properties参数指定message的属性。此处delivery_mode=2指明message为持久的 for i in range(10): print(i, "----") channel.basic_publish(exchange='', routing_key='rabbitmqtest', body='Hello world！%s' % i, properties=pika.BasicProperties(delivery_mode=2)) # 关闭与rabbitmq server的连接 connection.close() -
消费者
# 消费者代码,consume1与consume2 import pika import time credentials = pika.PlainCredentials('guest', 'guest') # BlockingConnection:同步模式 connection = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1', credentials=credentials)) channel = connection.channel() # 申明消息队列。当不确定生产者和消费者哪个先启动时，可以两边重复声明消息队列。 channel.queue_declare(queue='rabbitmqtest', durable=True) # 定义一个回调函数来处理消息队列中的消息，这里是打印出来 def callback(ch, method, properties, body): # 手动发送确认消息 time.sleep(3) print(body.decode()) # 告诉生产者，消费者已收到消息 ch.basic_ack(delivery_tag=method.delivery_tag) # 如果该消费者的channel上未确认的消息数达到了prefetch_count数，则不向该消费者发送消息 channel.basic_qos(prefetch_count=1) # 告诉rabbitmq，用callback来接收消息 # 默认情况下是要对消息进行确认的，以防止消息丢失。 # 此处将no_ack明确指明为True，不对消息进行确认。 channel.basic_consume('rabbitmqtest', on_message_callback=callback,) # auto_ack=True) # 自动发送确认消息 # 开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理 channel.start_consuming()
此时此刻，非我莫属
