Python3模块pika连接RabbitMQ消息队列（代码自用）

原理

• 消息队列（Message Queue）：在消息的传输过程中保存消息的容器
• RabbitMQ：实现了高级消息队列协议（AMQP）的开源消息代理软件

消息队列

AMPQ

RabbitMQ

Python连接RabbitMQ

pika安装

pip install pika

生产者

import pika

# 参数
USERNAME = '用户名'
PASSWORD = '密码'
VIRTUAL_HOST = ''
HOST = ''
PORT = 5672
QUEUE = '队列名'


def basic_publish(exchange, routing_key, body):
    # 创建消息队列连接器
    connection = pika.BlockingConnection(
        pika.ConnectionParameters(HOST, PORT, VIRTUAL_HOST, pika.PlainCredentials(USERNAME, PASSWORD)))
    channel = connection.channel()
    # 写数据
    channel.basic_publish(exchange, routing_key, body)

消费者

import pika

# 参数
USERNAME = '用户名'
PASSWORD = '密码'
VIRTUAL_HOST = ''
HOST = ''
PORT = 5672
QUEUE = '队列名'

# 创建消息队列连接器
credentials = pika.PlainCredentials(USERNAME, PASSWORD)
connection = pika.BlockingConnection(pika.ConnectionParameters(HOST, PORT, VIRTUAL_HOST, credentials))
channel = connection.channel()

if __name__ == '__main__':
    # 读数据不消费
    from json import loads
    channel.basic_consume(QUEUE, lambda a, b, c, d: print(loads(d)))
    channel.start_consuming()

封装自用

import pika
from json import loads


class Q:
    USERNAME = '用户名'
    PASSWORD = '密码'
    VIRTUAL_HOST = ''
    HOST = ''
    PORT = 5672


class QUEUE:
    """队列名称"""
    queue0 = '队列0'
    queue1 = '队列1'
    queue2 = '队列2'


class Mq(QUEUE):
    def __init__(self, q=Q):
        credentials = pika.PlainCredentials(q.USERNAME, q.PASSWORD)
        parameters = pika.ConnectionParameters(q.HOST, q.PORT, q.VIRTUAL_HOST, credentials, heartbeat=0)
        self.connection = pika.BlockingConnection(parameters)
        self.channel = self.connection.channel()

    def basic_consume(self, queue, func=lambda a, b, c, d: print(loads(d))):
        """消费数据（默认不消费）"""
        self.channel.basic_consume(queue, func)
        self.channel.start_consuming()

    def consume(self, queue, func=print):
        """消费数据（默认不报错则消费）"""
        def _func(ch, method, properties, body):
            func(loads(body))
            ch.basic_ack(delivery_tag=method.delivery_tag)  # 不报错则消费
        self.basic_consume(queue, _func)

    def queue_declare(self, queue):
        """声明队列"""
        self.channel.queue_declare(queue)
        print('declare queue:', queue)

    def queue_delete(self, queue):
        """删除队列"""
        self.channel.queue_delete(queue)
        print('delete queue:', queue)

    def basic_publish(self, queue, body):
        """生产数据"""
        self.channel.basic_publish(exchange='', routing_key=queue, body=body)


if __name__ == '__main__':
    Mq().basic_consume(QUEUE.queue0, func=lambda a, b, c, d: print(d))

多线程

def multiprocess(functions):
    from multiprocessing import Process
    pool = [Process(target=f) for f in functions]
    for p in pool:
        p.start()
    for p in pool:
        p.join()


def multithreading(functions):
    from threading import Thread
    pool = [Thread(target=f) for f in functions]
    for p in pool:
        p.start()
    for p in pool:
        p.join()


def _f():
    print(0)
    from time import sleep
    sleep(1.5)
    print(1)


if __name__ == '__main__':
    multithreading([_f, _f])
    # multiprocess([_f, _f])