首页手记消息队列底层原理项目实战入门教程

消息队列底层原理项目实战入门教程

标签：

架构

概述

本文深入探讨了消息队列底层原理，包括架构、消息传递机制、消息持久化与可靠性保障等内容，并通过项目实战详细介绍了消息队列在实际开发中的应用和优化方法，涵盖了从环境搭建到性能优化的全过程，旨在帮助读者全面掌握消息队列底层原理项目实战。

消息队列基础概念

1.1 什么是消息队列

消息队列是一种软件中间件，它允许应用程序之间异步地发送和接收消息。消息队列主要用来在不同的进程、机器、甚至是不同的编程语言之间进行数据交换。它充当一个缓冲器，将生产者生成的消息暂时存储起来，然后由消费者来处理这些消息。

消息队列可以基于不同的实现技术，包括但不限于内存队列、文件队列、数据库队列等。每种实现技术都有其特定的优缺点，适用于不同的应用场景。

1.2 消息队列的作用

消息队列在分布式系统中有多种用途：

解耦：消息队列有助于解耦应用程序的不同组件，使得组件之间的耦合度降低。例如，一个订单系统可以使用消息队列将订单信息发送到库存系统，而不需要直接调用库存系统的API。
异步处理：通过异步处理可以提高系统的响应速度。例如，一个用户请求可以触发消息队列中的任务，用户不必等待任务完成就能得到响应。
削峰填谷：在高并发场景下，消息队列可以缓存大量的请求，从而减少对后端服务的压力。例如，系统可以将大量并发的请求存储在消息队列中，并由后端服务在较低的负载下处理这些请求。
负载均衡：通过消息队列，可以将任务均匀分配给多个消费者，从而实现负载均衡。
可靠传输：消息队列可以提供消息持久化和可靠性保障机制，确保消息不会丢失。

1.3 常见的消息队列系统介绍

常见的消息队列系统包括：

Apache Kafka：Kafka是一个高吞吐量的分布式流处理平台，它以分布式日志的形式存储消息。
RabbitMQ：RabbitMQ是一个在AMQP（高级消息队列协议）标准基础上实现的开源消息队列系统。
Apache ActiveMQ：ActiveMQ是一个流行的Java消息系统，它支持多种消息协议，包括JMS、Stomp和AMQP。
RocketMQ：RocketMQ是一个高吞吐量的分布式消息队列，由阿里巴巴开源。
ZeroMQ：ZeroMQ是一个快速的消息库，它实现了多种消息模式，如发布/订阅、请求/应答等。

消息队列的底层原理

2.1 消息队列的架构

消息队列的架构主要由以下几个部分组成：

生产者：生产者是向消息队列发送消息的应用程序。生产者通常需要与消息队列服务进行交互，将消息发送到指定的队列或主题中。
消费者：消费者是从消息队列中接收消息的应用程序。消费者负责从消息队列中读取消息，并对消息进行处理。
消息队列服务：消息队列服务负责管理和维护队列或主题，包括消息的存储、传输、分发等操作。
消息存储：消息队列服务通常会将消息存储在内存、磁盘或数据库中。这取决于消息队列服务的设计和配置。
消息传输：消息队列服务通过网络将消息从生产者传输到队列或主题中，然后将消息从队列或主题中传输给消费者。

2.2 发布-订阅模型

发布-订阅模型是消息队列中常见的消息传递模式之一，它允许生产者（发布者）将消息发送到一个或多个主题上，同时允许消费者（订阅者）订阅这些主题上的消息。

发布-订阅模型的流程如下：

生产者向特定的主题发布消息。
消费者订阅一个或多个主题，并接收主题上的消息。
当有消息发布到订阅的主题时，消息队列服务会将消息传递给订阅该主题的所有消费者。
消费者处理接收到的消息。

发布-订阅模型的优点包括：

解耦：发布者和订阅者之间没有直接通信，这使得两者之间的耦合度较低。
广播：一个消息可以被多个订阅者接收，这使得消息可以在多个消费者之间共享。
灵活性：订阅者可以在任何时候订阅或取消订阅主题，而不需要修改发布者的代码。

示例代码（使用RabbitMQ实现发布-订阅模型）：

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建主题
channel.exchange_declare(exchange='logs', exchange_type='fanout')

# 发布消息
channel.basic_publish(exchange='logs', routing_key='',
                      body='Hello World!')
print(" [x] Sent 'Hello World!'")

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='logs')

# 订阅主题
channel.queue_bind(exchange='logs', queue='logs')

# 接收消息
def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

channel.basic_consume(queue='logs', on_message_callback=callback, auto_ack=True)

print(" [*] Waiting for messages. To exit press CTRL+C")
channel.start_consuming()

2.3 消息队列中的消息传递机制

消息队列中的消息传递机制通常包括以下几个步骤：

生产者发送消息：生产者将消息发送到消息队列服务指定的队列或主题中。
消息队列服务存储消息：消息队列服务将接收到的消息存储在内存、磁盘或数据库中。
消息队列服务分发消息：消息队列服务将消息从队列或主题中取出，并传递给订阅该队列或主题的消费者。
消费者处理消息：消费者从消息队列服务中接收消息，并对消息进行处理。
消息确认机制：消息队列服务通常会提供一个消息确认机制，确保消息被成功接收和处理。当消费者处理完消息后，消息队列服务会收到确认，然后将消息从队列或主题中移除。如果消费者在处理消息时出现错误或消息队列服务在传递消息时出现问题，消息队列服务会重新尝试传递消息。

消息传递机制的优点包括：

可靠性：消息队列服务可以提供消息的持久化和可靠性保障机制，确保消息不会丢失。
异步处理：通过消息队列，生产者和消费者之间可以异步地发送和接收消息，提高系统的响应速度。

示例代码（使用RabbitMQ实现消息传递机制）：

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='hello')

# 发布消息
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')
print(" [x] Sent 'Hello World!'")

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='hello')

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

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

2.4 消息持久化与可靠性保障

消息的持久化是指将消息存储在磁盘或数据库中，而不是仅仅存储在内存中。消息持久化可以提供更高的可靠性保障，确保消息不会因为系统崩溃或重启而丢失。

消息队列服务通常提供消息持久化和可靠性保障的机制，包括：

消息持久化：生产者可以将消息设置为持久化，表示消息会被存储在磁盘上，而不是仅仅存储在内存中。
确认机制：消费者可以向消息队列服务发送确认消息，表示消息已经被成功接收和处理。当消息队列服务收到确认消息后，会将消息从队列或主题中移除。如果消费者在处理消息时出现错误或消息队列服务在传递消息时出现问题，消息队列服务会重新尝试传递消息。

示例代码（使用RabbitMQ实现消息持久化）：

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列，并设置为持久化
channel.queue_declare(queue='hello', durable=True)

# 发布消息
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!',
                      properties=pika.BasicProperties(
                          delivery_mode=2,  # 消息持久化
                      ))
print(" [x] Sent 'Hello World!'")

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='hello', durable=True)

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

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

2.5 消费者组与负载均衡机制

消费者组是一种消息队列服务的高级特性，它允许将多个消费者分组，并将消息均匀地分配给消费者组中的消费者。这有助于实现负载均衡，并提高系统的处理能力。

消费者组的优点包括：

负载均衡：通过将消息均匀地分配给消费者组中的消费者，可以实现负载均衡，提高系统的处理能力。
容错：当消费者组中的一个消费者出现故障时，消息队列服务可以将消息重新分配给其他消费者，从而提高系统的容错能力。

示例代码（使用RabbitMQ实现消费者组）：

import pika
import time

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='hello')

# 发布消息
for i in range(10):
    channel.basic_publish(exchange='',
                          routing_key='hello',
                          body='Hello World %d' % i)
print(" [x] Sent 'Hello World!'")

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='hello')

# 接收消息
def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    time.sleep(1)
    ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

实战环境搭建

3.1 开发环境要求

开发环境要求包括以下几个方面：

操作系统：支持Linux、Windows、macOS等操作系统。
编程语言：支持Java、Python、C++等编程语言。
消息队列服务：安装并配置消息队列服务，如RabbitMQ、Kafka等。
开发工具：使用IDE或命令行工具进行开发和调试。

示例代码（使用RabbitMQ的安装和配置）：

# 下载RabbitMQ的安装包
wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.9.15/rabbitmq-server_3.9.15-1_all.deb

# 安装RabbitMQ
sudo dpkg -i rabbitmq-server_3.9.15-1_all.deb

# 启动RabbitMQ
sudo systemctl enable rabbitmq-server
sudo systemctl start rabbitmq-server

# 配置RabbitMQ
sudo rabbitmq-plugins enable rabbitmq_management

3.2 安装消息队列软件

安装消息队列软件通常包括以下几个步骤：

下载安装包：从官方下载消息队列软件的安装包。
安装软件：使用命令行或图形界面安装软件。
配置软件：根据需要配置软件的参数，如端口、用户名、密码等。

示例代码（使用RabbitMQ的安装和配置）：

# 下载RabbitMQ的安装包
wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.9.15/rabbitmq-server_3.9.15-1_all.deb

# 安装RabbitMQ
sudo dpkg -i rabbitmq-server_3.9.15-1_all.deb

# 启动RabbitMQ
sudo systemctl enable rabbitmq-server
sudo systemctl start rabbitmq-server

# 配置RabbitMQ
sudo rabbitmq-plugins enable rabbitmq_management

3.3 配置消息队列服务

配置消息队列服务通常包括以下几个步骤：

创建队列：使用消息队列服务提供的API或命令行工具创建队列。
创建主题：使用消息队列服务提供的API或命令行工具创建主题。
设置权限：为不同的用户或角色设置相应的权限，确保消息队列服务的安全性。
配置消息传递参数：根据需要配置消息传递的参数，如消息的持久化、消息的传递模式等。

示例代码（使用RabbitMQ的配置）：

import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='hello', durable=True)

# 创建主题
channel.exchange_declare(exchange='logs', exchange_type='fanout')

# 发布消息
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!',
                      properties=pika.BasicProperties(
                          delivery_mode=2,  # 消息持久化
                      ))
print(" [x] Sent 'Hello World!'")

# 设置权限
channel.queue_bind(exchange='logs', queue='hello')
channel.queue_bind(exchange='logs', queue='hello', routing_key='log.error')

消息队列的简单使用

4.1 创建消息生产者与消费者

创建消息生产者和消费者通常包括以下几个步骤：

生产者：生产者是向消息队列发送消息的应用程序。生产者通常需要与消息队列服务进行交互，将消息发送到指定的队列或主题中。
消费者：消费者是从消息队列中接收消息的应用程序。消费者负责从消息队列中读取消息，并对消息进行处理。

示例代码（使用RabbitMQ创建消息生产者与消费者）：

# 生产者
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='hello')

# 发布消息
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')
print(" [x] Sent 'Hello World!'")

# 消费者
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='hello')

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

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

4.2 发送与接收消息的基本步骤

发送和接收消息的基本步骤包括以下几个步骤：

创建连接：使用消息队列服务提供的API或命令行工具创建与消息队列服务的连接。
创建队列或主题：使用消息队列服务提供的API或命令行工具创建队列或主题。
发送消息：使用消息队列服务提供的API或命令行工具将消息发送到指定的队列或主题中。
接收消息：使用消息队列服务提供的API或命令行工具从队列或主题中接收消息。
处理消息：对接收的消息进行处理，完成相应的业务逻辑。

示例代码（使用RabbitMQ发送与接收消息）：

# 发送消息
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='hello')

# 发布消息
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')
print(" [x] Sent 'Hello World!'")

# 接收消息
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='hello')

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

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

4.3 控制消息传递的优先级

控制消息传递的优先级通常包括以下几个步骤：

设置消息的优先级：在发送消息时，可以通过设置消息的优先级来控制消息的传递顺序。
接收消息时处理优先级：在接收消息时，可以根据消息的优先级进行处理，确保高优先级的消息优先得到处理。

示例代码（使用RabbitMQ控制消息传递的优先级）：

# 发送消息
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='hello')

# 发布消息
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!',
                      properties=pika.BasicProperties(
                          priority=0  # 设置消息的优先级
                      ))
print(" [x] Sent 'Hello World!'")

# 接收消息
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='hello')

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

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

实战项目案例

5.1 项目需求分析

项目需求分析通常包括以下几个方面：

项目背景：介绍项目的背景和目的。
项目目标：定义项目的具体目标和预期成果。
项目功能：定义项目需要实现的功能和业务需求。
项目约束：定义项目的约束条件，如时间、资源等。

示例项目需求分析（一个简单的订单系统）：

项目背景：一个电子商务网站需要实现订单系统，该系统需要处理用户的订单信息，并将订单信息传递给库存系统和支付系统。
项目目标：实现一个高可靠、高可用的订单系统，确保订单信息能够被及时处理。
项目功能：包括订单创建、订单支付、库存更新等。
项目约束：项目需要在两周内完成，并且不能影响现有系统的运行。

示例代码（创建订单系统生产者）：

import pika

# 生产者（订单系统）
# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='order')

# 发布消息
channel.basic_publish(exchange='',
                      routing_key='order',
                      body='New Order Created')
print(" [x] Sent 'New Order Created'")

# 消费者（库存系统）
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='order')

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

channel.basic_consume(queue='order', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

5.2 项目设计与实现

项目设计与实现通常包括以下几个步骤：

系统设计：定义系统的架构和组件，包括消息队列服务、生产者、消费者等。
代码实现：编写生产者和消费者的代码，实现消息的发送和接收。
测试与调试：通过单元测试和集成测试，确保系统的正确性和稳定性。

示例代码（实现订单系统）：

# 生产者（订单系统）
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='order')

# 发布消息
channel.basic_publish(exchange='',
                      routing_key='order',
                      body='New Order Created')
print(" [x] Sent 'New Order Created'")

# 消费者（库存系统）
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='order')

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

channel.basic_consume(queue='order', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

5.3 项目部署与测试

项目部署与测试通常包括以下几个步骤：

部署：将生产者和消费者部署到生产环境中，确保系统的稳定运行。
测试：通过单元测试和集成测试，确保系统的正确性和稳定性。
监控：通过监控工具，实时监控系统的性能和状态。

示例代码（部署订单系统）：

# 部署生产者
pip install pika

# 部署消费者
pip install pika

# 测试
pytest

5.4 项目优化建议

项目优化建议通常包括以下几个方面：

性能优化：通过优化代码和配置，提高系统的性能。
安全性优化：通过增加安全性措施，提高系统的安全性。
可维护性优化：通过增加代码的可读性和可维护性，提高系统的可维护性。

示例代码（性能优化建议）：

# 优化生产者代码
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='order')

# 发布消息
for i in range(10000):
    channel.basic_publish(exchange='',
                          routing_key='order',
                          body='New Order Created %d' % i)
print(" [x] Sent 'New Order Created'")

# 优化消费者代码
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='order')

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

channel.basic_consume(queue='order', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

常见问题与解决方案

6.1 常见错误与日志分析

常见的错误包括：

连接问题：连接到消息队列服务失败或无法建立连接。
队列或主题不存在：尝试发送或接收消息时，队列或主题不存在。
消息传递失败：消息发送失败或接收失败。

解决方法：

检查网络连接：确保网络连接正常，并且可以访问消息队列服务。
检查队列或主题的名称：确保队列或主题的名称正确，并且已经创建。
检查消息传递的参数：确保消息传递的参数正确，如消息的持久化、消息的传递模式等。

示例代码（日志分析）：

# 日志文件路径
LOG_FILE_PATH = '/var/log/rabbitmq/rabbit@localhost.log'

# 读取日志文件
with open(LOG_FILE_PATH, 'r') as f:
    log_content = f.read()
    print(log_content)

6.2 性能优化技巧

性能优化技巧通常包括以下几个方面：

优化代码：通过优化代码，提高系统的性能。
增加缓存：通过增加缓存，减少对后端服务的访问。
负载均衡：通过负载均衡，提高系统的处理能力。

示例代码（性能优化技巧）：

# 优化生产者代码
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='order')

# 发布消息
for i in range(10000):
    channel.basic_publish(exchange='',
                          routing_key='order',
                          body='New Order Created %d' % i)
print(" [x] Sent 'New Order Created'")

# 优化消费者代码
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='order')

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

channel.basic_consume(queue='order', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

6.3 安全性保障措施

安全性保障措施通常包括以下几个方面：

权限控制：为不同的用户或角色设置相应的权限，确保消息队列服务的安全性。
加密通信：使用SSL或TLS等加密协议，确保消息的传输安全。
数据加密：使用加密算法，确保消息的数据安全。

示例代码（安全性保障措施）：

# 创建连接（使用SSL）
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost',
                                                               port=5671,
                                                               credentials=pika.PlainCredentials('guest', 'guest'),
                                                               ssl=True,
                                                               ssl_options={
                                                                   "certfile": "/path/to/cert.pem",
                                                                   "keyfile": "/path/to/key.pem",
                                                                   "ca_certs": "/path/to/ca.pem",
                                                                   "cert_reqs": ssl.CERT_REQUIRED
                                                               }))
channel = connection.channel()

# 创建队列
channel.queue_declare(queue='order')

# 发布消息
channel.basic_publish(exchange='',
                      routing_key='order',
                      body='New Order Created')
print(" [x] Sent 'New Order Created'")

# 创建连接（使用SSL）
import pika

# 创建连接
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost',
                                                               port=5671,
                                                               credentials=pika.PlainCredentials('guest', 'guest'),
                                                               ssl=True,
                                                               ssl_options={
                                                                   "certfile": "/path/to/cert.pem",
                                                                   "keyfile": "/path/to/key.pem",
                                                                   "ca_certs": "/path/to/ca.pem",
                                                                   "cert_reqs": ssl.CERT_REQUIRED
                                                               }))
channel = connection.channel()

# 声明队列
channel.queue_declare(queue='order')

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

channel.basic_consume(queue='order', on_message_callback=callback, auto_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕森卡

手记
篇

粉丝

120

获赞与收藏

528

关注作者，订阅最新文章

阅读免费教程

MySQL 进阶教程

32个小节 51574 963

后端通用面试教程

41个小节 30948 346

网络编程入门教程

20个小节 12735 240

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

消息队列底层原理项目实战入门教程

阅读免费教程