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

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

RabbitMQ安装

epel源安装

现在服务器安装epel源,为什么选择epel源呢?强烈推荐大家使用epel源,epel是社区强烈打造的免费开源发行软件包版本库,系统包含大概有1万多个软件包,163和sohu的镜像是没有这么多软件了.

首选确认你的版本号,然后才能选择相应的epel,命令如下

[root@cobbler ~]# cat /etc/issue
CentOS release 6.5 (Final)

Centos6*源安装:

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

验证是否安装成功,执行如下命令:

[root@cobbler ~]# yum repolist
Loaded plugins: fastestmirror, refresh-packagekit, security
Loading mirror speeds from cached hostfile
* base: mirrors.yun-idc.com
* epel: ftp.riken.jp
* extras: mirrors.yun-idc.com
* updates: mirrors.yun-idc.com
repo id repo name status
base CentOS-6 - Base 6,696
epel Extra Packages for Enterprise Linux 6 - x86_64 12,155
extras CentOS-6 - Extras 62
updates CentOS-6 - Updates 263
repolist: 19,176

看到epel,说明安装成功了,可以看到epel有1万2千155个包.有了他你不在需要tar、configure、make等等繁琐的动作了。使用yum即可搞定一切.

还有一个好处,如果你用自动化运维,使用saltstack puppet ansilble 等等统一配置管理时,都一个重要的要求是统一标准化,我们用epel源,直接一条命令就能安装了,不是很爽么?

安装RabbitMQ

安装erlang
$ yum -y install erlang 安装RabbitMQ
$ yum -y install rabbitmq-server

Python中安装API

pip install pika
or
easy_install pika

Python操作RabbitMQ

基本用法

发布者端:

import pika

connection=pika.BlockingConnection(pika.ConnectionParameters(host='192.168.4.193'))
channel=connection.channel()
channel.queue_declare(queue='cc') #如果有cc的队列,略过;如果没有,创建cc的队列 channel.basic_publish(exchange='',routing_key='cc',body='hello!world!!!')
print("[x] sent 'hello,world!'")
connection.close()

接收端:


import pika #创建一个连接对象,对象中绑定了rabbitmq的IP
connection=pika.BlockingConnection(pika.ConnectionParameters(host='192.168.4.193'))
#创建一个频道对象
channel=connection.channel()
#频道中声明指定queue,如果MQ中没有指定queue就创建,如果有,则略过
channel.queue_declare(queue='cc')
#定义回调函数
def callback(ch,method,properties,body):
print('[x] Recieved %r'%body)
# channel.close()
#no_ack=Fales:表示消费完以后不主动把状态通知rabbitmq,callback:回调函数,queue:指定队列
channel.basic_consume(callback,queue='cc',no_ack=True)
# channel.basic_consume(callback,queue='cc') print('[*] Waiting for msg') channel.start_consuming()

acknowledgment 消息不丢失

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

  • 回调函数中的ch.basic_ack(delivery_tag=method.delivery_tag)
  • basic_comsume中的no_ack=False

消息接收端应该这么写:

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.4.193'))
channel = connection.channel()
channel.queue_declare(queue='cc') # 定义回调函数
def callback(ch, method, properties, body):
print('[x] Recieved %r' % body)
# channel.close()
ch.basic_ack(delivery_tag=method.delivery_tag) # no_ack=Fales:表示消费完以后不主动把状态通知rabbitmq channel.basic_consume(callback, queue='cc',
no_ack=False) print('[*] Waiting for msg') channel.start_consuming()

durable 消息不丢失

消息生产者端发送消息时挂掉了,消费者接消息时挂掉了,以下方法会让RabbitMQ重新将该消息添加到队列中:

  • 回调函数中的ch.basic_ack(delivery_tag=method.delivery_tag),消费端需要做的
  • basic_comsume中的no_ack=False,消费端需要做的
  • 发布消息端的basic_publish添加参数properties=pika.BasicProperties(delivery_mode=2),生产者端需要做的

消息生产者端:

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.4.193'))
channel = connection.channel()
channel.queue_declare(queue='cc') # 如果有cc的队列,略过;如果没有,创建cc的队列 channel.basic_publish(exchange='',
routing_key='cc',
body='hello!world!!!',
properties=pika.BasicProperties(delivery_mode=2)) #消息持久化
print("[x] sent 'hello,world!'")
connection.close()

消息消费者端:

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.4.193'))
channel = connection.channel()
channel.queue_declare(queue='cc') # 定义回调函数
def callback(ch, method, properties, body):
print('[x] Recieved %r' % body)
# channel.close()
ch.basic_ack(delivery_tag=method.delivery_tag) # no_ack=Fales:表示消费完以后不主动把状态通知rabbitmq channel.basic_consume(callback, queue='cc',
no_ack=True) print('[*] Waiting for msg') channel.start_consuming()

消息获取顺序

默认消息队列里的数据是按照顺序被消费者拿走,例如:消费者1去队列中获取 奇数 序列的任务,消费者2去队列中获取 偶数 序列的任务。但有大部分情况下,消息队列后端的消费者服务器的处理能力是不相同的,这就会出现有的服务器闲置时间较长,资源浪费的情况,那么,我们就需要改变默认的消息队列获取顺序!

channel.basic_qos(prefetch_count=1) 表示谁来谁取,不再按照奇偶数排列,这是消费者端需要做的

消费者端如下:

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.4.193'))
channel = connection.channel()
channel.queue_declare(queue='cc') # 定义回调函数
def callback(ch, method, properties, body):
print('[x] Recieved %r' % body)
# channel.close()
ch.basic_ack(delivery_tag=method.delivery_tag) channel.basic_qos(prefetch_count=1) #改变默认获取顺序,谁来谁取 # no_ack=Fales:表示消费完以后不主动把状态通知rabbitmq
channel.basic_consume(callback, queue='cc',
no_ack=True) print('[*] Waiting for msg') channel.start_consuming()

发布和订阅

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

关键字:exchange type = fanout

消息生产者:

import pika

connection=pika.BlockingConnection(pika.ConnectionParameters(host='192.168.11.131'))
channel = connection.channel()
channel.exchange_declare(exchange='logs_fanout',type='fanout') msg='456'
channel.basic_publish(exchange='logs_fanout',routing_key='',body=msg) print('开始发送:%s'%msg)
connection.close()

消息消费者:

import pika

connection=pika.BlockingConnection(pika.ConnectionParameters(host='192.168.11.131'))
channel = connection.channel()
channel.exchange_declare(exchange='logs_fanout',type='fanout') #随机创建队列
result=channel.queue_declare(exclusive=True)
queue_name=result.method.queue #绑定相关队列名称
channel.queue_bind(exchange='logs_fanout',queue=queue_name) def callback(ch,method,properties,body):
print('[x] %r'%body) channel.basic_consume(callback,queue=queue_name,no_ack=True)
channel.start_consuming()

关键字发送

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

关键字:exchange type = direct,默认模式也为此模式.

消息生产者端:

import pika

connection=pika.BlockingConnection(pika.ConnectionParameters(host='192.168.11.131'))
channel = connection.channel()
channel.exchange_declare(exchange='logs_direct_test1',type='direct') serverity='error'
msg='123' channel.basic_publish(exchange='logs_direct_test1',routing_key=serverity,body=msg) print('开始发送:%r:%r'%(serverity,msg))
connection.close()

消息消费者1:

import pika

connection=pika.BlockingConnection(pika.ConnectionParameters(host='192.168.11.131'))
channel = connection.channel()
channel.exchange_declare(exchange='logs_direct_test1',type='direct') #随机创建队列
result=channel.queue_declare(exclusive=True)
queue_name=result.method.queue serverities=['error','info','warning',]
for serverity in serverities:
channel.queue_bind(exchange='logs_direct_test1',queue=queue_name,routing_key=serverity) print('[***] 开始接受消息!') 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:

import pika

connection=pika.BlockingConnection(pika.ConnectionParameters(host='192.168.11.131'))
channel = connection.channel()
channel.exchange_declare(exchange='logs_direct_test1',type='direct') #随机创建队列
result=channel.queue_declare(exclusive=True)
queue_name=result.method.queue serverities=['error',]
for serverity in serverities:
channel.queue_bind(exchange='logs_direct_test1',queue=queue_name,routing_key=serverity) print('[***] 开始接受消息!') 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,exchange将传入”路由值“和 ”关键字“进行匹配,匹配成功,则将数据发送到指定队列。

关键字:exchange type = topic

    • 表示只能匹配 一个 单词
  • # 表示可以匹配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()

Python之操作RabbitMQ的更多相关文章

  1. Python 【第六章】:Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

    Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度 ...

  2. Python操作RabbitMQ

    RabbitMQ介绍 RabbitMQ是一个由erlang开发的AMQP(Advanced Message Queue )的开源实现的产品,RabbitMQ是一个消息代理,从“生产者”接收消息并传递消 ...

  3. Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

    Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度 ...

  4. 十一天 python操作rabbitmq、redis

    1.启动rabbimq.mysql 在""运行""里输入services.msc,找到rabbimq.mysql启动即可 2.启动redis 管理员进入cmd, ...

  5. Python之路【第九篇】:Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

    Python之路[第九篇]:Python操作 RabbitMQ.Redis.Memcache.SQLAlchemy   Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用 ...

  6. python - 操作RabbitMQ

    python - 操作RabbitMQ     介绍 RabbitMQ是一个在AMQP基础上完整的,可复用的企业消息系统.他遵循Mozilla Public License开源协议.MQ全称为Mess ...

  7. 文成小盆友python-num12 Redis发布与订阅补充,python操作rabbitMQ

    本篇主要内容: redis发布与订阅补充 python操作rabbitMQ 一,redis 发布与订阅补充 如下一个简单的监控模型,通过这个模式所有的收听者都能收听到一份数据. 用代码来实现一个red ...

  8. Python之路第十二天,高级(4)-Python操作rabbitMQ

    rabbitMQ RabbitMQ是一个在AMQP基础上完整的,可复用的企业消息系统.他遵循Mozilla Public License开源协议. MQ全称为Message Queue, 消息队列(M ...

  9. python操作---RabbitMQ

    RabbitMQ是一个在AMQP基础上完整的,可复用的企业消息系统.他遵循Mozilla Public License开源协议. MQ全称为Message Queue, 消息队列(MQ)是一种应用程序 ...

随机推荐

  1. python-----将图片与标注的xml坐标水平翻转

    我们做机器学习的时候,总会用到很多训练集,然后我们的数据比较少的时候,就可以将图片翻转标注.代码如下: #!/usr/bin/env python # -*- coding: utf-8 -*- # ...

  2. 机器学习 三剑客 之 pandas + numpy

    机器学习 什么是机器学习? 机器学习是从数据中自动分析获得规律(模型),并利用规律对未知数据进行预测 机器学习存在的目的和价值领域? 领域: 医疗.航空.教育.物流.电商 等... 目的: 让机器学习 ...

  3. BCB6 使用TZCompressionStream压缩

          最近由于项目需要涉及到解压第三方公司的数据,在此做一下记录环境部署和使用方法,免得以后忘记.    对方公司的数据是通过TCompressionStream 压缩之后,存到数据库中,采用的 ...

  4. ubuntu下后台服务的管理

    注册后台服务后都有脚本存在/lib/systemd/system路径下 如mysql为mysql.service 被service管理的进程被杀掉还是会重启的 应使用service XXX stop停 ...

  5. .net 后台页面统一验证是否登录

    首先新写一个PageBase类 using System; using System.Collections.Generic; using System.Web; namespace Departme ...

  6. 【leetcode】1292. Maximum Side Length of a Square with Sum Less than or Equal to Threshold

    题目如下: Given a m x n matrix mat and an integer threshold. Return the maximum side-length of a square ...

  7. 解决GitHub下载速度太慢的问题

    更改hosts文件: Windows 更改C:\Windows\System32\drivers\etc\hosts文件,在文件中追加219.76.4.4 github-cloud.s3.amazon ...

  8. Visual Studio Code:中文乱码

    造冰箱的大熊猫@cnblogs 2019/11/3 在UTF环境下,用VSCode打开一个GB2312编码的文件,显示乱码怎么办? 1.窗口右下方会显示当前所使用的编码格式(下图中手型图标所在处UTF ...

  9. Vue-es6基础语法

    什么是ES6 ECMAScript 6 简称ES6, 在2015年6月正式发布~  ECMAScript 是JavaScript语言的国际标准. 我们本着二八原则,掌握好常用的,有用的~能让我们更快的 ...

  10. Linux进程通信之mmap

    mmap()函数: void *mmap(void* addr,size_t length,int port,int flags,int fd,off_t offset); 返回:成功:返回创建的映射 ...