[193]python中RabbitMQ的使用

最新推荐文章于 2024-05-27 10:40:06 发布

周小董

最新推荐文章于 2024-05-27 10:40:06 发布

阅读量5.4k

点赞数

分类专栏：部署安装类

本文链接：https://blog.csdn.net/xc_zhou/article/details/80851726

版权

部署安装类专栏收录该内容

68 篇文章 6 订阅

订阅专栏

文章目录

1、简介

RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现的产品，RabbitMQ是一个消息代理，从“生产者”接收消息并传递消息至“消费者”，期间可根据规则路由、缓存、持久化消息。“生产者”也即message发送者以下简称P，相对应的“消费者”乃message接收者以下简称C，message通过queue由P到C，queue存在于RabbitMQ，可存储尽可能多的message，多个P可向同一queue发送message，多个C可从同一个queue接收message

内部架构

1.1、关键词说明

Broker：消息队列服务器实体。
Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。
Queue：消息队列载体，每个消息都会被投入到一个或多个队列。
Binding：绑定，它的作用就是把exchange和queue按照路由规则绑定起来。
Routing Key：路由关键字，exchange根据这个关键字进行消息投递。
vhost：虚拟主机，一个broker里可以开设多个vhost，用作不同用户的权限分离。
producer：消息生产者，就是投递消息的程序。
consumer：消息消费者，就是接受消息的程序。
channel：消息通道，在客户端的每个连接里，可建立多个channel，每个channel代表一个会话任务。

1.2、消息队列运行机制

（1）客户端连接到消息队列服务器，打开一个channel。
（2）客户端声明一个exchange，并设置相关属性。
（3）客户端声明一个queue，并设置相关属性。
（4）客户端使用routing key，在exchange和queue之间建立好绑定关系。
（5）客户端投递消息到exchange。
（6）exchange接收到消息后，就根据消息的key和已经设置的binding，将消息投递到一个或多个队列里。

注：在声明一个队列后，如果将其持久化，则下次不需要进行声明，因为该队列已经在rabbitMQ中了！！！

1.3、exchange类型

1、Direct交换机
特点：依据key进行投递
例如绑定时设置了routing key为”hello”，那么客户端提交的消息，只有设置了key为”hello”的才会投递到队列。

2、Topic交换机
特点：对key模式匹配后进行投递，符号”#”匹配一个或多个词，符号” * ”匹配一个词
例如”abc.#”匹配”abc.def.ghi”，”abc.*”只匹配”abc.def”。

3、Fanout交换机
特点：不需要key，采取广播模式，一个消息进来时，投递到与该交换机绑定的所有队列

1.4、消息确认

当客户端从队列中取出消息之后，可能需要一段时间才能处理完成，如果在这个过程中，客户端出错了，异常退出了，而数据还没有处理完成，那么非常不幸，这段数据就丢失了，因为rabbitmq默认会把此消息标记为已完成，然后从队列中移除。

消息确认是客户端从rabbitmq中取出消息，并处理完成之后，会发送一个ack告诉rabbitmq，消息处理完成，当rabbitmq收到客户端的获取消息请求之后，或标记为处理中，当再次收到ack之后，才会标记为已完成，然后从队列中删除。当rabbitmq检测到客户端和自己断开链接之后，还没收到ack，则会重新将消息放回消息队列，交给下一个客户端处理，保证消息不丢失，也就是说，RabbitMQ给了客户端足够长的时间来做数据处理。

在客户端使用no_ack来标记是否需要发送ack，默认是False，开启状态

2、构建环境

2.1、在windows环境下安装rabbitmq，教程如下：

http://jingyan.baidu.com/article/a17d5285173ce68098c8f2e5.html

2.2、安装pika模块

python使用rabbitmq服务，可以使用现成的类库pika、txAMQP或者py-amqplib，这里选择了pika。

在命令行中直接使用pip命令：

pip install pika

3、示例测试

实例的内容就是从send.py发送消息到rabbitmq，receive.py从rabbitmq接收send.py发送的信息。

P表示produce，生产者的意思，也可以称为发送者，实例中表现为send.py；

C表示consumer，消费者的意思，也可以称为接收者，实例中表现为receive.py；

中间红色的表示队列的意思，实例中表现为hello队列。

send.py

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

queue = 'oss.url_test'#队列名
routing_key = 'url_test'
exchange = 'oss_test'

# 新建连接，rabbitmq安装在本地则hostname为'localhost'
hostname = '192.168.8.190'
port=5672

credentials = pika.PlainCredentials(username='',password='')
parameters = pika.ConnectionParameters(host=hostname,port=port,credentials=credentials)
connection = pika.BlockingConnection(parameters=parameters)

# 创建通道
channel = self.connection.channel()
# 创建broker
channel.exchange_declare(exchange=exchange, exchange_type='direct', durable=True)
# 声明一个队列，生产者和消费者都要声明一个相同的队列，用来防止万一某一方挂了，另一方能正常运行
channel.queue_declare(queue=queue, durable=True)
# 把队列和中间人绑定
channel.queue_bind(exchange=exchange, queue=queue, routing_key=routing_key)
# 交换机; 队列名,写明将消息发往哪个队列; 消息内容
# routing_key在使用匿名交换机的时候才需要指定，表示发送到哪个队列,注意当未定义exchange时，routing_key需和queue的值保持一致
channel.basic_publish(exchange=exchange, routing_key=routing_key, body=json.dumps(data)
    ,properties=pika.BasicProperties(delivery_mode=2,))
#关闭连接
connection.close()

receive.py

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

hostname = '192.168.8.190'
port=5672

credentials = pika.PlainCredentials(username='',password='')
parameters = pika.ConnectionParameters(host=hostname,port=port,credentials=credentials)
connection = pika.BlockingConnection(parameters=parameters)
# 创建通道
channel = connection.channel()
channel.queue_declare(queue=queue,durable=True)

def callback(ch, method, properties, body):
    print " [x] Received %r" % (body,)
    ch.basic_ack(delivery_tag=method.delivery_tag)  # 发送ack消息

#添加不按顺序分配消息的参数,可有可无
# channel.basic_qos(prefetch_count=1)  
# 告诉rabbitmq使用callback来接收信息
channel.basic_consume(callback, queue=queue, no_ack=False)#no_ack来标记是否需要发送ack，默认是False，开启状态

# 开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理,按ctrl+c退出
print ' [*] Waiting for messages. To exit press CTRL+C'
channel.start_consuming()

我们先运行send.py发送消息：

再运行receive.py接收消息：

4、消息持久化

消息持久化，消息确认机制使得客户端在崩溃的时候，服务端消息不丢失，但是如果rabbitmq奔溃了呢？该如何保证队列中的消息不丢失？此就需要product在往队列中push消息的时候，告诉rabbitmq，此队列中的消息需要持久化，用到的参数：durable=True，再次强调，Producer和client都应该去创建这个queue，尽管只有一个地方的创建是真正起作用的：

queue的持久化是通过durable=true来实现的

消息的持久化是通过properties=pika.BasicProperties(delivery_mode = 2,)设置的，这里的delivery_mode=1代表不持久化，delivery_mode=2代表持久化

channel.basic_publish(exchange='',routing_key="test",  body=message,  
    properties=pika.BasicProperties(delivery_mode = 2,)  # make message persistent
)

如过将queue的持久化标识durable设置为true，则代表是一个持久的队列，那么在服务重启之后，队列也会存在，因为服务会把持久化的queue存放在硬盘上，当服务重启的时候，会重新什么之前被持久化的queue。

队列是可以被持久化，但是里面的消息是否为持久化那还要看消息的持久化设置。也就是说，重启之前那个queue里面有消息数据的话，重启之后那队列里面是不是还存在原来的消息数据，这个就要取决于在发送消息时对消息的设置了。

如果要在重启后保持消息的持久化必须设置消息是持久化的标识。

设置了队列和消息的持久化之后，当broker服务重启的之后，消息依旧存在。单只设置队列持久化，重启之后消息会丢失；单只设置消息的持久化，重启之后队列消失，既而消息也丢失。单单设置消息持久化而不设置队列的持久化显得毫无意义。

具体代码：

product端：

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(
    host='127.0.0.1', port=5672, ))     #定义连接池
channel = connection.channel()          #声明队列以向其发送消息消息

channel.queue_declare(queue='test_persistent',durable=True)
for i in range(10):
    channel.basic_publish(exchange='', routing_key='test_persistent', body=str(i),properties=pika.BasicProperties(delivery_mode=2))
    print('send success msg[%s] to rabbitmq' %i)
connection.close()   #关闭连接

client端：

import pika
import time

connection = pika.BlockingConnection(pika.ConnectionParameters(
    host='127.0.0.1', port=5672))
channel = connection.channel()

channel.queue_declare(queue='test_persistent',durable=True)


def callback(ch, method, properties, body):
    '''回调函数,处理从rabbitmq中取出的消息'''
    print(" [x] Received %r" % body)
    #time.sleep(5)
    ch.basic_ack(delivery_tag = method.delivery_tag)  #发送ack消息


channel.basic_qos(prefetch_count=1)
channel.basic_consume(callback,queue='test_persistent',no_ack=False)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()    #开始监听 接受消息
注意：client端也需配置durable=True，否则将报下面错误：

pika.exceptions.ChannelClosed: (406, "PRECONDITION_FAILED - parameters for queue 'test_persistent' in vhost '/' not equivalent")

配置完之后，发现product往rabbitmq端push消息之后，重启rabbitmq，消息依然存在

参考：https://www.cnblogs.com/pycode/p/rabbitmq.html
https://www.cnblogs.com/wt11/p/5970297.html

python之rabbitmq消息持久化：
https://blog.csdn.net/junqing124/article/details/108305023
https://blog.csdn.net/u013256816/article/details/60875666
https://developer.aliyun.com/article/769882

周小董

关注

0
点赞
踩
22

收藏

觉得还不错? 一键收藏
打赏
0
评论
[193]python中RabbitMQ的使用

1，简介RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现的产品，RabbitMQ是一个消息代理，从“生产者”接收消息并传递消息至“消费者”，期间可根据规则路由、缓存、持久化消息。“生产者”也即message发送者以下简称P，相对应的“消费者”乃message接收者以下简称C，message通过queue由P到C，queue存在于Ra...
复制链接

扫一扫