RabbitMQ是一个在AMQP基础上完整的，可复用的企业消息系统。他遵循Mozilla Public License开源协议。

MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消 息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。

RabbitMQ安装

1.linux
安装配置epel源

$ rpm -ivh http://dl.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm

安装erlang

$ yum -y install erlang

安装RabbitMQ

$ yum -y install rabbitmq-server

service rabbitmq-server start/stop
2.安装python API
pip install pika

or

easy_install pika

先来一个基于Queue实现生产者消费者模型试试水

#!/usr/bin/env python3

#coding:utf8

import queue

import threading

message = queue.Queue(10)

def producer(i):

	'''厨师,生产包子放入队列'''

	while True:

	    message.put(i)

def consumer(i):

	'''消费者,从队列中取包子吃'''

	while True:

	    msg = message.get()

for i in range(12): 厨师的线程包子

	t = threading.Thread(target=producer, args=(i,))

	t.start()

for i in range(10): 消费者的线程吃包子

	t = threading.Thread(target=consumer, args=(i,))

	t.start()

开始rabbitMQ

对于RabbitMQ来说，生产和消费不再针对内存里的一个Queue对象，而是某台服务器上的RabbitMQ Server实现的消息队列。

一、最基本的生产者消费者

1.生产者代码

#!/usr/bin/env python

import pika

# ######################### 生产者 #########################

#链接rabbit服务器（localhost是本机，如果是其他服务器请修改为ip地址）

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))

#创建频道

channel = connection.channel()

#创建一个队列名叫hello

channel.queue_declare(queue='hello')

#exchange -- 它使我们能够确切地指定消息应该到哪个队列去。

#向队列插入数值 routing_key是队列名 body是要插入的内容

channel.basic_publish(exchange='',

                  routing_key='hello',

                  body='Hello World!')

print("开始队列")

#缓冲区已经flush而且消息已经确认发送到了RabbitMQ中，关闭链接

connection.close()

2.消费者代码

#!/usr/bin/env python

import pika

# ########################## 消费者 ##########################

#链接rabbit

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))

#创建频道

channel = connection.channel()

#如果生产者没有运行创建队列，那么消费者也许就找不到队列了。为了避免这个问题

#所有消费者也创建这个队列

channel.queue_declare(queue='hello')

#接收消息需要使用callback这个函数来接收，他会被pika库来调用

def callback(ch, method, properties, body):

	print(" [x] Received %r" % body)

#从队列取数据 callback是回调函数 如果拿到数据 那么将执行callback函数

channel.basic_consume(callback,

	                  queue='hello',

	                  no_ack=True)

print(' [*] 等待信息. To exit press CTRL+C')

#永远循环等待数据处理和callback处理的数据

channel.start_consuming()
二、acknowledgment 消息不丢失的方法

no-ack ＝ False，如果生产者遇到情况(关闭通道,连接关闭或TCP连接丢失))挂掉了，那么，RabbitMQ会重新将该任务添加到队列中。

1.生产者不变，但是还是复制上来吧

#!/usr/bin/env python

import pika

# ######################### 生产者 #########################

#链接rabbit服务器

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))

#创建频道

channel = connection.channel()

#创建一个队列名叫hello

channel.queue_declare(queue='hello')

#向队列插入数值 routing_key是队列名 body是要插入的内容

channel.basic_publish(exchange='',

                  routing_key='hello',

                  body='Hello World!')

print("开始队列")

connection.close()

2.消费者

import pika

#链接rabbit

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))

#创建频道

channel = connection.channel()

#如果生产者没有运行创建队列，那么消费者创建队列

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):

	print(" [x] Received %r" % body)

	import time

	time.sleep(10)

	print 'ok'

	ch.basic_ack(delivery_tag = method.delivery_tag) #主要使用此代码

channel.basic_consume(callback,

	                  queue='hello',

	                  no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')

channel.start_consuming()

当生产者生成一条数据，被消费者接收，消费者中断后如果不超过10秒，连接的时候数据还在。当超过10秒之后，重新链接，数据将消失。消费者等待链接。

三、durable 消息不丢失 （消息持久化）

这个 queue_declare 需要在 生产者（producer） 和消费方（consumer) 代码中都进行设置。

1.生产者

#!/usr/bin/env python

import pika

#链接rabbit服务器

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))

#创建频道

channel = connection.channel()

#创建队列，使用durable方法

channel.queue_declare(queue='hello', durable=True)

					#如果想让队列实现持久化那么加上durable=True

channel.basic_publish(exchange='',

                  routing_key='hello',

                  body='Hello World!',

                  properties=pika.BasicProperties(

                      delivery_mode=2,

				  #标记我们的消息为持久化的 - 通过设置 delivery_mode 属性为 2

				  #这样必须设置，让消息实现持久化

                  ))

#这个exchange参数就是这个exchange的名字. 空字符串标识默认的或者匿名的exchange：如果存在routing_key, 消息路由到routing_key指定的队列中。

print(" [x] 开始队列'")

connection.close()

2.消费者

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))

#创建频道

channel = connection.channel()

#创建队列，使用durable方法

channel.queue_declare(queue='hello', durable=True)

def callback(ch, method, properties, body):

    print(" [x] Received %r" % body)

    import time

    time.sleep(10)

    print 'ok'

    ch.basic_ack(delivery_tag = method.delivery_tag)

	channel.basic_consume(callback,

                  	queue='hello',

                  	no_ack=False)

	print(' [*] 等待队列. To exit press CTRL+C')

	channel.start_consuming()

注：标记消息为持久化的并不能完全保证消息不会丢失，尽管告诉RabbitMQ保存消息到磁盘，当RabbitMQ接收到消息还没有保存的时候仍然有一个短暂的时间窗口. RabbitMQ不会对每个消息都执行同步fsync(2) --- 可能只是保存到缓存cache还没有写入到磁盘中，这个持久化保证不是很强，但这比我们简单的任务queue要好很多，如果你想很强的保证你可以使用 publisher confirms

四、消息获取顺序

默认消息队列里的数据是按照顺序被消费者拿走，例如：消费者1 去队列中获取 奇数 序列的任务，消费者1去队列中获取 偶数 序列的任务。

channel.basic_qos(prefetch_count=1) 表示谁来谁取，不再按照奇偶数排列

1.生产者

import pika

import sys  

connection = pika.BlockingConnection(pika.ConnectionParameters(

    host='localhost'))

channel = connection.channel()

# 设置队列为持久化的队列

channel.queue_declare(queue='task_queue', durable=True)

message = ' '.join(sys.argv[1:]) or "Hello World!"

channel.basic_publish(exchange='',

                  routing_key='task_queue',

                  body=message,

                  properties=pika.BasicProperties(

                     delivery_mode = 2, # 设置消息为持久化的

                  ))

print(" [x] Sent %r" % message)

connection.close()

2.消费者

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))

channel = connection.channel()

channel.queue_declare(queue='hello'durable=True)  # 设置队列持久化 

def callback(ch, method, properties, body):

	print(" [x] Received %r" % body)

	import time

	time.sleep(10)

	print 'ok'

	ch.basic_ack(delivery_tag = method.delivery_tag)

#表示谁来谁取，不再按照奇偶数排列

channel.basic_qos(prefetch_count=1)# 消息未处理完前不要发送信息的消息  

channel.basic_consume(callback,

                  queue='hello',

                  no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')

channel.start_consuming()

交换 (Exchanges)

exchange类型可用： direct , topic , headers 和 fanout 。 我们将要对最后一种进行讲解 --- fanout

一、消息发布订阅

发布订阅和简单的消息队列区别在于，发布订阅会将消息发送给所有的订阅者，而消息队列中的数据被消费一次便消失。所以，RabbitMQ实现发布和订阅时，会为每一个订阅者创建一个队列，而发布者发布消息时，会将消息放置在所有相关队列中。

exchange type = fanout

1.发布者

#!/usr/bin/env python

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

    host='localhost'))

channel = connection.channel()

channel.exchange_declare(exchange='logs',

                     type='fanout')

message = ' '.join(sys.argv[1:]) or "info: Hello World!"

channel.basic_publish(exchange='logs',

                  routing_key='',

                  body=message)

print(" [x] Sent %r" % message)

connection.close()

2.订阅者

#!/usr/bin/env python

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(

    host='localhost'))

channel = connection.channel()

channel.exchange_declare(exchange='logs',

                     type='fanout')

result = channel.queue_declare(exclusive=True) #队列断开后自动删除临时队列

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()

六、关键字发送

exchange type = direct

之前事例，发送消息时明确指定某个队列并向其中发送消息，RabbitMQ还支持根据关键字发送，即：队列绑定关键字，发送者将数据根据关键字发送到消息exchange，exchange根据 关键字 判定应该将数据发送至指定队列。

1.生产者：

#!/usr/bin/env python3

#coding:utf8

#######################生产者#################

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

	    host='localhost'))

channel = connection.channel()

channel.exchange_declare(exchange='direct_logs',

                     type='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()

2.消费者：

#!/usr/bin/env python3

#coding:utf8

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:

	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()
七、模糊匹配

exchange type = topic

在topic类型下，可以让队列绑定几个模糊的关键字，之后发送者将数据发送到exchange，exchange将传入”路由值“和 ”关键字“进行匹配，匹配成功，则将数据发送到指定队列。

# 表示可以匹配 0 个 或 多个 单词

  • 表示只能匹配 一个 单词

    发送者路由值 队列中

    old.boy.python old.* -- 不匹配

    old.boy.python old.# -- 匹配

1.消费者

#!/usr/bin/env python3

#coding:utf8

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()

2.生产者

#!/usr/bin/env python3

#coding:utf8

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()

更多内容：以下参考：

http://blog.csdn.net/songfreeman/article/details/50945025

work queue （用来在多个workers之间分发消息）

1.循环调度(Round-robin dispatching)

使用多个消费者来接收并处理消息

默认，RabbitMQ将循环的发送每个消息到下一个Consumer , 平均每个Consumer都会收到同样数量的消息。 这种分发消息的方式成为 循环调度（round-robin)

  • 生产者：

      #!/usr/bin/env python3
    
  #coding:utf8
    
  import pika
    
  import sys
    
  #链接
    
  connec = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
    
  channel = connec.channel()
    
  #创建队列
    
  channel.queue_declare(queue='worker')
    
  #插入数据
    
  message = ' '.join(sys.argv[1:]) or "Hello World"
    
  channel.basic_publish(exchange='',
    
  		              routing_key='worker',
    
  		              body=message,
    
  		              properties=pika.BasicProperties(delivery_mode = 2,)
    
  		              )
    
  print(" [x] Send %r " % message)

  • 消费者：

      #!/usr/bin/env python3
    
  #coding:utf8
    
  import time
    
  import pika

  connect = pika.BlockingConnection(pika.ConnectionParameters	(host='localhost'))
    
  channel = connect.channel()

  channel.queue_declare('worker')

  def callback(ch, method, properties,body):
    
  	print(" [x] Received %r" % body)
    
  	time.sleep(body.count(b'.'))
    
  	print(" [x] Done")
    
  ch.basic_ack(delivery_tag = method.delivery_tag)

  channel.basic_consume(callback,
    
                    queue='worker',
    
                    )
    
  channel.start_consuming()

执行的时候两个消费者等待接收消息，

第一次生产者产生消息的时候被消费者1接收

第二次生产者产生消息的时候被消费者2接收

19.python笔记之Rabbitmq的更多相关文章

  1. python笔记-11 rabbitmq

    一.理解rabbitmq的基本背景 1.理解消息队列 1.1 普通queue 在前面的博客中所提到的队列,此处均称之为普通队列 简述一下普通队列的一些分类及不足 1.1.1 基本Queue:queue ...

  2. 《Python编程：从入门到实践》第19章笔记：用户/用户注册/身份验证

    接上篇django最基本的一些日常用法,这是第19章笔记,希望在做"动手试一试"的时候可以让自己方便参考. 这一章实现了两个功能: 1.让用户能够添加主题Topic和条目Entry ...

  3. python笔记 - day6

    python笔记 - day6 参考: http://www.cnblogs.com/wupeiqi/articles/5501365.html 大纲: 利用递归,实现阶乘: Python反射 pyt ...

  4. python笔记 - day5

    python笔记 - day5 参考: http://www.cnblogs.com/wupeiqi/articles/5484747.html http://www.cnblogs.com/alex ...

  5. s21day21 python笔记

    s21day21 python笔记 一.内容回顾及补充 内置函数补充 type():查看数据类型 class Foo: pass obj = Foo() if type(obj) == Foo: pr ...

  6. s21day19 python笔记

    s21day19 python笔记 一.面向对象的基本知识 1.1 基本格式 # 定义类 class 类名: def 方法名(self,name): print(name) return 123 de ...

  7. s21day05 python笔记

    s21day05 python笔记 一.昨日内容回顾及补充 回顾 补充 列表独有功能 extend:循环添加到一个列表中 1.users = ['张三',66],people = ['王五',99] ...

  8. python笔记-1（import导入、time/datetime/random/os/sys模块）

    python笔记-6(import导入.time/datetime/random/os/sys模块)   一.了解模块导入的基本知识 此部分此处不展开细说import导入,仅写几个点目前的认知即可.其 ...

  9. python 笔记2016

    列表,元组(不可添加和修改),字典 3种集合模式 模块----类---函数 要把文件变成双击运行,要把文件的属性选择python安装目录下的python.exe 1,查看数据类型 print(type ...

随机推荐

  1. BZOJ-2257 瓶子和燃料 分解因数+数论方面乱搞（裴蜀定理）

    一开始真没想出解法...后来发现那么水.... 2257: [Jsoi2009]瓶子和燃料 Time Limit: 10 Sec Memory Limit: 128 MB Submit: 970 So ...

  2. android 自定义控件 使用declare-styleable进行配置属性（源码角度）

          android自定义styleableattrs源码 最近在模仿今日头条,发现它的很多属性都是通过自定义控件并设定相关的配置属性进行配置,于是便查询了解了下declare-styleabl ...

  3. MyEclipse------各种问题解决方法

    1.汉化后如何变为英文版:找到myeclipse.ini文件,改为:language=enlanguage=zh为中文 2.解决版本不匹配问题:http://blog.sina.com.cn/s/bl ...

  4. Protocol Buffer技术详解(Java实例)

    Protocol Buffer技术详解(Java实例) 该篇Blog和上一篇(C++实例)基本相同,只是面向于我们团队中的Java工程师,毕竟我们项目的前端部分是基于Android开发的,而且我们研发 ...

  5. --Dirring love 音乐(01背包问题)

    解题思路: dp[i][j] 前 i 首歌放入 j 容量中的最大热情度. 前 i 首歌 放到 j 容量中 dp[i][j]= dp[i-1][j-m[i]]+r[i]   (注意:如果 j 容量 &l ...

  6. CNN 美国有线电视新闻网 wapCNN WAP 指无线应用通讯协议 ---- 美国有线电视新闻网 的无线应用

    wapCNN  wap指无线应用通讯协议  CNN美国有线电视新闻网   固, wapCNN 美国有线电视新闻网的无线应用 -------------------------------------- ...

  7. PHP 500 -Invalid command RewriteEngine的解决

    转自:http://blog.csdn.net/wang02011/article/details/8205903 环境:   wampserver-2.1a 系统 :  win8 错误 :  500 ...

  8. 高效使用git的一些命令

    1,添加文件到版本库        添加单个文件: git add filename        添加所有txt文件: git add *.txt        添加所有修改文件: git add ...

  9. Jquery Validate 正则表达式实用验证代码

    jQuery.validate 的正则验证功能,包括手机号码.电话号码.邮政编码.QQ号码.IP地址.字母和数字.中文的验证等. 手机号码验证 以下为引用内容:  jQuery.validator.a ...

  10. UIView 设置背景图片

    http://blog.csdn.net/qijianli/article/details/7777268 项目中,可能需要我们为某个视图设置背景图片,而API中UIView没有设置背景图片的方法,那 ...