Python学习笔记整理总结【RabbitMQ队列】
RabbitMQ是消息队列。之前学过的队列queue：线程queue（threading queue），只是多个线程之间进行数据交互。进程queue（processing queue），只是父进程与子进程进行交互。两个独立的程序之间进行交互就需要中间代理（rabbitMQ）
1、最简单的生产者、消费者模型（一对一）
#生产者 #!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) #连接到rabbitmq服务器，因为是在本地测试，所以就用localhost就可以了
channel = connection.channel() #声明一个管道(管道内发消息)
channel.queue_declare(queue='solo') #声明消息队列，消息将在这个队列中进行传递。如果将消息发送到不存在的队列，rabbitmq将会自动清除这些消息。 channel.basic_publish(exchange='', #exchange表示交换器，能精确指定消息应该发送到哪个队列
routing_key='solo', #routing_key 就是queue队列的名称
body='Hello World!' #发送内容
)
print("Sent 'Hello,World!'")
connection.close() #关闭
#生产者
#消费者
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='solo')#如果知道queue='solo'已经存在且运行可以省略，但有可能你不知道 def callback(ch,method,properties,body):
print(ch,method,properties)
#ch:<pika.adapters.blocking_connection.BlockingChannel object at 0x002E6C90> #管道内存对象地址
#methon:<Basic.Deliver(['consumer_tag=ctag1.03d155a851b146f19cee393ff1a7ae38', #具体信息
# 'delivery_tag=1', 'exchange=', 'redelivered=False', 'routing_key=solo'])>
#properties:<BasicProperties>
print("Received %r"%body) channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息
queue="solo",
no_ack=True) #接受到消息后不返回ack，无论本地是否处理完消息都会在队列中消失
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming() #开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理
#消费者
2.一个生产者，多个消费者模型（一对多）
①默认生产者轮询发布消息给各个消费者,跟负载均衡差不多（消息公平分发）
#生产者 #!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) #连接到rabbitmq服务器，因为是在本地测试，所以就用localhost就可以了
channel = connection.channel() #声明一个管道(管道内发消息)
channel.queue_declare(queue='solo') #声明消息队列，消息将在这个队列中进行传递。如果将消息发送到不存在的队列，rabbitmq将会自动清除这些消息。 channel.basic_publish(exchange='', #exchange表示交换器，能精确指定消息应该发送到哪个队列
routing_key='solo', #routing_key 就是queue队列的名称
body='Hello World!' #发送内容
)
print("Sent 'Hello,World!'")
connection.close() #关闭
#生产者
#消费者1
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='solo')#如果知道queue='solo'已经存在且运行可以省略，但有可能你不知道 def callback(ch,method,properties,body):
print(ch,method,properties)
#ch:<pika.adapters.blocking_connection.BlockingChannel object at 0x002E6C90> #管道内存对象地址
#methon:<Basic.Deliver(['consumer_tag=ctag1.03d155a851b146f19cee393ff1a7ae38', #具体信息
# 'delivery_tag=1', 'exchange=', 'redelivered=False', 'routing_key=solo'])>
#properties:<BasicProperties>
print("Received %r"%body) channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息
queue="solo",
no_ack=True) #接受到消息后不返回ack，无论本地是否处理完消息都会在队列中消失
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming() #开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理
#消费者1
#消费者2
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='solo') #如果知道queue='solo'已经存在且运行可以省略，但有可能你不知道 def callback(ch,method,properties,body):
print(ch,method,properties)
#ch:<pika.adapters.blocking_connection.BlockingChannel object at 0x002E6C90> #管道内存对象地址
#methon:<Basic.Deliver(['consumer_tag=ctag1.03d155a851b146f19cee393ff1a7ae38', #具体信息
# 'delivery_tag=1', 'exchange=', 'redelivered=False', 'routing_key=solo'])>
#properties:<BasicProperties>
print("Received %r"%body) channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息
queue="solo",
no_ack=True) #接受到消息后不返回ack，无论本地是否处理完消息都会在队列中消失
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming() #开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理
#消费者2
②如果Rabbit只管按顺序把消息发到各个消费者身上，不考虑消费者负载的话，很可能出现，一个机器配置不高的消费者那里堆积了很多消息处理不完，同时配置高的消费者却一直很轻松。
解决方案：可以在各个消费者端，配置perfetch=1,意思就是告诉RabbitMQ在我这个消费者当前消息还没处理完的时候就不要再给我发新消息了
#channel.basic_qos(prefetch_count=1)
③消费者接收到消息后没有处理完突然宕机，消息就从队列上消失了，rabbitMQ把消息删除掉了
解决方案：消费者里的no_ack=True去掉之后并在callback函数里面添加ch.basic_ack(delivery_tag = method.delivery_tag，就可以实现消息不被处理完不能在队列里清除。
④如果消息在传输过程中rabbitMQ服务器宕机了，会发现之前的消息队列就不存在了
解决方案：消息持久化，消息持久化会让队列不随着服务器宕机而消失，会永久的保存下去
#channel.queue_declare(queue='solo',durable=True) //队列持久化 #channel.basic_publish(
# properties=pika.BasicProperties(
# delivery_mode = 2 //消息持久化
# )
⑤公平分发+消息持久化
#生产者 #!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) #连接到rabbitmq服务器，因为是在本地测试，所以就用localhost就可以了
channel = connection.channel() #声明一个管道(管道内发消息)
channel.queue_declare(queue='solo',durable=True) #声明消息队列，消息将在这个队列中进行传递。如果将消息发送到不存在的队列，rabbitmq将会自动清除这些消息。//增加队列持久化 channel.basic_publish(exchange='', #exchange表示交换器，能精确指定消息应该发送到哪个队列
routing_key='solo', #routing_key 就是queue队列的名称
body='Hello World!' #发送内容
properties=pika.BasicProperties(
delivery_mode = 2 #消息持久化
)
)
print("Sent 'Hello,World!'")
connection.close() #关闭
#消费者1
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='solo')#如果知道queue='solo'已经存在且运行可以省略，但有可能你不知道 def callback(ch,method,properties,body):
print(ch,method,properties)
#ch:<pika.adapters.blocking_connection.BlockingChannel object at 0x002E6C90> #管道内存对象地址
#methon:<Basic.Deliver(['consumer_tag=ctag1.03d155a851b146f19cee393ff1a7ae38', #具体信息
# 'delivery_tag=1', 'exchange=', 'redelivered=False', 'routing_key=solo'])>
#properties:<BasicProperties>
print("Received %r"%body)
ch.basic_ack(delivery_tag=method.delivery_tag) #④解决宕机消息未发送完 channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息
queue="solo",
) #接受到消息后不返回ack，无论本地是否处理完消息都会在队列中消失
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming() #开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理
#消费者2
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='solo')#如果知道queue='solo'已经存在且运行可以省略，但有可能你不知道 def callback(ch,method,properties,body):
print(ch,method,properties)
#ch:<pika.adapters.blocking_connection.BlockingChannel object at 0x002E6C90> #管道内存对象地址
#methon:<Basic.Deliver(['consumer_tag=ctag1.03d155a851b146f19cee393ff1a7ae38', #具体信息
# 'delivery_tag=1', 'exchange=', 'redelivered=False', 'routing_key=solo'])>
#properties:<BasicProperties>
print("Received %r"%body)
ch.basic_ack(delivery_tag=method.delivery_tag) #④解决宕机消息未发送完 channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息
queue="solo",
) #接受到消息后不返回ack，无论本地是否处理完消息都会在队列中消失
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming() #开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理
3、Publish/Subscribe(消息发布/订阅)
接收者绑定一个频道就能接收这个频道的所有消息，但无过滤相关操作。使用RabbitMQ就能达到过滤等操作，更细致的接收消息
之前的例子都基本都是1对1的消息发送和接收，即消息只能发送到指定的queue里，但有些时候你想让你的消息被所有的Queue收到，类似广播的效果，这时候就要用到exchange了，
Exchange在定义的时候是有类型的，以决定到底是哪些Queue符合条件，可以接收消息
①fanout: 所有bind到此exchange的queue都可以接收消息
②direct: 通过routingKey和exchange决定的那个唯一的queue可以接收消息
③topic:所有符合routingKey(此时可以是一个表达式)的routingKey所bind的queue可以接收消息
④headers: 通过headers 来决定把消息发给哪些queue
表达式符号说明：#代表一个或多个字符，*代表任何字符
例：#.a会匹配a.a，aa.a，aaa.a等
*.a会匹配a.a，b.a，c.a等
注：使用RoutingKey为#，Exchange Type为topic的时候相当于使用fanout
① fanout接收所有广播：广播表示当前消息是实时的，如果没有一个消费者在接受消息，消息就会丢弃，在这里消费者的no_ack已经无用，因为fanout不会管你处理消息结束没有，发过的消息不会重发，记住广播是实时的。
#消息发布者
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika
import sys connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel() channel.exchange_declare(exchange='logs',
type='fanout') #fanout类型的转发器 message = "info: Hello World!"
channel.basic_publish(exchange='logs',
routing_key='', #广播不用声明queue
body=message)
print(" [x] Sent %r" % message)
connection.close()
#消息发布者
#消息订阅者
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs',
type='fanout') #fanout类型的转发器
result = channel.queue_declare(exclusive=True) # 不指定queue名字,rabbit会随机分配一个名字,
# exclusive=True会在使用此queue的消费者断开后,自动将queue删除
queue_name = result.method.queue
channel.queue_bind(exchange='logs', # 绑定转发器，接收转发器上面的数据
queue=queue_name) 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()
#消息订阅者
② 有选择的接收消息 direct: 同fanout一样，no_ack在此要设置为True，不然队列里数据不会清空（虽然也不会重发）
RabbitMQ还支持根据关键字发送，即：队列绑定关键字，发送者将数据根据关键字发送到消息exchange，exchange根据 关键字 判定应该将数据发送至指定队列
注：此方式接收所有的error、info、warning
#消息发布者
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika
import sys connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel() channel.exchange_declare(exchange='direct_logs',
type='direct') #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)
print(" [x] Sent %r:%r" % (severity, message))
connection.close()
#消息发布者
#消息订阅者
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika
import sys connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel() 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: #循环severity列表
channel.queue_bind(exchange='direct_logs', #绑定（传入几个绑定几个）
queue=queue_name,
routing_key=severity) print(' [*] Waiting for logs. To exit press CTRL+C') def callback(ch, method, properties, body):
print(" [x] %r:%r" % (method.routing_key, body)) channel.basic_consume(callback,
queue=queue_name,
no_ack=True) channel.start_consuming()
#消息订阅者
③ 更细致的消息过滤 topic（动态匹配）
所有符合routingKey(此时可以是一个表达式)的routingKey所bind的queue可以接收消息
表达式符号说明：#代表一个或多个字符，*代表任何字符
例：#.a会匹配a.a，aa.a，aaa.a等
*.a会匹配a.a，b.a，c.a等
注：使用RoutingKey为#，Exchange Type为topic的时候相当于使用fanout
注：此方式接收为分类别接收：MySQL的所有error、info、warning；阿帕奇的所有error、info、warning。。。
#消息发布者
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika
import sys connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel() 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:%r" % (routing_key, message))
connection.close()
#消息发布者
#消息订阅者
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika
import sys connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel() 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:%r" % (method.routing_key, body)) channel.basic_consume(callback,
queue=queue_name,
no_ack=True) channel.start_consuming()
#消息订阅者
4、RPC（双向通信）
注：也是实时的
（一）接收端将接收到的消息处理后再返回给发送端（发送端在发送信息前，产生一个接收消息的临时队列，并且在发送请求的时候将该队列赋值给reply_to，该队列用来接收返回的结果。）；
（二）发送的消息和返回的结果一一对应起来（correlation id）
①使用python的uuid来产生唯一的correlation_id。
②发送计算请求时，设定参数correlation_id。
③定义一个字典来保存返回的数据，并且键值为相应线程产生的correlation_id。
#########rpc client#######
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
import pika
import uuid,time class FibonacciRpcClient(object):
def __init__(self):
self.connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost')) self.channel = self.connection.channel() result = self.channel.queue_declare(exclusive=True) #生成一个随机的callback_queue
self.callback_queue = result.method.queue self.channel.basic_consume(self.on_response, #只要收到消息就执行on_response回调函数
no_ack=True, #不用ack确认
queue=self.callback_queue) def on_response(self, ch, method, props, body):
if self.corr_id == props.correlation_id: #验证码核对，确保发送和返回的消息一一对应
self.response = body def call(self, n):
self.response = None
self.corr_id = str(uuid.uuid4())
print(self.corr_id)
self.channel.basic_publish(exchange='',
routing_key='rpc_queue',
properties=pika.BasicProperties(
reply_to=self.callback_queue, #发送返回信息的队列name//携带新的信息reply_to，不影响发送的消息本身
correlation_id=self.corr_id, #发送uuid 相当于验证码
),
body=str(n))
while self.response is None:
self.connection.process_data_events() #非阻塞版的start_consuming//有消息接收消息，没有消息继续往下走
print("no messages")
time.sleep(0.5) #测试//可以允许客户再次发送数据，多条数据可能不按顺序完成，返回消息的结果可能不一一对应
return int(self.response) fibonacci_rpc = FibonacciRpcClient() #实例化
print(" [x] Requesting fib(30)")
response = fibonacci_rpc.call(30) #执行call方法
print(" [.] Got %r" % response)
########rpc server########## #!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-soloLi
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= #客户端发来的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, #收到消息触发on_request回调函数
queue='rpc_queue') print(" [x] Awaiting RPC requests")
channel.start_consuming()
Python学习笔记整理总结【RabbitMQ队列】的更多相关文章
- python学习笔记整理——字典
python学习笔记整理 数据结构--字典 无序的 {键:值} 对集合 用于查询的方法 len(d) Return the number of items in the dictionary d. 返 ...
- python学习笔记整理——集合 set
python学习整理笔记--集合 set 集合的用途:成员测试和消除重复的条目,进行集合运算 注意:花括号或set()函数可以用于创建集合. 注意:若要创建一个空的集合你必须使用set(),不能用{} ...
- python学习笔记整理——元组tuple
Python 文档学习笔记2 数据结构--元组和序列 元组 元组在输出时总是有括号的 元组输入时可能没有括号 元组是不可变的 通过分拆(参阅本节后面的内容)或索引访问(如果是namedtuples,甚 ...
- python学习笔记整理——列表
Python 文档学习笔记 数据结构--列表 列表的方法 添加 list.append(x) 添加元素 添加一个元素到列表的末尾:相当于a[len(a):] = [x] list.extend(L) ...
- python 学习笔记整理
首先自我批评一下,说好的一天写一篇博客,结果不到两天,就没有坚持了,发现自己做什么事情都没有毅力啊!不能持之以恒.但是,这次一定要从写博客开始来改掉自己的一个坏习惯. 可是写博客又该写点什么呢? 反正 ...
- Python学习笔记整理总结【语言基础篇】
一.变量赋值及命名规则① 声明一个变量及赋值 #!/usr/bin/env python # -*- coding:utf-8 -*- # _author_soloLi name1="sol ...
- python学习笔记六——堆栈和队列
4.2.3 列表的查找.排序.反转 list列表可以进行添加.删除操作,此外List列表还提供了查找元素的方法.list列表的查找提供了两种方式,一种是使用index方法返回元素在列表中的位置,另一种 ...
- python学习笔记——multiprocessing 多进程组件-队列Queue
1 消息队列 1.1 基本语法 消息队列:multiprocessing.Queue,Queue是对进程安全的队列,可以使用Queue实现对进程之间的数据传输:还有一个重要作用是作为缓存使用. Que ...
- Python学习笔记整理总结【Django】【MVC/MTV/路由分配系统（URL）/视图函数 （views）/表单交互】
一.Web框架概述 Web框架本质上其实就是一个socket服务端,用户的浏览器其实就是一个socket客户端. #!/usr/bin/env python # -*- coding:utf-8 ...
随机推荐
- 使用getCurrentPosition方法实时获取当前Geolocation信息（赋源码文件）--html5、JavaScript
使用getCurrentPosition方法实时获取当前Geolocation信息: 1.typeof 运算符返回一个用来表示表达式的数据类型的字符串 <script> alert(typ ...
- 关于NOIP2014“无线网络发射器选址”一题的衍生题目的思考及思维方向
无线网络发射器选址 题目描述 随着智能手机的日益普及,人们对无线网的需求日益增大.某城市决定对城市内的公共场所覆盖无线网. 假设该城市的布局为由严格平行的129 条东西向街道和129 条南北向街道所形 ...
- [oracle 使用(1)] win7/10 下Oracle10g的安装与卸载
1.安装前提 首先要确保你的电脑之前没有安装过,或者安装过但是已经卸载干净了.至于如何查看是否卸载干净可以看看我后面的Oracle卸载步骤. 2.Oracle的安装. 2.1.首先自己在Oracle官 ...
- Linux.根据进程名关键字杀进程
先看例子, 假设系统中有以下2个进程 USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root ...
- mysql 中翻页
万变不离其中 select * from tableName where 条件 limit 当前页码*页面容量-1 , 页面容量
- MySQL常用存储引擎
MySQL存储引擎主要有两大类: 1. 事务安全表:InnoDB.BDB. 2. 非事务安全表:MyISAM.MEMORY.MERGE.EXAMPLE.NDB Cluster.ARCHIVE.CSV. ...
- 紧跟腾讯大王卡：B站2233卡“基友号”即将上线
来自B站官方的消息显示,B站在近期也将推出"基友号"功能,功能的内容是通话免费,考虑到这类互联网套餐都是中国联通在运营,因此在内容上可能也会效仿腾讯大王卡实现免费通话. 目前,B站 ...
- linux makefile 编译多个.c文件 实例
本例由 main.c add.c sub.c add_sub.h 四个文件组成:编写Makefile执行程序 /******************************************* ...
- FATE
FATE Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submissi ...
- 利用echarts highcharts 实现自定义地图 关系图效果 侧边3D柱形图饼图散点图
github 地址: https://https://github.com/Gengshaoxuan/medataMap github 地址: https://https://github.com ...