Python操作RabbitMQ

   本篇博客主要介绍如何通过Python来操作管理RabbitMQ消息队列,大家在工作中可能遇到很多类似RabbitMQ这种消息队列的中间件,如:ZeroMQ、ActiveMQ、MetaMQ等,我们学会了如何操作RabbitMQ的话基本上操作其他的队列都是一通百通。

 一、RabbitMQ安装

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

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

1,yum安装rabbitmq

1
2
3
4
5
6
7
8
9
10
11
#安装配置epel源
  rpm -ivh http://dl.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm
 
#安装Erlang
  yum -y insatll erlang
 
#安装RabbitMQ
  yum -y install rabbitmq-server
 
#注意:
   service rabbitmq-server start/stop

2,安装API

1
2
3
4
5
#pip安装:
  pip install pika
 
#源码安装:
  https://pypi.python.org/pypi/pika  #官网地址

    之前我们在介绍线程,进程的时候介绍过python中自带的队列用法,下面我们通过一段代码复习一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#生产者消费者模型,解耦的意思就是两个程序之间,互相没有关联了,互不影响。
import queue
import threading
import time
q = queue.Queue(20)      #队列里最多存放20个元素
  
def productor(arg):            #生成者,创建30个线程来请求吃包子,往队列里添加请求元素
    q.put(str(arg) + '- 包子')
  
for i in range(30):
    t = threading.Thread(target=productor,args=(i,))
    t.start()
  
def consumer(arg):       #消费者,接收到队列请求以后开始生产包子,来消费队列里的请求
    while True:
        print(arg,q.get())
        time.sleep(2)
  
for j in range(3):
    t = threading.Thread(target=consumer,args=(j,))
    t.start()

二、通过Python来操作RabbitMQ队列

     上面我们已经将环境装备好,下面我们通过Pika模块来对Rabbitmq队列来进行操作,对于RabbitMQ来说,生产和消费不再针对内存里的一个Queue对象,而是某台服务器上的RabbitMQ Server实现的消息队列。

1,基本用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
####################################生产者#####################################
 
import pika
 
connection=pika.BlockingConnection(pika.ConnectionParameters(host='192.168.10.131')) 
#创建一个链接对象,对象中绑定rabbitmq的IP地址
 
 
channel=connection.channel()        #创建一个频道
 
channel.queue_declare(queue='name1'#通过这个频道来创建队列,如果MQ中队列存在忽略,没有则创建
 
channel.basic_publish(exchange='',
                      routing_key='name1',   #指定队列名称
                      body='Hello World!')   #往该队列中发送一个消息
print(" [x] Sent 'Hello World!'")
connection.close()                           #发送完关闭链接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#####################################消费者######################################
 
import pika
 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.10.131'))
#创建一个链接对象,对象中绑定rabbitmq的IP地址
 
channel = connection.channel()         #创建一个频道
 
channel.queue_declare(queue='name1')   #通过这个频道来创建队列,如果MQ中队列存在忽略,没有则创建
 
def callback(ch, method, properties, body):   #callback函数负责接收队列里的消息
    print(" [x] Received %r" % body)
 
channel.basic_consume(callback,              #从队列里去消息
                      queue='name1',         #指定队列名
                      no_ack=True)
 
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

acknowledgment 消息不丢失

   上面的例子中如果我们将no-ack=False ,那么当消费者遇到情况(its channel is closed, connection is closed, or TCP connection is lost)挂掉了,那么RabbitMQ会重新将该任务添加到队列中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import pika
 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.10.131'))
channel = connection.channel()
 
channel.queue_declare(queue='name1')
 
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='name1',                             
                      no_ack=False)                    #如果no_ack=False,当消费者down掉了,RabbitMQ会重新将该任务添加到队列中
 
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

  上例如果消费者中断后如果不超过10秒,重新链接的时候数据还在。当超过10秒之后,消费者往生产者发送了ack,重新链接的时候数据将消失。

durable消息不丢失

    消费者down掉后我们知道怎么处理了,如果我的RabbitMQ服务down掉了该怎么办呢?

消息队列是可以做持久化,如果我们在生产消息的时候就指定某条消息需要做持久化,那么RabbitMQ发现有问题时,就会将消息保存到硬盘,持久化下来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
####################################生产者#####################################
#!/usr/bin/env python
  
import pika
  
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.10.131'))
  
channel = connection.channel()
  
channel.queue_declare(queue='name2', durable=True)    #指定队列持久化
  
channel.basic_publish(exchange='',
                      routing_key='name2',
                      body='Hello World!',
                      properties=pika.BasicProperties(
                          delivery_mode=2,            #指定消息持久化
                      ))
print(" [x] Sent 'Hello World!'")
connection.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#####################################消费者######################################
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
  
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.10.131'))
  
channel = connection.channel()
  
channel.queue_declare(queue='name2', 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='name2',
                      no_ack=False)
  
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

消息获取顺序

    默认消息队列里的数据是按照顺序被消费者拿走的,例如:消费者1去队列中获取奇数序列任务,消费者2去队列中获取偶数序列的任务,消费者1处理的比较快而消费者2处理的比较慢,那么消费者1就会一直处于繁忙的状态,为了解决这个问题在需要加入下面代码:

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
 
channel = connection.channel()
 
channel.queue_declare(queue='name1')
 
 
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='name1',
                      no_ack=False)
 
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

2,发布订阅

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

    在RabbitMQ中,所有生产者提交的消息都有Exchange来接收,然后Exchange按照特定的策略转发到Queue进行存储,RabbitMQ提供了四种Exchange:fanout、direct、topic、header。由于header模式在实际工作中用的比较少,下面主要对前三种进行比较。

exchange type = fanout :任何发送到Fanout Exchange的消息都会被转发到与该Exchange绑定(Binding)的所有Queue上

  ​为了方便理解,应用了上面这张图,可以清晰的看到相互之间的关系,当我们设置成fanout模式时,如何操作请看下面代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
####################################发布者#####################################
import pika
 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
 
channel.exchange_declare(exchange='test_fanout',
                         type='fanout')
 
message = '4456'
channel.basic_publish(exchange='test_fanout',
                      routing_key='',
                      body=message)
print(' [x] Sent %r' % message)
connection.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
####################################订阅者#####################################
 
import pika
 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
 
channel.exchange_declare(exchange='test_fanout',        #创建一个exchange
                         type='fanout')                 #任何发送到Fanout Exchange的消息都会被转发到与该Exchange绑定(Binding)的所有Queue上
 
#随机创建队列
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
 
#绑定
channel.queue_bind(exchange='test_fanout',
                   queue=queue_name)                    #exchange绑定后端队列
 
print('<------------->')
 
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:任何发送到Direct Exchange的消息都会被转发到RouteKey中指定的Queue上(关键字发送)

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

 

 发布者:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python
import pika
import sys
 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
 
channel = connection.channel()
 
channel.exchange_declare(exchange='direct_test',
                         type='direct')
 
severity = 'info'         #设置一个key,
message = '99999'
channel.basic_publish(exchange='direct_test',
                      routing_key=severity,
                      body=message)
print(" [x] Sent %r:%r" % (severity, message))
connection.close()

 ​订阅者1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#!/usr/bin/env python
import pika
import sys
 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
 
channel = connection.channel()
 
channel.exchange_declare(exchange='direct_test',
                         type='direct')
 
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
 
severities = ['error','info',]      #绑定队列,并发送关键字error,info
for severity in severities:
    channel.queue_bind(exchange='direct_test',
                       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()

订阅者2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#!/usr/bin/env python
import pika
import sys
 
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
 
channel = connection.channel()
 
channel.exchange_declare(exchange='direct_test',
                         type='direct')
 
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
 
severities = ['error',]
for severity in severities:
    channel.queue_bind(exchange='direct_test',
                       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()

    结论:当我们将发布者的key设置成Error的时候两个队列对可以收到Exchange的消息,当我们将key设置成info后,只有订阅者1可以收到Exchange的消息。

 exchange type = topic:任何发送到Topic Exchange的消息都会被转发到所有关心RouteKey中指定话题的Queue上(模糊匹配)

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

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

  • * :表示只能匹配一个单词。

1
2
3
4
5
#发送路由值        队列中
 
www.cnblogs.com    www.* --->#无法匹配
 
www.cnblogs.com    www.# --->#匹配成功

发布者:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/env python
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()
 
 
#执行方式:
python xxx.py name1   #name1为routing_key

订阅者:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#!/usr/bin/env python
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()
 
#执行方式:
python xxx,py name1

更多相关内容请参考以下连接:

http://www.rabbitmq.com/documentation.html

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

 

posted @ 2016-07-28 01:52 邸海峰 阅读(...) 评论(...) 编辑 收藏
doc