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

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

RabbitMQ 是什么?:  消息队列 .

  其他队列 :- queue  - redis列表  - rabbitmq - zeromq

为什么要有消息队列?:   

    - 生产者消费者

    - 数据通信 

     - rest api,http协议发送的json格式数据
                  - webservice,http协议发送的xml格式数据
                  - rpc,基于socket并使用自己封装的协议进行数据传输

  

RabbitMQ安装

服务端   LInux

yum install rabbitmq-server 
客户端  
pip3 install pika 
运行
rabbitmq-server
systemctl start rabbitmq-server sudo rabbitmqctl add_user wupeiqi 123
# 设置用户为administrator角色
sudo rabbitmqctl set_user_tags wupeiqi administrator
# 设置权限
sudo rabbitmqctl set_permissions -p "/" root ".*" ".*" ".*" systemctl restart rabbitmq-server

 a. 普通消息队列

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() # 创建一个队列:s91
channel.queue_declare(queue='s91') # 向队列s91中发送一个 Hello World!
channel.basic_publish(exchange='',routing_key='s91',body='') connection.close()

s1

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel()
channel.queue_declare(queue='s91') def callback(ch, method, properties, body):
print(body) channel.basic_consume(callback,queue='s91',no_ack=True) channel.start_consuming()

s2

 b.ack

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() # 创建一个队列:s91
channel.queue_declare(queue='s91') # 向队列s91中发送一个 Hello World!
channel.basic_publish(exchange='',routing_key='s91',body='') connection.close()

s1

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials))
channel = connection.channel() # channel.queue_declare(queue='s91') def callback(ch, method, properties, body):
print(body) ch.basic_ack(delivery_tag=method.delivery_tag) channel.basic_consume(callback,queue='s91',no_ack=False) channel.start_consuming()

s2

 c.服务端持久化

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() # make message persistent
channel.queue_declare(queue='s92', durable=True) channel.basic_publish(exchange='',
routing_key='s92',
body='Hello World!',
properties=pika.BasicProperties(
delivery_mode=2, # make message persistent
))
connection.close()

s1

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() # make message persistent
channel.queue_declare(queue='s92', durable=True) def callback(ch, method, properties, body):
print(" [x] Received %r" % body) ch.basic_ack(delivery_tag = method.delivery_tag) channel.basic_consume(callback,queue='s92',no_ack=False) channel.start_consuming()

s2

 d.取数据顺序

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() # make message persistent
channel.queue_declare(queue='s92', durable=True) channel.basic_publish(exchange='',
routing_key='s92',
body='Hello World!',
properties=pika.BasicProperties(
delivery_mode=2, # make message persistent
))
connection.close()

s1

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() # make message persistent
channel.queue_declare(queue='s92', durable=True) def callback(ch, method, properties, body):
print(" [x] Received %r" % body) ch.basic_ack(delivery_tag = method.delivery_tag) channel.basic_qos(prefetch_count=1)
channel.basic_consume(callback,queue='s92',no_ack=False) channel.start_consuming()

s2

 e.fanout

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() channel.exchange_declare(exchange='e1',exchange_type='fanout') message = "Hello World!" channel.basic_publish(exchange='e1',routing_key='',body=message) connection.close()

s1

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() channel.exchange_declare(exchange='e1',exchange_type='fanout') # 随机生成对列名
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue # 让队列和e1绑定
channel.queue_bind(exchange='e1',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()

s2

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() channel.exchange_declare(exchange='e1',exchange_type='fanout') # 随机生成对列名
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue # 让队列和e1绑定
channel.queue_bind(exchange='e1',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()

s3

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() channel.exchange_declare(exchange='e1',exchange_type='fanout') # 随机生成对列名
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue # 让队列和e1绑定
channel.queue_bind(exchange='e1',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()

s4

 f.direct

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() channel.exchange_declare(exchange='e2',exchange_type='direct') message = "Hello World!" channel.basic_publish(exchange='e2',routing_key='error',body=message) connection.close()

s1

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() channel.exchange_declare(exchange='e2',exchange_type='direct') # 随机生成对列名
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue # 让队列和e1绑定
channel.queue_bind(exchange='e2',queue=queue_name,routing_key='info')
channel.queue_bind(exchange='e2',queue=queue_name,routing_key='error') def callback(ch, method, properties, body):
print(" [x] %r" % body) channel.basic_consume(callback,queue=queue_name,no_ack=True) channel.start_consuming()

s2

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() channel.exchange_declare(exchange='e2',exchange_type='direct') # 随机生成对列名
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue # 让队列和e1绑定
channel.queue_bind(exchange='e2',queue=queue_name,routing_key='error') def callback(ch, method, properties, body):
print(" [x] %r" % body) channel.basic_consume(callback,queue=queue_name,no_ack=True) channel.start_consuming()

s3

 g.topic

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() channel.exchange_declare(exchange='e3',exchange_type='topic') message = "Hello World!" channel.basic_publish(exchange='e3',routing_key='info.xx.uu',body=message) connection.close()

s1

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() channel.exchange_declare(exchange='e3',exchange_type='topic') # 随机生成对列名
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue # 让队列和e1绑定
channel.queue_bind(exchange='e3',queue=queue_name,routing_key='info.*') def callback(ch, method, properties, body):
print(" [x] %r" % body) channel.basic_consume(callback,queue=queue_name,no_ack=True) channel.start_consuming()

s2

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) channel = connection.channel() channel.exchange_declare(exchange='e3',exchange_type='topic') # 随机生成对列名
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue # 让队列和e1绑定
channel.queue_bind(exchange='e3',queue=queue_name,routing_key='info.#') def callback(ch, method, properties, body):
print(" [x] %r" % body) channel.basic_consume(callback,queue=queue_name,no_ack=True) channel.start_consuming()

s3

 h.超时时间

import pika

credentials = pika.PlainCredentials("root","")
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.13.92',credentials=credentials)) connection.add_timeout(5, lambda: channel.stop_consuming()) channel = connection.channel()
channel.queue_declare(queue='s91') def callback(ch, method, properties, body):
print(body) channel.basic_consume(callback,queue='s91',no_ack=True) channel.start_consuming()

s2

使用:
  a. 普通消息队列

  b. 批量向多个队列中发送

  c. 根据关键字匹配向队列中发送

  d. 模糊匹配向队列中发送

问题:
1. exchange的作用?
  - exchange和队列进行绑定
  - 用户向队列发送数据时,无序再找队列,直接向exchange中发送即可。

2. rabbitmq中有几种exchange?
  - fanout,只要绑定就发
  - dirct,确定关键字
  - topic,模糊匹配

3. 消息持久化和ack
  - 服务端(durable)
  - 客户端(ack)

看官方文档 -----------------------------------------------------
    http://www.rabbitmq.com/getstarted.html


Python RabbitMQ 消息队列的更多相关文章

  1. Python RabbitMQ消息队列

    python内的队列queue 线程 queue:不同线程交互,不能夸进程 进程 queue:只能用于父进程与子进程,或者同一父进程下的多个子进程,进行交互 注:不同的两个独立进程是不能交互的.   ...

  2. openresty 学习笔记番外篇:python访问RabbitMQ消息队列

    openresty 学习笔记番外篇:python访问RabbitMQ消息队列 python使用pika扩展库操作RabbitMQ的流程梳理. 客户端连接到消息队列服务器,打开一个channel. 客户 ...

  3. RabbitMQ消息队列(一): Detailed Introduction 详细介绍

     http://blog.csdn.net/anzhsoft/article/details/19563091 RabbitMQ消息队列(一): Detailed Introduction 详细介绍 ...

  4. RabbitMQ消息队列1: Detailed Introduction 详细介绍

    1. 历史 RabbitMQ是一个由erlang开发的AMQP(Advanced Message Queue )的开源实现.AMQP 的出现其实也是应了广大人民群众的需求,虽然在同步消息通讯的世界里有 ...

  5. (转)RabbitMQ消息队列(七):适用于云计算集群的远程调用(RPC)

    在云计算环境中,很多时候需要用它其他机器的计算资源,我们有可能会在接收到Message进行处理时,会把一部分计算任务分配到其他节点来完成.那么,RabbitMQ如何使用RPC呢?在本篇文章中,我们将会 ...

  6. (转)RabbitMQ消息队列(六):使用主题进行消息分发

    在上篇文章RabbitMQ消息队列(五):Routing 消息路由 中,我们实现了一个简单的日志系统.Consumer可以监听不同severity的log.但是,这也是它之所以叫做简单日志系统的原因, ...

  7. (转)RabbitMQ消息队列(四):分发到多Consumer(Publish/Subscribe)

    上篇文章中,我们把每个Message都是deliver到某个Consumer.在这篇文章中,我们将会将同一个Message deliver到多个Consumer中.这个模式也被成为 "pub ...

  8. RabbitMQ消息队列(四):分发到多Consumer(Publish/Subscribe)

    上篇文章中,我们把每个Message都是deliver到某个Consumer.在这篇文章中,我们将会将同一个Message deliver到多个Consumer中.这个模式也被成为 "pub ...

  9. 使用EasyNetQ组件操作RabbitMQ消息队列服务

    RabbitMQ是一个由erlang开发的AMQP(Advanved Message Queue)的开源实现,是实现消息队列应用的一个中间件,消息队列中间件是分布式系统中重要的组件,主要解决应用耦合, ...

随机推荐

  1. 基于unittest测试框架的扩展

    1 unittest介绍 Unittest,Python自带的单元测试框架,PyUnit类包含TestResult,TestCase, TestSuite,TextTestResult,TextTes ...

  2. C语言实践 输出100以内的素数

    int main() { int isprime = 1; for (int i = 2; i < 101; i++) { isprime = 1;//要确保每次循环都要把这个值设置为1,不然上 ...

  3. Linux Valgrind命令

    一.简介 C/C++程序,最常见的错误之一就是内存泄露.Valgrind 是一款 Linux下的内存调试工具,它可以对编译后的二进制程序进行内存使用监测找出内存泄漏问题. Valgrind通常包括如下 ...

  4. 执行CUnit测试出错

    est/test_fifo.test: error while loading shared libraries: libcunit.so.1: cannot open shared object f ...

  5. ubuntu安装软件包apt-get和dpkg方法

    1apt方法 安装软件 apt-get install softname1 softname2 softname3…… 卸载软件 apt-get remove softname1 softname2 ...

  6. openvswitch安装

    安装前准备软件包及版本 Gcc pkg-config autoconf automake m4 python2.X 下载OVS软件包 http://openvswitch.org/releases/o ...

  7. C#将DataTable数据导出到EXCEL的两种方法

    1.在非服务器控件的页面导出数据,需要借助一张temp空页面post回后台的数据. 前台:window.location.href = "../Temp.aspx"; 后台: tr ...

  8. web大文件上传控件-监控fd_create流程-Xproer.HttpUploader6

      监控fd_create流程 1.打开ie,f12 2.启动网络监控 点击开始捕获 上传文件夹,然后查看监控 将监控信息转到详细视图

  9. 编写高质量代码改善C#程序的157个建议——建议58:用抛出异常代替返回错误代码

    建议58:用抛出异常代替返回错误代码 CLR异常机制的优点: 正常控制流会被立即中止,无效值或状态不会在系统中继续传播. 提供了统一的处理错误的方法. 提供了在构造函数.操作符重载及属性中报告异常的遍 ...

  10. WOX快速搜索

    WOX wox和mac上的Aflred类似,虽然在功能上稍有逊色,但是还是可以给我们使用windows电脑带来很多福利.首先你不需要在桌面放一堆应用软件的快捷方式,桌面可以非常干净整洁,想要打开某个应 ...