RabbitMQ是一个在AMQP基础上完整的,可复用的企业消息系统。他遵循Mozilla Public License开源协议。
MQ全称为Message Queue, 消息队列(MQ)是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息(针对应用程序的数据)来通信,而无需专用连接来链接它们。消 息传递指的是程序之间通过在消息中发送数据进行通信,而不是通过直接调用彼此来通信,直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。
一、RabbitMQ安装
安装配置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 启动或关闭RabbitMQ服务
RabbitMQ默认端口是5672
Redis默认端口6379
MySQL默认端口3306
http默认端口80
https默认端口443
mongodb默认端口27017
1、RabbitMQ是服务端,那我们怎么来使用呢?
在python程序,pika模块用来驱动RabbitMQ服务 pip install pika
2、RabbitMQ四种工作模式
简单模式
exchange模式
-- fanout 分发模式
-- direct 关键字模式
-- topic 模糊模式
==================****==================
一、acknowledgment 消息不丢失 (应答模式)
二、durable 消息不丢失(数据持久化)
三、消息获取顺序
四、发布订阅
五、关键字发送
六、模糊匹配
==================****==================
RabbitMQ操作
sudo rabbitmqctl add_user alex 123
# 设置用户为administrator角色
sudo rabbitmqctl set_user_tags alex administrator
# 设置权限
sudo rabbitmqctl set_permissions -p "/" alex '.''.''.'
# 然后重启rabbiMQ服务
sudo /etc/init.d/rabbitmq-server restart
# 然后可以使用刚才的用户远程连接rabbitmq server了。
------------------------------
credentials = pika.PlainCredentials("alex","123")
connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.14.47',credentials=credentials))
对于RabbitMQ来说,生产和消费不再针对内存里的一个Queue对象,而是某台服务器上的RabbitMQ Server实现的消息队列.
生产者--》交换机--》队列--》消费者
#!/usr/bin/env python
import pika
# ######################### 生产者 #########################
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost')) # 对RabbitMQ进行连接
channel = connection.channel() # 创建一个通道对象
channel.queue_declare(queue='hello') #创建一个队列,生产者先进RabbitMQ就创建队列,如果消费者先进去,该句没作用(应为消费者已创建队列),
# 简单模式下,生产者 消费者 谁先进入RabbitMQ谁创建队列
channel.basic_publish(exchange='', #定义工作模式的名字
exchange_type='fanout/direct/topic', # 定义工作模式
routing_key='hello', # 在RabbitMQ服务,找的队里名字
body='Hello World!') # 发送的数据
# exchange = '' # 定义名字
# exchange_type = 'fanout/direct/topic' #fanout,direct,topic定义其中一种模式,默认是简单模式
#exchange为空(简单模式),交换机不工作,根据routing_key名字去找队列,
#exchange不为空(exchange模式),交换机工作,routing_key='',
# routing_key = 'hello'
# body= 发送的消息
print(" [x] Sent 'Hello World!'")
connection.close()
#!/usr/bin/env python
import pika
# ########################## 消费者 ##########################
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)
channel.basic_consume(callback, # 从队列取出一个值传给body,交给callback处理,
queue='hello', # 队列名
no_ack=True) #默认不应答,如果从队列取出的值a,交给callback,但是callback过程程序崩了,那么值a就丢失了
# 设置False,使用应答,队列取出值a但还保存着一份,callback处理完值a后,发送一个消息(此次正常处理值a)给RabbitMQ的队列可以删除保存的那份。
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='10.211.55.4')) # 连接RabbitMQ服务
channel = connection.channel() # 创建一个通道对象
#创建一个队列,生产者先进RabbitMQ就创建队列,如果消费者先进去,该句没作用(因为消费者已创建了队列)
#简单模式下,生产者 消费者 谁先进入RabbitMQ谁创建队列
channel.queue_declare(queue='hello') #队列名: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) #=======修改的部分 no_ack =False
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
二、durable 消息不丢失
#==================生产者================
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))
channel = connection.channel()
# make message persistent
channel.queue_declare(queue='hello', durable=True)#=======修改的部分加上 durable=True 队列的内容,内存保存一份,磁盘保存一份
# 如果RabbitMQ服务端崩了,内存数据全没,可以在从磁盘找回
channel.basic_publish(exchange='',
routing_key='hello',
body='Hello World!',
properties=pika.BasicProperties( #=======修改的部分 no_ack =False
delivery_mode=2, # make message persistent
))
print(" [x] Sent 'Hello World!'")
connection.close()
#==================消费者================
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))
channel = connection.channel()
# make message persistent
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(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
三、消息获取顺序
默认消息队列里的数据是按照顺序被消费者拿走,例如:消费者1 去队列中获取 奇数 序列的任务,消费者1去队列中获取 偶数 序列的任务。
channel.basic_qos(prefetch_count=1) 表示谁来谁取,不再按照奇偶数排列
#======================消费者=============
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))
channel = connection.channel()
# make message persistent
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_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()
四、发布订阅
发布订阅和简单的消息队列区别在于,发布订阅会将消息发送给所有的订阅者,而消息队列中的数据被消费一次便消失。所以,RabbitMQ实现发布和订阅时,会为每一个订阅者创建一个队列,而发布者发布消息时,会将消息放置在所有相关队列中。
exchange的 fanout分发模式 #定报纸类似
生产者不在生产队列 ,有消费者生产队列
生产者只管生产数据,进入到RabbitMQ交给交换机 由交换机来连接消费的队列,并生产的数据复制多份给每个消费者都分发一份
exchange ="交换机名字" #可以谁便起
exchange_type ='fanout' # 定义工作模式
#====================发布者==============
#!/usr/bin/env python
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs', # 声明交换机模式 =========修改部分
exchange_type='fanout')
message = ' '.join(sys.argv[1:]) or "info: Hello World!" # python a.py hello egon yuan
#sys.argv[1:] = [hello egon yuan]
channel.basic_publish(exchange='logs',
routing_key='', #由订阅创建队列
body=message)
print(" [x] Sent %r" % message)
connection.close()
#====================订阅者==============
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs', # 设置使用哪种工作模式
exchange_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根据 关键字 判定应该将数据发送至指定队列。
#==================生产者===========
#!/usr/bin/env python
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='direct_logs',
exchange_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()
#==================消费者===========
#!/usr/bin/env python
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='direct_logs',
exchange_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.
# -- 匹配
#=====================生产者============
#!/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()
#=====================生产者============
#!/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()