python操作RabbiMQ
RabbitMQ是一个在AMQP基础上完整的,可复用的企业消息系统。他遵循Mozilla Public License开源协议。
MQ全称为Message Queue, 消息队列(MQ)是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息(针对应用程序的数据)来通信,而无需专用连接来链接它们。消 息传递指的是程序之间通过在消息中发送数据进行通信,而不是通过直接调用彼此来通信,直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。
#!/usr/bin/env python
# _*_coding:utf-8 _*_ import Queue
import threading message = Queue.Queue(10) def producter(i): while True:
message.put(i) def consumer(i):
while True:
message.get() for i in range(5):
w = threading.Thread(target=producter,args=(i,))
w.start() for i in range(2):
w = threading.Thread(target=consumer,args=(i,))
w.start()
生产者消费者模型
对于RabbitMQ来说,生产和消费不再针对内存里的一个Queue对象,而是某台服务器上的RabbitMQ Server实现的消息队列。
#!/usr/bin/env python
# _*_coding:utf-8 _*_ import pika connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.1.108')) #连接一台rabbitMQ channel = connection.channel() #创建一个频道 channel.queue_declare("chenchao") #声明一个消息队列 channel.basic_publish(exchange='',routing_key="chenchao",body="Fucking!") #发送消息 print "sent Fucking world!!!!" connection.close() #关闭连接
生产者
#!/usr/bin/env python
# _*_coding:utf-8 _*_ # #############################消费者######################## import pika connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.1.108')) channel = connection.channel() channel.queue_declare("chenchao") def callback(ch, method, properties, body): #固定格式 必须有4个参数
print body channel.basic_consume(callback,queue="chenchao",no_ack=True) #将从队列里取出的数据回调给callback方法 channel.start_consuming() #开始取值
消费者
1、acknowledgment 消息不丢失
no-ack = False,如果在传递消息的过程中消费者遇到情况(its channel is closed, connection is closed, or TCP connection is lost)挂掉了,那么,RabbitMQ会重新将该任务消息添加到队列中。
#!/usr/bin/env python
# _*_coding:utf-8 _*_ # #############################消费者######################## import pika connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.1.108')) channel = connection.channel() channel.queue_declare("chenchao") def callback(ch, method, properties, body): #固定格式 必须有4个参数
print body
import time
time.sleep(8)
print "sleep over"
ch.basic_ack(delivery_tag = method.delivery_tag ) #向生产者发送应答 channel.basic_consume(callback,queue="chenchao",no_ack=False) #将从队列里取出的数据回调给callback方法 channel.start_consuming() #开始取值
消费者
ch.basic_ack(delivery_tag = method.delivery_tag ) #向生产者发送应答,表示已经接收到了数据
no_ack=False
2、durable 消息不丢失
如果之前的队列为非持久化的,那么之后就不能将其修改为持久化的,必须重新创建一个新的队列,并声明为持久化的队列,并且在发送消息时也要注明是持久化消息才行。
#!/usr/bin/env python
# _*_coding:utf-8 _*_ # #######################生产者###################### import pika connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.1.108')) #连接一台rabbitMQ channel = connection.channel() #创建一个频道 channel.queue_declare("chenchao2",durable=True) #声明一个消息队列为持久化的队列 channel.basic_publish(exchange='',
routing_key="chenchao2",
body="Message NO.1",
properties=pika.BasicProperties(delivery_mode=2,)) #发送消息为持久化的数据 print "sent Message OK!" connection.close() #关闭连接
生产者
durable=True
properties=pika.BasicProperties(delivery_mode=2,)
#!/usr/bin/env python
# _*_coding:utf-8 _*_ # #############################消费者######################## import pika connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.1.108')) channel = connection.channel() channel.queue_declare("chenchao2",durable=True) #生命一个可持续化的队列(如果队列已经存在,这句可有可无) def callback(ch, method, properties, body): #固定格式 必须有4个参数
print body
import time
time.sleep(8)
print "sleep over"
ch.basic_ack(delivery_tag = method.delivery_tag ) #向生产者发送应答 channel.basic_consume(callback,queue="chenchao2",no_ack=False) #将从队列里取出的数据回调给callback方法 channel.start_consuming() #开始取值
消费者
3、消息获取顺序
默认消息队列里的数据是按照顺序被消费者拿走,例如:消费者1 去队列中获取 奇数 序列的任务,消费者1去队列中获取 偶数 序列的任务。
channel.basic_qos(prefetch_count=1) 表示谁来谁取,不再按照奇偶数排列
#!/usr/bin/env python
# _*_coding:utf-8 _*_ # #############################消费者######################## import pika connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.1.108')) channel = connection.channel() channel.queue_declare("chenchao2",durable=True) #生命一个可持续化的队列(如果队列已经存在,这句可有可无) def callback(ch, method, properties, body): #固定格式 必须有4个参数
print body
import time
time.sleep(8)
print "sleep over"
ch.basic_ack(delivery_tag = method.delivery_tag ) #向生产者发送应答 channel.basic_qos(prefetch_count=1) #获取消息不在按奇偶规则获取 channel.basic_consume(callback,queue="chenchao2",no_ack=False) #将从队列里取出的数据回调给callback方法 channel.start_consuming() #开始取值
消费者
4、发布订阅
发布订阅和简单的消息队列区别在于,发布订阅会将消息发送给所有的订阅者,而消息队列中的数据被消费一次便消失。所以,RabbitMQ实现发布和订阅时,会为每一个订阅者创建一个队列,而发布者发布消息时,会将消息放置在所有相关队列中。
#!/usr/bin/env python
# _*_coding:utf-8 _*_ import pika
import sys connection = pika.BlockingConnection(pika.ConnectionParameters(
host='192.168.1.108'))
channel = connection.channel() channel.exchange_declare(exchange='chenchao',
type='fanout') #声明一个名称为chenchao的exchange 类型为fanout message = ' '.join(sys.argv[1:]) or "info: Hello every consumer2"
channel.basic_publish(exchange='chenchao',
routing_key='',
body=message) #将消息发送到exchange里,通过exchange发送到所有队列
print(" [x] Sent %r" % message)
connection.close()
发布者
channel.exchange_declare(exchange='chenchao',
type='fanout') #声明一个名称为chenchao的exchange 类型为fanout
#!/usr/bin/env python
# _*_coding:utf-8 _*_ import pika connection = pika.BlockingConnection(pika.ConnectionParameters(
host='192.168.1.108'))
channel = connection.channel() channel.exchange_declare(exchange='chenchao',
type='fanout') #声明类型为fanou名称为chenchao的exchange result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue #生成一个随机名的队列 channel.queue_bind(exchange='chenchao',
queue=queue_name) #将队列与exchange绑定 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()
订阅者
channel.queue_bind(exchange='chenchao',
queue=queue_name) #将队列与exchange绑定
5、关键字发送
exchange type = direct
之前事例,发送消息时明确指定某个队列并向其中发送消息,RabbitMQ还支持根据关键字发送,即:队列绑定关键字,发送者将数据根据关键字发送到消息exchange,exchange根据 关键字 判定应该将数据发送至指定队列。
#!/usr/bin/env python
# _*_coding:utf-8 _*_ import pika
import sys connection = pika.BlockingConnection(pika.ConnectionParameters(
host='192.168.1.108'))
channel = connection.channel() channel.exchange_declare(exchange='import',
type='direct') #声明一个名称为import的exchange 类型为direct message = ' '.join(sys.argv[1:]) or "info: Hello are you Q1???"
channel.basic_publish(exchange='import',
routing_key='Nice',
body=message) #将消息与关键字发送到exchange里,通过关键字发送到绑定的队列
print(" [x] Sent %r" % message)
connection.close()
生产者
type='direct'
routing_key='Nice'
#!/usr/bin/env python
# _*_coding:utf-8 _*_ import pika connection = pika.BlockingConnection(pika.ConnectionParameters(
host='192.168.1.108'))
channel = connection.channel() channel.exchange_declare(exchange='import',
type='direct') #声明类型为direct名称为import的exchange result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue #生成一个随机名的队列 channel.queue_bind(exchange='import',
queue=queue_name,
routing_key="Queue1") #将队列与exchange绑定,并声明关键字 channel.queue_bind(exchange='import',
queue=queue_name,
routing_key="Nice") #将队列与exchange绑定,并声明关键字 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()
订阅者
#!/usr/bin/env python
# _*_coding:utf-8 _*_ import pika connection = pika.BlockingConnection(pika.ConnectionParameters(
host='192.168.1.108'))
channel = connection.channel() channel.exchange_declare(exchange='import',
type='direct') #声明类型为direct名称为import的exchange result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue #生成一个随机名的队列 channel.queue_bind(exchange='import',
queue=queue_name,
routing_key="Queue2") #将队列与exchange绑定,并声明关键字 channel.queue_bind(exchange='import',
queue=queue_name,
routing_key="Nice") #将队列与exchange绑定,并声明关键字 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()
订阅者2
type='direct'
routing_key="Nice"
6、模糊匹配
exchange type = topic
在topic类型下,可以让队列绑定几个模糊的关键字,之后发送者将数据发送到exchange,exchange将传入”路由值“和 ”关键字“进行匹配,匹配成功,则将数据发送到指定队列。
- # 表示可以匹配 0 个 或 多个 单词
- * 表示只能匹配 一个 单词
routing_key="Nice.*"
routing_key="Nice.#"
发送者路由值 队列中
old.boy.python old.
*
-
-
不匹配
old.boy.python old.
# -- 匹配
#!/usr/bin/env python
# _*_coding:utf-8 _*_ import pika
import sys connection = pika.BlockingConnection(pika.ConnectionParameters(
host='192.168.1.108'))
channel = connection.channel() channel.exchange_declare(exchange='topic_logs',
type='topic') #声明一个名称为import的exchange 类型为direct message = ' '.join(sys.argv[1:]) or "info: Are you choosed?"
channel.basic_publish(exchange='topic_logs',
routing_key='Nice',
body=message) #将消息与关键字发送到exchange里,通过关键字发送到绑定的队列
print(" [x] Sent %r" % message)
connection.close()
发布者
type='topic'
#!/usr/bin/env python
# _*_coding:utf-8 _*_ import pika connection = pika.BlockingConnection(pika.ConnectionParameters(
host='192.168.1.108'))
channel = connection.channel() channel.exchange_declare(exchange='topic_logs',
type='topic') #声明类型为topic的exchange result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue #生成一个随机名的队列 channel.queue_bind(exchange='topic_logs',
queue=queue_name,
routing_key="Nice.*") #将队列与exchange绑定,并声明关键字 *代表只能匹配一个 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()
订阅者1
type='topic'
routing_key="Nice.*"
#!/usr/bin/env python
# _*_coding:utf-8 _*_ import pika connection = pika.BlockingConnection(pika.ConnectionParameters(
host='192.168.1.108'))
channel = connection.channel() channel.exchange_declare(exchange='topic_logs',
type='topic') #声明类型为direct名称为import的exchange result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue #生成一个随机名的队列 channel.queue_bind(exchange='topic_logs',
queue=queue_name,
routing_key="Nice.#") #将队列与exchange绑定,并声明关键字 #代表只能匹配0个或者多个 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()
订阅者2
routing_key="Nice.#"
python操作RabbiMQ的更多相关文章
- Python之路:Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy
Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度 ...
- 【转】Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy
Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度 ...
- python操作RabbitMQ、Redis、Memcache、SQLAlchemy
Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度 ...
- Python菜鸟之路:Python基础-Python操作RabbitMQ
RabbitMQ简介 rabbitmq中文翻译的话,主要还是mq字母上:Message Queue,即消息队列的意思.rabbitmq服务类似于mysql.apache服务,只是提供的功能不一样.ra ...
- Python操作 RabbitMQ、Redis、Memcache
Python操作 RabbitMQ.Redis.Memcache Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数 ...
- Python(九) Python 操作 MySQL 之 pysql 与 SQLAchemy
本文针对 Python 操作 MySQL 主要使用的两种方式讲解: 原生模块 pymsql ORM框架 SQLAchemy 本章内容: pymsql 执行 sql 增\删\改\查 语句 pymsql ...
- Python 【第六章】:Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy
Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度 ...
- 练习:python 操作Mysql 实现登录验证 用户权限管理
python 操作Mysql 实现登录验证 用户权限管理
- Python操作MySQL
本篇对于Python操作MySQL主要使用两种方式: 原生模块 pymsql ORM框架 SQLAchemy pymsql pymsql是Python中操作MySQL的模块,其使用方法和MySQLdb ...
随机推荐
- escape character.
/* 转义字符:通过\ 来转变后面字母或者符号的含义. \n:换行. \b:退格.相当于backspace. \r:按下回车键.window系统,回车符是由两个字符来表示\r\n. \t:制表符.相当 ...
- SQL Server死锁日志各字段含义
使用跟踪标记 1204 --打开跟踪标记 DBCC TRACEON (1204,-1) --关闭跟踪标记 DBCC TRACEOFF (1204,-1) 处于死锁状态时,跟踪标记 1204 在等待的线 ...
- AFNETWORKING tabelView没有reloadData,报错unsupported URL
Error Domain=NSURLErrorDomain Code=-1002 "unsupported URL" UserInfo=0x7f9dc278aa60 {NSUnde ...
- html 5的localstorag
随着我们硬件技术的发展,浏览器本身的功能也愈发的完善,从之前的cookie到现在的本地缓存机制,再到web storage,在之前html4 的时候使用cookie具有一些明显的局限,如大小限制,co ...
- SGU 157.Patience
简单的搜索,在n>10时,要打表 code: #include<stdio.h> #include<string.h> #include<algorithm> ...
- python everything is object
python面向对象非常彻底,即使过程式的代码风格,python在运作的时候也是面向对象的.everything is object. 差异 在面向对象的理念上,python和非常工程化的面向对象语言 ...
- Invoke()/BeginInvoke()区别
查看MSDN如下: Control..::.Invoke ---> 在拥有此控件的基础窗口句柄的线程上执行委托. Control..::.BeginInvoke ---> ...
- 固定DIV样式
<!doctype html> <html> <head> <meta charset="UTF-8"> < ...
- Android 应用层知识纲要
Java基础 * 面向对象 * Java集合框架 * 异常处理 * Java反射, Spring框架,通过反射实现 * 泛型, 静态变成语言 * 文件操作 Android基础 * Activity * ...
- 分布式系统间通信之RPC的基本概念(六)
RPC(Remote Procedure Call Protocol)远程过程调用协议.一个通俗的描述是:客户端在不知道调用细节的情况下,调用存在于远程计算机上的某个对象,就像调用本地应用程序中的对象 ...