准备阶段
1、安装ERLang和RabbitMQ，并且启动RabbitMQ
2、pyp install pika
应用阶段
一、使用方法：
1、发送端的使用步骤：
A、建立一个连接
B、通过连接建立一个管道对象
C、声明管道名称
D、利用basic_publish（不会阻塞）在管道里发送数据
E、关闭连接
import pika # 建立连接 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) # 设置管道 channel = connection.channel() # 设置管道名称 channel.queue_declare(queue='hello') # 发布信息，routing_key为管道名称,body为内容 channel.basic_publish(exchange='', routing_key='hello', body='Hello World!') print("[X] Sent 'Hello world!'") # 关闭连接 connection.close()
2、接收端的使用步骤：
A、建立一个连接
B、通过连接建立一个管道对象
C、声明管道名称
D、利用basic_consume监听管道，并交给相应的函数处理，如果有消息过来，此函数会接收到4个参数。
E、start_consume开始接收，默认为阻塞
import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='hello') def callback(ch, method, properties, body): print("[X] Received %r" % body) # 接收hello管道的消息，交给callbak处理 channel.basic_consume('hello', callback) print('[*] waiting for messages.To exit press Ctrl+C') # 开始接收消息，默认阻塞 channel.start_consuming()
注意：一个生产者可对多个消费者，生产的每个消息会按顺序发给消费者，而不会一次全部都发。
二、服务器端的确认
在接收端的basic_publich（）加上auto_ack=True的参数，则接收端一收到消息就发给rabbitmq服务器确认，服务器就把消息从队列中删除。如果设为False，则不会给服务器确认，消息一直存在队列中，除非在callback函数中添加ch.basic_ack(delivery_tag=method.delivery_tag)，则会提醒服务器删除消息
import pika import time connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='hello') def callback(ch, method, properties, body): print('-->', ch, method, properties) time.sleep(10) print("[X] Received %r" % body) ch.basic_ack(delivery_tag=method.delivery_tag) # 手动确认，配合auto_ack=False使用 # 接收hello管道的消息，交给callbak处理 channel.basic_consume('hello', callback, auto_ack=False) # 加上auto_ack=True一发给服务器就确认，就把消息从队列删除 print('[*] waiting for messages.To exit press Ctrl+C') # 开始接收消息，默认阻塞 channel.start_consuming()
import pika # 建立连接 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) # 设置管道 channel = connection.channel() # 设置管道名称 channel.queue_declare(queue='hello') # 发布信息，routing_key为管道名称,body为内容 channel.basic_publish(exchange='', routing_key='hello', body='Hello World!') print("[X] Sent 'Hello world!'") # 关闭连接 connection.close()
查看消息队列的方法：
1、在cmd中打开rabbitmq安装目录下的sbin目录
2、rabbitmqctl.bat list_queues
消息队列的持久化
一、概念：由于RabbitMQ服务重启则会清空缓存中的队列，故需要把消息队列持久化，以便再发消息。
二、实现步骤
1、发送端与接收端均需要在声明队列名称中加上参数：durable = True。但这只实现了此队列的持久化，此队列中的消息服务一重启还是会消失。
2、在basic_publish添加参数：properties = pika.BasicProperites(delivery_mode=2)
import pika # 建立连接 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) # 设置管道 channel = connection.channel() # 设置管道名称 channel.queue_declare(queue='hello', durable=True) # 发布信息，routing_key为管道名称,body为内容 channel.basic_publish(exchange='', properties=pika.BasicProperties(delivery_mode=2), routing_key='hello', body='Hello World!') print("[X] Sent 'Hello world!'") # 关闭连接 connection.close()
import pika import time connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='hello', durable=True) def callback(ch, method, properties, body): print('-->', ch, method, properties) time.sleep(10) print("[X] Received %r" % body) ch.basic_ack(delivery_tag=method.delivery_tag) # 手动确认，配合auto_ack=False使用 # 接收hello管道的消息，交给callbak处理 channel.basic_consume('hello', callback, auto_ack=False) # 加上auto_ack=True一发给服务器就确认，就把消息从队列删除 print('[*] waiting for messages.To exit press Ctrl+C') # 开始接收消息，默认阻塞 channel.start_consuming()
负载均衡
一、由于每台电脑的性能不同，处理消息的速度不同。速度快的电脑可发送多条指令，慢的发少一点
二、实现步骤
在客户端中basic_consume（）前加上basic_qos(prefetch_count=1)
import pika import time connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='hello', durable=True) def callback(ch, method, properties, body): print('-->', ch, method, properties) print("[X] Received %r" % body) ch.basic_ack(delivery_tag=method.delivery_tag) # 手动确认，配合auto_ack=False使用 # 定义接收端还在处理的消息条数时发送端发送消息 channel.basic_qos(prefetch_count=1) # 接收hello管道的消息，交给callbak处理 channel.basic_consume('hello', callback, auto_ack=False) # 加上auto_ack=True一发给服务器就确认，就把消息从队列删除 print('[*] waiting for messages.To exit press Ctrl+C') # 开始接收消息，默认阻塞 channel.start_consuming()
广播消息
一、原理图：
二、发送端的实现：
1、声明管道的名称，类型，channel.exchage_declare(exchage='logs',exchage_type='fanout')
2、在exchange中发布信息：channel.basic_publish(exchange='logs',routing_key='',body=msg)
三、接收端的实现
1、声明管道的名称、类型
2、生成一个随机队列，并且此队列用完会自动删除。result = channel.queue_declare('',exclusive=True)
queue_name = result.method.queue
3、队列与Exchange的绑定
channel.queue_bind(queue_name,'logs')
4、channel.basic_consume()
5、channel.start_consuming()
import pika # 建立连接对象 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) # 创建管道对象 channel = connection.channel() # 为管道中的exchange起个名字，设置exchange类型 msg = 'Info of the World!' # exchange的名称和类型 channel.exchange_declare(exchange='logs', exchange_type='fanout') # 发布信息 channel.basic_publish(exchange='logs', routing_key='', body=msg) print("[X] sent Hello World") connection.close()
import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() # 声明exchange的类型，名称 channel.exchange_declare(exchange='logs', exchange_type='fanout') # 随机生成一个队列 result = channel.queue_declare('', exclusive=True) # 获取队列名称 queue_name = result.method.queue # 队列和exchange绑定 channel.queue_bind(queue=queue_name, exchange='logs') print("[*] waiting for exchange.Press Ctrl+C to exit") def callback(ch, method, properties, body): print("[X] received %r" % body) channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True) channel.start_consuming()
注意：发送者就像收音机那样，不管你收到没有，只发一次。
发送到指定的接收端
一、原理图
二、实现步骤
1、发送端（只需声明队列和发布消息）
A、使用Exchange的类型为direct
B、发布basic_publish()消息时要设置参数routing_key，此处为了与接收端的routing_key匹配。
2、接收端（需要声明随机队列，必须是随机队列，并把队列与exchange绑定）
A、声明队列
B、把队列与exchange绑定，channel.queue_bind(queue,exchange,routing_key)，此处的routing_key是为了与发送端的routing_key匹配
C、调用basic_consume。
D、start_consuming
import pika import sys connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost')) channel = connection.channel() # 设置exchange类型，名称 channel.exchange_declare(exchange='direct_logs', exchange_type='direct') severity = sys.argv[1] if len(sys.argv) > 1 else 'info' msg = ' '.join(sys.argv[2:]) or 'Hello World!' channel.basic_publish(exchange='direct_logs', routing_key=severity, body=msg ) connection.close()
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 if len(sys.argv) < 2: print('Usage: %s [info] [warning] [error]' % sys.argv[0]) sys.exit(-1) severities = sys.argv[1:] for severity in severities: channel.queue_bind(queue=queue_name, exchange='direct_logs', routing_key=severity) def callback(ch, method, properites, body): print('Receiver %r:%r' % (method.routing_key, body)) channel.basic_consume(queue=queue_name, on_message_callback=callback) channel.start_consuming()
topic类型的Exchange
一、主要作用：使用topic类型的Exchange，可使得rabbitmq识别带有通配符的routing_key。
二、常用的通配符：
*：和windows的通配符一样
#：代表所有
三、用法：和direct差不多，只是改一下Exchange类型
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(queue='', exclusive=True) queue_name = result.method.queue if len(sys.argv) < 2: print('Usage: %s [info] [warning] [error]' % sys.argv[0]) exit(-1) serverties = sys.argv[1:] for severty in serverties: channel.queue_bind(queue=queue_name, exchange='topic_logs', routing_key=severty) def callback(ch, method, properties, body): print('Receiver %r:%r' % (method.routing_key, body)) channel.basic_consume(queue=queue_name, on_message_callback=callback) channel.start_consuming()
import pika import sys connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost')) channel = connection.channel() channel.exchange_declare(exchange='topic_logs', exchange_type='topic') serverity = sys.argv[1] if len(sys.argv) > 1 else 'anonymous.info' msg = ' '.join(sys.argv[2:]) or 'Hello World!' channel.basic_publish(exchange='topic_logs', routing_key=serverity, body=msg) connection.close()
RPC
import pika import uuid class FibonacciRpcClient(object): def __init__(self, num): """初始化函数""" # 斐波纳契参数 self.num = num self.connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost')) self.channel = self.connection.channel() # 生成队列发送命令参数 self.channel.queue_declare(queue='rpc_queue') # 随机生成一个队列，以便接收结果 result = self.channel.queue_declare(queue='', exclusive=True) self.queue_name = result.method.queue self.response = None self.channel.basic_consume(queue=self.queue_name, on_message_callback=self.on_response) def on_response(self, ch, method, properties, body): """处理response""" # 比较本方的的id标识符和服务器端的id标识符，相同则说明body是客户端需要的，设response为body if properties.correlation_id == self.cor_id: self.response = body def send_number_to_server(self): """发送数字给服务器计算斐波纳契数""" # 获取客户端的id标识符 self.cor_id = str(uuid.uuid4()) # 发送标识符和结果队列给服务端 self.channel.basic_publish(exchange='', routing_key='rpc_queue', body=str(self.num), properties=pika.BasicProperties(reply_to=self.queue_name, correlation_id=self.cor_id)) def result_from_server(self): """从服务器端收结果""" while self.response is None: self.connection.process_data_events() # start_consuming的非阻塞版 print(self.response) fibprcclient = FibonacciRpcClient(7) fibprcclient.send_number_to_server() fibprcclient.result_from_server()
import pika connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost')) channel = connection.channel() channel.queue_declare(queue='rpc_queue') fib_result = 0 def on_request(ch, method, properties, body): n = int(body) cor_id = properties.correlation_id fib_result = fib(n) channel.basic_publish(exchange='', routing_key=properties.reply_to, body=str(fib_result), properties=pika.BasicProperties(correlation_id=cor_id)) ch.basic_ack(delivery_tag=method.delivery_tag) def fib(n): if n == 1 or n == 2: return 1 else: return fib(n-1) + fib(n-2) channel.basic_qos(prefetch_count=1) channel.basic_consume(queue='rpc_queue', on_message_callback=on_request, auto_ack=False) channel.start_consuming()
一、新知识点：
1、uuid模块：uuid.uuid4()随机生成一个uuid类型的数据
2、properties=pika.BasicProperties(reply_to=self.queue_name,correlation_id=self.cor_id))：设置回复的queue，并且利用cor_id来确认回复的答案
3、self.connection.process_data_events()：非阻塞版的start_consuming()
Rabbitmq远程连接
默认情况下，guest帐号不能远程连接到rabbitmq
1、服务器配置(centos)：添加一个新的帐户
（1）、rabbitmq-plugins enable rabbitmq_management
（2）、Centos允许防火墙通过：
fire-wall-cmd --zone=public --add-port=15672 --permanent
fire-wall-cmd --zone=public --add-port=5672 --permanent
（3）、通过ip:15672访问，添加用户，并且设置权限
2、Python程序
（1）、需要用户认证：auth = pika.PlainCredentials(username,password)
conn = pika.BlockingConnection(pika.ConnectionParameters(host=hostname,
credentials=auth))
1395
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
