首页手记手写MQ项目实战：从入门到上手的简单教程

手写MQ项目实战：从入门到上手的简单教程

标签：

Python C++ Go

本文详细介绍了手写MQ项目实战的全过程，涵盖了MQ的基本概念、作用与优势、常见类型以及项目开发前的准备工作。文章还通过示例代码详细讲解了如何创建消息队列、发送与接收消息，以及手动消息确认机制。此外，文章还提供了两个实战案例，包括简单的订单处理系统和实时日志收集系统，帮助读者理解如何在实际项目中应用MQ技术。

MQ简介与基本概念

什么是MQ

MQ全称为Message Queue，即消息队列。它是一种软件中间件，位于消息生产者和消息使用者之间，负责存储和转发消息，以实现不同系统或组件之间的异步通信。消息队列允许生产者将消息发送到队列中，然后由消费者从队列中读取消息，而生产者与消费者不需要同时在线，也不需要知道对方的存在，从而解耦了系统的各个部分。

MQ的作用与优势

作用

解耦：通过消息队列，生产者和消费者之间可以实现解耦，两者之间不需要直接交互，降低了系统的耦合度。
异步处理：生产者发送消息后可以立即返回，不需要等待消费者的响应，提高了系统的响应速度。
削峰填谷：在高并发场景下，消息队列可以作为缓冲层，避免生产者短时间内产生大量消息直接冲击消费者，缓解系统压力。
可扩展性：可以通过消息队列实现系统的横向或纵向扩展，增加或减少消费者数量来处理消息，提高系统的伸缩性。

优势

高可用性：消息队列提供消息的持久化存储，保障了消息的可靠传输。
灵活性：支持多种消息队列协议和多种消息传输协议，可以灵活地集成到不同的系统中。
消息路由：支持高级路由功能，可以根据不同的业务需求将消息路由到不同的队列或消费者。
监控与管理：支持详细的监控和管理功能，方便运维人员进行系统监控和故障排查。

常见MQ类型介绍

常见的消息队列产品有以下几种：

RabbitMQ：一个开源的消息队列系统，使用AMQP（高级消息队列协议）进行消息传递。支持多种消息模式，包括发布/订阅、请求/应答等。
Kafka：由LinkedIn开源的一个分布式发布订阅型消息系统，主要设计目标是高性能和高吞吐量，常用于日志收集和流处理等场景。
ActiveMQ：由Apache开发的一个开源消息代理和轻量级的消息中间件，支持多种传输协议，包括AMQP、STOMP等。
RocketMQ：由阿里巴巴开源的一个分布式消息队列系统，性能高、可靠性强，支持多种消息模式和消息路由策略。
RabbitMQ：使用AMQP作为其消息传递协议，支持多种消息模式，包括发布/订阅、请求/应答等。

示例代码

以下是一段使用RabbitMQ的Python代码示例，展示了如何发送和接收消息：

import pika

# 创建一个连接到本地RabbitMQ服务的连接
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.close()

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

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')

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

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

MQ项目开发前的准备

开发环境搭建

要搭建MQ项目的开发环境，首先需要安装消息队列服务器软件。以RabbitMQ为例，以下是安装步骤：

下载安装包：从官网下载RabbitMQ的安装包，地址为 https://www.rabbitmq.com/download.html。
安装服务：运行安装包，按照提示完成安装。安装完成后，可以通过命令行启动服务。例如在Windows上，可以在命令行中输入 rabbitmq-service install 安装服务，然后使用 rabbitmq-service start 启动服务。
配置环境变量：确保RabbitMQ的安装路径已经添加到系统的环境变量中。

必要工具与库的安装

为了开发MQ项目，需要安装以下工具和库：

编程语言：选择一个适合的编程语言，比如Python、Java、Go等。
消息队列客户端库：安装相应的消息队列客户端库，例如Python的pika、Java的spring-amqp等。
IDE：选择一个适合的IDE，比如PyCharm、IntelliJ IDEA、VSCode等。

以下是一段Python环境准备的示例代码，展示了如何安装RabbitMQ的客户端库pika：

pip install pika

手写MQ消息发送与接收

消息队列的创建

在消息队列中，队列是消息的存储和路由的基本单位。创建队列的步骤如下：

连接到消息队列服务：首先需要连接到MQ服务。
声明一个队列：使用客户端库中的相应方法声明一个队列，如果队列不存在，则会自动创建。

示例代码：

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')

消息的发送与接收

消息发送

消息发送的基本步骤如下：

创建连接：连接到消息队列服务。
声明队列：确保队列已经存在。
发送消息：使用客户端库中的相应方法发送消息到指定队列。

示例代码：

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.close()

消息接收

消息接收的基本步骤如下：

创建连接：连接到消息队列服务。
声明队列：确保队列已经存在。
接收消息：使用客户端库中的相应方法接收消息，并在接收到消息时执行回调函数。

示例代码：

import pika

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')

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

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

手动消息确认机制

默认情况下，消息队列会自动确认消息的接收。在某些场景下，需要手动确认消息的接收，以确保消息已经被正确处理。手动确认机制的基本步骤如下：

创建连接：连接到消息队列服务。
声明队列：确保队列已经存在。
接收消息：接收消息时，不立即确认，而是通过回调函数处理消息。
确认消息：在处理完消息后，手动发送消息确认。

示例代码：

import pika

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    # 模拟消息处理
    print(" [x] Processing...")
    # 手动确认消息
    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')

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

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

MQ项目实战案例

简单的订单处理系统

订单处理系统通常涉及订单生成、订单支付、订单发货等多个步骤。通过消息队列可以实现这些步骤的异步处理，提高系统的响应速度和扩展性。

系统架构

订单处理系统的架构如下：

订单生成模块：生成订单，并将订单信息发送到消息队列。
订单支付模块：接收订单支付消息，处理支付逻辑。
订单发货模块：接收订单发货消息，处理发货逻辑。

示例代码

订单生成模块

import pika

def generate_order(order_id):
    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
    channel = connection.channel()
    channel.queue_declare(queue='order_queue')
    channel.basic_publish(exchange='',
                          routing_key='order_queue',
                          body=f'Order {order_id} generated')
    print(f" [x] Sent 'Order {order_id} generated'")
    connection.close()

generate_order('1001')

订单支付模块

import pika

def callback(ch, method, properties, body):
    print(f" [x] Received {body}")
    # 模拟支付处理
    print(f" [x] Processing payment {body}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='order_queue')

channel.basic_consume(queue='order_queue',
                      on_message_callback=callback)

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

订单发货模块

import pika

def callback(ch, method, properties, body):
    print(f" [x] Received {body}")
    # 模拟发货处理
    print(f" [x] Processing shipment {body}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='shipment_queue')

channel.basic_consume(queue='shipment_queue',
                      on_message_callback=callback)

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

实时日志收集系统

实时日志收集系统通常用于收集服务器和应用的日志信息，并将其转发到日志分析系统进行处理。通过消息队列可以实现日志的实时传输和处理。

系统架构

日志收集系统的架构如下：

日志生成模块：收集服务器和应用的日志信息，并发送到消息队列。
日志处理模块：接收日志消息，进行日志分析和处理。

示例代码

日志生成模块

import pika

def log_event(event):
    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
    channel = connection.channel()
    channel.queue_declare(queue='log_queue')
    channel.basic_publish(exchange='',
                          routing_key='log_queue',
                          body=f'Log event {event}')
    print(f" [x] Sent 'Log event {event}'")
    connection.close()

log_event('User login')

日志处理模块

import pika

def callback(ch, method, properties, body):
    print(f" [x] Received {body}")
    # 模拟日志处理
    print(f" [x] Processing log event {body}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='log_queue')

channel.basic_consume(queue='log_queue',
                      on_message_callback=callback)

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

MQ项目中的常见问题与解决方案

消息丢失与重复问题

消息丢失问题

消息丢失通常是由于以下几个原因引起的：

生产者发送失败：生产者发送消息时，由于网络问题或MQ服务不可用，消息可能没有成功发送到MQ。
MQ服务不可用：MQ服务本身可能由于各种原因不可用，导致消息丢失。
消费者丢失消息：消费者接收消息时可能由于网络问题或处理失败导致消息丢失。

解决方案

持久化消息：确保生产者发送的消息是持久化的，即消息发送到MQ后会被持久化存储。
配置消息重试：配置生产者在发送失败时进行重试，直到消息发送成功。
死信队列：使用死信队列来处理丢失或无法处理的消息。

示例代码

import pika

def publish_message(message):
    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
    channel = connection.channel()
    channel.queue_declare(queue='test_queue', durable=True)
    channel.basic_publish(exchange='',
                          routing_key='test_queue',
                          body=message,
                          properties=pika.BasicProperties(
                              delivery_mode=pika.spec.PERSISTENT_DELIVERY_MODE
                          ))
    print(f" [x] Sent {message}")
    connection.close()

publish_message('Hello World!')

消息重复问题

消息重复通常是由于以下几个原因引起的：

消息确认机制：消息确认机制未正确实现，导致消息被重复处理。
消费端异常：消费端处理消息时发生异常，导致消息未被正确确认。

解决方案

手动确认消息：确保消费端在处理完消息后手动发送确认，避免消息重复处理。
唯一ID处理：为每条消息分配一个唯一ID，通过唯一ID来判断消息是否已经被处理过。

示例代码

import pika

def callback(ch, method, properties, body):
    print(f" [x] Received {body}")
    # 模拟消息处理
    print(f" [x] Processing {body}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='test_queue')

channel.basic_consume(queue='test_queue',
                      on_message_callback=callback)

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

消息堆积问题

问题描述

消息堆积通常是指消息队列中积压了大量的未处理消息，导致系统响应变慢甚至崩溃。这种情况通常是由于消费者处理速度跟不上生产者的发送速度。

解决方案

增加消费者数量：增加消费者的数量，提高消息处理速度。
使用优先级队列：为重要的消息设置较高的优先级，优先处理重要的消息。
流量控制：通过流量控制机制限制生产者发送消息的速度。
分批处理：将大量消息分批处理，避免一次性处理大量消息导致系统资源耗尽。

示例代码

import pika

def callback(ch, method, properties, body):
    print(f" [x] Received {body}")
    # 模拟消息处理
    print(f" [x] Processing {body}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='test_queue', max_length=100)

channel.basic_consume(queue='test_queue',
                      on_message_callback=callback)

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

性能优化技巧

优化建议

减少网络延迟：优化网络环境，减少生产者到MQ服务、MQ服务到消费者之间的网络延迟。
选择合适的队列类型：根据业务需求选择合适的队列类型，例如直接队列、主题队列等。
批量发送和接收消息：生产者批量发送消息，消费者批量接收和处理消息，减少通信次数。
异步处理：使用异步处理机制，提高消息处理速度。

示例代码

import pika

def callback(ch, method, properties, body):
    print(f" [x] Received {body}")
    # 模拟消息处理
    print(f" [x] Processing {body}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='test_queue')

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

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

MQ项目的测试与维护

功能性测试

功能性测试是验证MQ项目是否满足预期功能的重要步骤。测试内容包括但不限于以下几个方面：

消息发送与接收：确保消息能够正确发送到队列，并被正确接收。
消息持久化：验证消息是否能够持久化存储。
消息确认机制：验证消息被正确确认后是否会从队列中移除。
异常处理：验证在异常情况下，消息队列能否正确处理。

示例代码

import pika

def test_message_send_receive():
    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
    channel = connection.channel()
    channel.queue_declare(queue='test_queue')

    # 发送消息
    channel.basic_publish(exchange='',
                          routing_key='test_queue',
                          body='Test message')
    print(" [x] Sent 'Test message'")

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

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

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

test_message_send_receive()

性能测试

性能测试是评估MQ项目在高并发场景下的表现。测试内容包括但不限于以下几个方面：

并发发送与接收：测试在高并发场景下，消息能够正确发送和接收。
吞吐量：测试在一定时间内能处理多少消息。
延迟：测试消息从发送到接收的延迟时间。
资源消耗：测试在高并发场景下，系统资源的消耗情况。

示例代码

import pika
import threading

def send_message():
    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
    channel = connection.channel()
    channel.queue_declare(queue='test_queue')

    for i in range(1000):
        channel.basic_publish(exchange='',
                              routing_key='test_queue',
                              body=f'Message {i}')
        print(f" [x] Sent 'Message {i}'")
    connection.close()

def receive_message():
    def callback(ch, method, properties, body):
        print(f" [x] Received {body}")
        ch.basic_ack(delivery_tag=method.delivery_tag)

    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
    channel = connection.channel()
    channel.queue_declare(queue='test_queue')

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

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

send_thread = threading.Thread(target=send_message)
receive_thread = threading.Thread(target=receive_message)

send_thread.start()
receive_thread.start()

日常维护注意事项

维护MQ项目需要关注以下几个方面：

日志监控：定期查看MQ服务的日志，及时发现和处理异常情况。
资源监控：监控MQ服务的资源使用情况，优化资源配置。
备份与恢复：定期备份MQ服务的数据，确保数据安全。
性能优化：根据实际情况进行性能优化，提高系统性能。

示例代码

def monitor_logs():
    import subprocess

    process = subprocess.Popen(['tail', '-f', '/var/log/rabbitmq/rabbit@localhost.log'], stdout=subprocess.PIPE)
    while True:
        output = process.stdout.readline()
        if output:
            print(output.strip())

monitor_logs()

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

呼啦一阵风

手记
篇

粉丝

74

获赞与收藏

319

关注作者，订阅最新文章

阅读免费教程

Python 办公自动化教程

17个小节 25714 870

Python 算法入门教程

15个小节 27431 1072

Python 进阶应用教程

38个小节 65767 1032

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

手写MQ项目实战：从入门到上手的简单教程

作用

优势

示例代码

消息发送

消息接收

系统架构

示例代码

订单生成模块

订单支付模块

订单发货模块

系统架构

示例代码

日志生成模块

日志处理模块

消息丢失问题

解决方案

示例代码

消息重复问题

解决方案

示例代码

问题描述

解决方案

示例代码

优化建议

示例代码

示例代码

示例代码

示例代码

阅读免费教程