python-RabbitMQ

简单队列方式

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import Queue
import threading


#建立队列长度为10
message = Queue.Queue(10)

#生产者
def producer(i):
        #往队列中扔消息
        message.put(i)
        print('queue_size=%s'%message.queue)
#消费者
def consumer(i):
        #取队列消息，先进先出
        msg = message.get()


#生产线程
for i in range(10):
    t = threading.Thread(target=producer, args=(i,))
    t.start()
#消费线程
for i in range(5):
    t = threading.Thread(target=consumer, args=(i,))
    t.start()
    
#打印剩余的数据
print('queue_size=%s'%message.queue)

结果：

生产队列增长过程过程

producer_queue=deque([0])
producer_queue=deque([0, 1])
producer_queue=deque([0, 1, 2])
producer_queue=deque([0, 1, 2, 3])
producer_queue=deque([0, 1, 2, 3, 4])
producer_queue=deque([0, 1, 2, 3, 4, 5])
producer_queue=deque([0, 1, 2, 3, 4, 5, 6])
producer_queue=deque([0, 1, 2, 3, 4, 5, 6, 7])
producer_queue=deque([0, 1, 2, 3, 4, 5, 6, 7, 8])
producer_queue=deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

剩余数据
queue=deque([4, 5, 6, 7, 8, 9])

以下是RabbitMQ 主要模式

1简单队列

2exchange{

    1、fanout

    2、direct

    3 、topic

}

安装组件

pip install  pika

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

1、简单队列模型、消息不丢失持久化参数durable 

 生产者

# -*- coding:utf-8 -*-
import pika
#认证的用户密码
credentials = pika.PlainCredentials('openstack', 'RABBIT_PASS')
#远程主机配置
parameters = pika.ConnectionParameters('172.16.21.5',5673,'/',credentials)

#封装socket逻辑部分，拿到操作句柄
connection = pika.BlockingConnection(parameters)
channel = connection.channel()


#创建队列名字为hello,这个队列的名字一般是唯一的.消费者连接的信道名称也是这个
channel.queue_declare(queue='hello')

# 第一种工作状态
#basic_publish设置队列
# exchange='' 就是简单队列的意思，这里exchange不工作
# routing_key='hello' ，exchange不工作了那么这里如何处理，就靠routing_key来找对应队列
#bodybody='Hello World!' 这就是传递的数据
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')
channel.basic_qos(prefetch_count=1)
print(" [x] Sent 'Hello World!'")
connection.close()

消费者

# -*- coding:utf-8 -*-
import pika
#认证的用户密码
credentials = pika.PlainCredentials('openstack', 'RABBIT_PASS')
#远程主机配置
parameters = pika.ConnectionParameters('172.16.21.5',5673,'/',credentials)
connection = pika.BlockingConnection(parameters)
channel = connection.channel()


#消费者这里也创建一个队列，实际中生产者或消费者不一定谁先启动，如果消费者直接去没有创建的队列拿数据会直接报错
channel.queue_declare(queue='hello')

#回调函数
def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    #no_ack=false 必须在回调函数中加入下面的方法
    #ch.basic_ack(delivery_tag = method.delivery_tag)

#获取队列中
#queue='hello'获取hello队列的消息
#no_ack=True(无应答)false(有应答).如果callback函数会执行很长时间如果期间消费者机器出问题那么(无应答)模式消息取从队列
#中取走后就会删除掉的,无法找回。(有应答)队列必须等待callback正确执行完在删除队列消息
channel.basic_consume(callback,
                      queue='hello',
                      no_ack=True)

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

消息获取顺序

默认队列中有12消息，三个消费者,A四个消息、B四个消息、C四个消息。BC处理块A处理慢就会变成A继续处理消息，BC闲置

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

#消费者增加下面的方法
channel.basic_qos(prefetch_count=1)

channel.basic_consume(callback,
                      queue='hello',
                      no_ack=False)

2、exchange工作模型（fanout，direct，topic）

     fanout模式

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
import sys
credentials = pika.PlainCredentials('openstack', 'RABBIT_PASS')
parameters = pika.ConnectionParameters('172.16.21.5',5673,'/',credentials)
connection = pika.BlockingConnection(parameters)
channel = connection.channel()

#exchange创建一个交换机名为logs,并且设置类型为fanout
channel.exchange_declare(exchange='logs',
                         type='fanout')

message = 'exchange :type=fanout'
#指定名为logs的交换机,这里使用exchange,routing_key就不需要了。
channel.basic_publish(exchange='logs',
                      routing_key='',
                      body=message)
print(" [x] Sent %r" % message)
connection.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika

credentials = pika.PlainCredentials('openstack', 'RABBIT_PASS')
parameters = pika.ConnectionParameters('172.16.21.5',5673,'/',credentials)
connection = pika.BlockingConnection(parameters)
channel = connection.channel()


#用意和之前一样
channel.exchange_declare(exchange='logs',
                         type='fanout')

#创建一个队列
result = channel.queue_declare(exclusive=True)
#给队列随机命名
queue_name = result.method.queue

#将消费者队列和交换机(exchange='logs')进行绑定
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模式）

这个模式上在上图增加了route key 。生产者发送消息的时候会绑定一个route key，消费者订阅消息也必须绑定route key 。这样一来就可以使用同一个交换机但可以接受自己关心的消息
原理：

 生产者

#!/usr/bin/env python
import pika
import sys

credentials = pika.PlainCredentials('openstack', 'RABBIT_PASS')
parameters = pika.ConnectionParameters('172.16.21.5',5673,'/',credentials)
connection = pika.BlockingConnection(parameters)
channel = connection.channel()

#建立交换机和类型
channel.exchange_declare(exchange='direct_logs',
                         type='direct')
#route key
severity = 'info'
message = 'exchange:type direct'
#发送消息
channel.basic_publish(exchange='direct_logs',
                      routing_key=severity,
                      body=message)
print(" [x] Sent %r:%r" % (severity, message))
connection.close()

消费者

#!/usr/bin/env python
import pika
import sys

credentials = pika.PlainCredentials('openstack', 'RABBIT_PASS')
parameters = pika.ConnectionParameters('172.16.21.5',5673,'/',credentials)
connection = pika.BlockingConnection(parameters)
channel = connection.channel()

#创建交换机和类型
channel.exchange_declare(exchange='direct_logs',
                         type='direct')

#创建队列
result = channel.queue_declare(exclusive=True)
#设定随机队列名
queue_name = result.method.queue

#消费者一个队列可以绑定多个routekey
severities = ['info','error']

#循环多个routekey
for severity in severities:
    #绑定叫交换机、队列、routekey
    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(模糊匹配)

exchange type = topic

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

#匹配模式写在消费者中
abc.123.abc    abc.* -- 不匹配 ,* 表示只能匹配 一个 单词
abc.123.abc    abc.# -- 匹配 ，# 表示可以匹配 0 个 或 多个 单词

消费者

 #!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
import sys

credentials = pika.PlainCredentials('openstack', 'RABBIT_PASS')
parameters = pika.ConnectionParameters('172.16.21.5',5673,'/',credentials)
connection = pika.BlockingConnection(parameters)
channel = connection.channel()

#创建交换机和类型
channel.exchange_declare(exchange='topic_logs1',
                         type='topic')

#创建队列
result = channel.queue_declare(exclusive=True)
#设定随机队列名
queue_name = result.method.queue

#消费者一个队列可以绑定多个routekey
#消费者中用模糊匹配abc.*  这个只能匹配一个字母
severities = ['abc.*']

#循环多个routekey
for severity in severities:
    #绑定叫交换机、队列、routekey
    channel.queue_bind(exchange='topic_logs1',
                       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()

生产者

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
import sys

credentials = pika.PlainCredentials('openstack', 'RABBIT_PASS')
parameters = pika.ConnectionParameters('172.16.21.5',5673,'/',credentials)
connection = pika.BlockingConnection(parameters)
channel = connection.channel()

#建立交换机和类型
channel.exchange_declare(exchange='topic_logs1',
                         type='topic')
#route key'abc.1'
severity = 'abc.1'
message = 'exchange:type topic route_key=abc.#'
#发送消息
channel.basic_publish(exchange='topic_logs1',
                      routing_key=severity,
                      body=message)
print(" [x] Sent %r:%r" % (severity, message))
connection.close()

结果：

[*] Waiting for logs. To exit press CTRL+C
[x] 'abc.1':'exchange:type topic route_key=abc.1'