人工智能python之rabbitmq如何安装?这个你会吗?很多朋友都觉得这块还比较难掌握的，感觉老复杂了，一碰到这个题，就有点比较烦闷，真的无从下手吗?今天就跟长沙尚学堂小编一起来破破僵局吧。
本文转载于长沙尚学堂，http://www.cssxt.com/javazx/10201.html，网站内还有高淇、马士兵等老师零基础自学java视频免费下载哦
一、rabbitmq安装
rabbitmq是一个在amqp基础上完整的，可复用的企业消息系统，它遵循mozilla pulic license开源协议。
mq全称为message queue，消息队列(mq)是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息(针对应用程序的数据)来通信，而无需专用链接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。
1.yum安装rabbitmq
#安装配置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
#pip安装：
pip install pika
#源码安装：
https://pypi.python.org/pypi/pika #官网地.址
之前我们在介绍线程，进程的时候介绍过python中自带的队列用法，下面我们通过一段代码回顾一下：
#生产者消费者模型，解耦的意思就是两个程序之间，互相没有关联了，互不影响。
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，基本用法
####################################生产者#####################################
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() #发送完关闭链接
#####################################消费者######################################
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会重新将该任务添加到队列中。
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发现有问题时，就会将消息保存到硬盘，持久化下来。
####################################生产者#####################################
#!/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()
#####################################消费者######################################
#!/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) :表示谁来获取，不再按照奇偶数 排列
#!/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模式时，如何操作请看下面代码：
####################################发布者#####################################
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()
####################################订阅者#####################################
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根据关键字判定应该将数据发送至指定队列。
发布者：
#!/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：
#!/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：
#!/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个或多个单词;
* ：表示只能匹配一个单词。
#发送路由值 队列中
www.cnblogs.com www.* --->#无法匹配
www.cnblogs.com www.# --->#匹配成功
发布者：
#!/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
订阅者：
#!/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
长沙尚学堂java培训很不错，小班制授课，0学费入学，毕业后再分期，14天免费试听，入学签订协议，实战教学模式，就业保障服务，职业素质培训...外地家长来长沙尚学堂实地考察，学校还可以报销车费，真的很不错！！！

---

北京尚学堂科技有限公司湖南分公司
0731 83072091