简介：消息队列是IT中用于异步通信的应用程序间技术，RabbitMQ是流行的开源消息代理软件。本项目"rabbit-queue-python"聚焦于Python与RabbitMQ的交互，重点在于发送和接收JSON数据。项目将展示如何使用pika库建立连接、序列化JSON、定义交换机和队列以及消息的发送和接收流程。还涵盖了错误处理、连接恢复和消息确认机制，这对于分布式系统和微服务架构等应用具有重要意义。 
1. 消息队列和RabbitMQ简介
1.1 消息队列的作用和优势
在现代软件开发中，消息队列是一种异步通信机制，允许不同组件之间进行解耦、异步处理和分布式部署。通过消息队列，系统能够提高并发处理能力，平衡负载，并提供高可用性和伸缩性。消息队列通过将消息存放在队列中，使得消息的发送者无需等待接收者立即处理消息，从而优化了系统的整体性能。
1.2 RabbitMQ的介绍和核心概念
RabbitMQ 是一种流行的开源消息代理（Message Broker），它实现了高级消息队列协议（AMQP）。它支持多种消息传递模式，包括点对点和发布/订阅，并提供了可靠的消息传递和高可用性。RabbitMQ 通过插件扩展支持多种功能，使得它能够适应各种企业级应用。
在RabbitMQ 中，几个核心组件包括：交换机（Exchange）、队列（Queue）、绑定（Binding）和消息（Message）。交换机负责接收生产者发送的消息，并根据路由规则将消息分发到一个或多个队列。队列是存储消息的地方，生产者将消息放入队列，消费者从队列中取出消息进行处理。绑定用于定义交换机和队列之间的关系。消息则是数据的载体，包含主题、内容和其他属性。
接下来，我们将深入探讨如何在Python中使用pika库与RabbitMQ进行交互，以及安装pika库和创建虚拟环境的相关内容。
2. Python中使用pika库与RabbitMQ交互
Python是一种广泛使用的高级编程语言，以其简洁的语法和强大的功能在开发领域受到青睐。在消息队列的世界里，Python能够通过pika库与RabbitMQ进行交互。pika是RabbitMQ官方提供的一个Python客户端库，能够实现消息的发布、订阅、接收和处理。通过本章节，我们将深入了解如何在Python环境中使用pika库，以及它在与RabbitMQ交互中扮演的关键角色。
2.1 pika库的基本使用方法
2.1.1 pika库的安装和配置
在开始使用pika之前，首先需要确保该库已经安装在你的Python环境中。pika库可以通过Python的包管理工具pip进行安装。
pip install pika
安装完成后，你可能还需要配置一些环境变量或依赖项以确保pika可以正常工作。通常情况下，pika库的安装依赖于其他库，如 amqp 、 six 、 setuptools 等，确保这些库也是最新版本。
安装和配置pika库之后，你可能需要使用到虚拟环境来管理项目依赖，这样可以在不同项目间隔离Python环境。
2.1.2 pika库的核心组件和基本操作
pika库包含几个核心组件，包括 Connection 、 Channel 、 Exchange 和 Queue 等。这些组件共同作用，构建出消息发送和接收的完整流程。
下面展示的是一个简单的pika库基本使用示例，用于连接RabbitMQ服务器、声明交换器和队列，以及发送和接收消息。
import pika
# 连接到RabbitMQ服务器
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# 声明交换器
channel.exchange_declare(exchange='logs', exchange_type='fanout')
# 声明队列
result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue
# 绑定队列到交换器
channel.queue_bind(exchange='logs', queue=queue_name)
# 发送消息
channel.basic_publish(exchange='logs', routing_key='', body='Hello World!')
# 接收消息的回调函数
def callback(ch, method, properties, body):
print(f"Received message: {body}")
# 设置接收消息的回调
channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)
# 开始接收消息
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
在上述代码中，我们首先建立了一个与本地RabbitMQ服务器的连接，并创建了一个通道。然后，声明了一个扇出类型的交换器（通常用于广播消息），并创建了一个非持久化的、自动删除的队列。接下来，我们将队列绑定到交换器上，并通过 basic_publish 方法发送了一条消息。最后，我们设置了一个回调函数来处理接收到的消息，并启动消费。
2.2 Python与RabbitMQ的交互模式
2.2.1 同步交互模式
在同步交互模式中，程序会在发送消息后等待直到收到服务器的响应。这种模式适用于请求/响应的消息交换模式。但是需要注意的是，RabbitMQ本身是异步的，要实现同步交互，你可能需要在客户端实现等待机制。
2.2.2 异步交互模式
异步交互模式是RabbitMQ使用的主要交互模式，其中程序发送消息后继续执行其他任务，不会等待服务器的响应。这种模式的优势在于它能够极大地提高程序的并发处理能力。客户端通过设置回调函数来处理接收到的消息，从而实现了真正的消息异步处理。
在这一部分中，我们探讨了使用pika库与RabbitMQ进行基本交互的方法，包括安装、配置以及核心组件的使用。在下一章中，我们将详细介绍如何安装pika库，并创建虚拟环境以避免依赖冲突。
3. 安装pika库和创建虚拟环境
3.1 安装pika库的步骤和注意事项
3.1.1 使用pip安装pika库
在Python的生态系统中，使用pip安装第三方库是最常见的方式之一。pika库作为Python与RabbitMQ交互的桥梁，可以通过pip轻松安装。以下是安装pika库的基本步骤：
pip install pika
这条命令会将pika库及其依赖项下载并安装到当前Python环境中。为了确保pika库安装成功，可以运行以下Python代码：
import pika
print(pika.__version__)
如果pika库安装无误，上述代码将输出安装的版本号。
3.1.2 安装过程中可能出现的问题及解决办法
在安装pika库的过程中，可能会遇到一些问题。以下是几种常见问题及其解决办法：
兼容性问题
问题描述： 某些操作系统可能与pika库的某些版本不兼容。
解决方法： 首先确认系统环境是否符合pika库的要求。可以通过查阅pika的官方文档，了解其兼容性列表。如果存在兼容性问题，可以尝试安装pika库的特定版本，或更新系统环境以满足要求。
权限问题
问题描述： 在某些系统中，执行pip安装命令时可能会出现权限不足的错误。
解决方法： 使用虚拟环境可以避免系统级别的权限问题。另外，也可以使用 sudo 命令（在Linux或macOS上）或以管理员身份运行命令提示符（在Windows上）。
网络问题
问题描述： 网络连接不稳定或被封锁可能导致安装失败。
解决方法： 确保网络连接正常。如果是网络连接被封锁，考虑使用VPN或者配置代理来绕过封锁。
3.2 创建虚拟环境的步骤和注意事项
3.2.1 使用virtualenv创建虚拟环境
虚拟环境（virtualenv）是一个用来创建独立Python环境的工具。以下是使用virtualenv创建虚拟环境的步骤：
- 首先需要安装virtualenv：
pip install virtualenv
- 创建一个新的虚拟环境目录：
virtualenv myenv
-
激活虚拟环境：
-
在Windows上：
myenv\Scripts\activate
- 在Unix或MacOS上：
source myenv/bin/activate
- 安装pika库到虚拟环境中：
pip install pika
3.2.2 使用conda创建虚拟环境
除了virtualenv，conda也是Python开发者常用的包管理和环境管理工具。以下是使用conda创建虚拟环境的步骤：
-
安装conda（如果尚未安装）。
-
使用conda创建一个新的虚拟环境：
conda create --name myenv python=3.8
- 激活虚拟环境：
conda activate myenv
- 安装pika库到虚拟环境中：
conda install pika
使用conda创建和管理虚拟环境的优点在于其对包依赖关系的管理更为强大，特别是在处理复杂的科学计算包时。
创建和使用虚拟环境的主要优点是隔离项目的依赖，避免不同项目之间的依赖冲突，同时也方便管理不同项目的环境配置。注意，在不同的虚拟环境中安装相同的包时，需要重复安装过程。
在本章中，我们详细介绍了安装pika库和创建虚拟环境的步骤以及相关的注意事项。这些步骤是使用Python与RabbitMQ交互的基础。在接下来的章节中，我们将进一步探讨如何连接到RabbitMQ服务器以及如何在Python中发送和接收消息。
4. 连接到RabbitMQ服务器的步骤
在我们深入探讨如何使用Python连接到RabbitMQ服务器之前，我们需要了解连接服务器的基本概念。这包括配置RabbitMQ服务器、使用正确的参数建立连接以及连接过程中的错误处理。本章将详细阐述本地和远程连接服务器的过程，以及它们之间的差异和各自的注意事项。
4.1 连接到本地RabbitMQ服务器的方法和步骤
4.1.1 配置本地RabbitMQ服务器
在尝试连接本地RabbitMQ服务器之前，确保已经安装并启动了RabbitMQ服务。在大多数操作系统上，RabbitMQ通过其Erlang包提供安装。安装完成后，RabbitMQ服务通常会自动启动。如果未启动，可以通过RabbitMQ提供的命令行工具手动启动服务。
接下来，需要配置RabbitMQ允许远程连接或确保在本机上设置无密码连接，因为默认情况下出于安全考虑，RabbitMQ可能不允许未授权的访问。
4.1.2 连接到本地RabbitMQ服务器
连接到本地RabbitMQ服务器通常比连接到远程服务器要简单，因为网络相关的配置较少。以下是一个使用Python和pika库连接本地RabbitMQ服务器的示例代码。
import pika
# 连接到本地RabbitMQ服务器
credentials = pika.PlainCredentials('username', 'password')
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='localhost', port=5672, credentials=credentials)
)
channel = connection.channel()
print(" [*] Waiting for messages. To exit press CTRL+C")
在此代码中，我们首先导入 pika 模块，然后使用 BlockingConnection 建立连接。 ConnectionParameters 需要几个参数，包括主机名、端口和凭证。默认情况下，RabbitMQ运行在5672端口。如果RabbitMQ配置了默认的用户名和密码，应将它们包含在 PlainCredentials 对象中。连接成功后，我们创建了一个通道 channel ，这是发送和接收消息的通道。
4.2 连接到远程RabbitMQ服务器的方法和步骤
4.2.1 配置远程RabbitMQ服务器
远程连接通常需要额外的配置，这包括确保RabbitMQ服务器的网络配置允许远程连接。通常这涉及到修改RabbitMQ的配置文件 /etc/rabbitmq/rabbitmq.config （或 rabbitmq.config ），并设置 {loopback_users, []}. 以便接受外部连接。
此外，还需要确认服务器的防火墙设置允许从客户端机器到RabbitMQ服务器的相应端口（默认为5672）的连接。
4.2.2 连接到远程RabbitMQ服务器
与连接本地服务器相似，连接远程服务器也需要使用 pika 库。以下是一个连接远程RabbitMQ服务器的示例代码。
import pika
# 连接到远程RabbitMQ服务器
credentials = pika.PlainCredentials('remote_username', 'remote_password')
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='remote_host', port=5672, credentials=credentials)
)
channel = connection.channel()
print(" [*] Waiting for messages. To exit press CTRL+C")
在这里，我们使用了远程服务器的主机名（ remote_host ）和凭据（ remote_username 和 remote_password ）代替了本地主机名和默认凭据。连接成功后，程序将输出确认信息并等待消息。
4.2.3 使用连接参数对象
为了确保连接的灵活性和可重用性，通常建议将连接参数存储在一个单独的参数对象中，以便在代码中多次使用。
# 创建连接参数对象
connection_params = pika.ConnectionParameters(
host='localhost', # 或者远程服务器的IP或域名
port=5672,
credentials=pika.PlainCredentials('username', 'password'),
virtual_host='my_vhost', # 可选，根据需要指定虚拟主机
)
# 使用连接参数对象创建连接
connection = pika.BlockingConnection(connection_params)
channel = connection.channel()
以上示例中， ConnectionParameters 方法接受多个参数，其中包括连接远程或本地RabbitMQ所需的主机、端口、凭证以及可选的虚拟主机参数。虚拟主机（vhost）用于在单个RabbitMQ服务器上隔离资源和用户。
4.2.4 连接中的异常处理
在实际的应用程序中，网络连接可能会中断或失败。因此，使用异常处理机制来处理潜在的连接问题是必不可少的。以下是如何使用Python的 try-except 块来捕获并处理连接异常的示例。
try:
connection = pika.BlockingConnection(connection_params)
channel = connection.channel()
print(" [*] Connected to RabbitMQ")
except pika.exceptions.AMQPConnectionError as e:
print("ERROR: Connection failed: %s" % e)
except Exception as e:
print("Unexpected error: %s" % e)
在此代码段中，如果连接或通道创建过程中出现任何异常，将捕获异常并打印错误消息。 AMQPConnectionError 是一个更具体的异常，专指与AMQP（高级消息队列协议）相关的连接问题。其他所有异常被 Exception 捕获。
4.2.5 完整示例
下面是一个完整的示例，展示了如何在Python中使用pika库连接到远程RabbitMQ服务器：
import pika
import sys
def main():
try:
# 配置连接参数
credentials = pika.PlainCredentials('remote_username', 'remote_password')
connection_params = pika.ConnectionParameters(
host='remote_host', # 替换为远程RabbitMQ服务器地址
port=5672,
credentials=credentials,
virtual_host='my_vhost'
)
# 创建连接
connection = pika.BlockingConnection(connection_params)
channel = connection.channel()
print(" [*] Connected to RabbitMQ server on remote_host")
except pika.exceptions.AMQPConnectionError as e:
print("ERROR: Connection to remote RabbitMQ server failed: %s" % e)
sys.exit(1)
except Exception as e:
print("ERROR: Unexpected error: %s" % e)
sys.exit(1)
finally:
if connection:
connection.close()
print(" [*] Closed connection to RabbitMQ server")
if __name__ == '__main__':
main()
这个脚本尝试连接到远程RabbitMQ服务器，如果连接失败，会打印错误消息并退出。成功连接后，它会打印一个确认消息，最后在脚本退出前关闭连接。
在本章中，我们详细介绍了连接到本地和远程RabbitMQ服务器的过程，包括配置服务器、建立连接、处理异常情况以及使用连接参数对象的实践。理解这些步骤对于确保Python应用程序能够高效、稳定地与RabbitMQ进行交互至关重要。
5. 发送JSON数据到RabbitMQ的方法
在实际开发中，将JSON数据发送到RabbitMQ是常见的需求。JSON作为轻量级的数据交换格式，因其良好的可读性和互操作性而被广泛使用。本章节将深入探讨如何构造JSON数据，并使用Python的pika库将其发送到RabbitMQ消息队列中。
5.1 JSON数据的格式和构造方法
5.1.1 JSON数据的基本格式
JSON数据是一种轻量级的数据交换格式，它基于文本，独立于语言，易于人阅读和编写，同时也易于机器解析和生成。JSON数据通常由以下几种基本数据类型构成：对象（object）、数组（array）、字符串（string）、数值（number）、布尔值（true/false）和null。
一个JSON对象可以表示为一系列的键值对，键（key）和字符串值（string）通过冒号（:）连接，不同键值对之间通过逗号（,）分隔，整个对象用花括号（{}）包裹。例如：
{
"name": "John Doe",
"age": 30,
"isEmployed": true
}
而JSON数组是值（value）的有序集合，使用方括号（[]）包裹。例如：
[
"apple",
"banana",
"orange"
]
5.1.2 Python中构造JSON数据的方法
在Python中，我们可以使用内置的 json 库来构造JSON数据。 json.dumps() 方法可以将Python字典或列表转换为JSON格式的字符串。以下是一个构造JSON数据的例子：
import json
# 构造一个简单的JSON对象
user = {
"name": "John Doe",
"age": 30,
"isEmployed": True
}
# 将Python字典转换为JSON格式字符串
user_json = json.dumps(user)
print(user_json)
# 输出：{"name": "John Doe", "age": 30, "isEmployed": true}
5.2 发送JSON数据到RabbitMQ的方法和步骤
5.2.1 发送JSON数据的基本步骤
要将JSON数据发送到RabbitMQ，我们需要先连接到RabbitMQ服务器，然后创建一个通道，声明一个队列，并使用 basic_publish 方法发送消息。以下是具体的步骤和示例代码：
import pika
import json
# 连接到RabbitMQ服务器
credentials = pika.PlainCredentials('user', 'password')
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, '/', credentials))
channel = connection.channel()
# 声明队列，如果队列不存在则创建
channel.queue_declare(queue='task_queue')
# 准备要发送的JSON数据
message = {
"name": "John Doe",
"age": 30,
"isEmployed": True
}
message_json = json.dumps(message)
# 发送JSON数据到RabbitMQ
channel.basic_publish(exchange='',
routing_key='task_queue',
body=message_json,
properties=pika.BasicProperties(
delivery_mode=2, # make message persistent
))
print(" [x] Sent %r" % message_json)
# 关闭连接
connection.close()
5.2.2 发送JSON数据时可能遇到的问题及解决办法
在发送JSON数据时，可能会遇到以下问题：
- 数据格式错误：确保发送到RabbitMQ的JSON数据格式正确。可以使用在线JSON验证工具进行验证。
- 连接问题：确保RabbitMQ服务已经启动，并且服务器地址、端口等连接信息配置正确。
- 权限问题：确保使用的用户名和密码具有发送消息的权限。
- 消息持久化：如果需要消息在RabbitMQ重启后仍然存在，确保使用了持久化属性
delivery_mode=2。
解决上述问题的方法通常是检查代码、确保RabbitMQ服务运行正常以及配置正确的权限。对于数据格式问题，除了使用在线工具外，也可以在Python中使用 json.loads() 方法反序列化JSON数据，检查是否抛出异常来判断格式是否正确。
接下来，让我们来展示如何使用表格和流程图来展示JSON数据结构和发送消息的流程。
| JSON属性 | 类型 | 描述 | |----------|--------|----------------------------------| | name | string | 用户名，例如："John Doe" | | age | number | 用户年龄，例如：30 | | isEmployed | boolean | 是否就业，例如：true |
graph LR
A[开始] --> B[连接RabbitMQ]
B --> C[声明队列]
C --> D[构造JSON数据]
D --> E[发送消息]
E --> F[关闭连接]
F --> G[结束]
通过上述的示例代码和问题解决方案，您可以更加清晰地了解如何在Python中发送JSON数据到RabbitMQ。接下来，我们将讨论如何接收JSON数据并处理消息的回调函数机制，以完成消息的完整交互过程。
6. 接收JSON数据并处理消息的回调函数机制
6.1 回调函数的基本概念和使用方法
回调函数（Callback Function）是被作为参数传递给另一个函数，在这个函数内部被调用的函数。它是JavaScript中的一个重要概念，同样在Python等其他编程语言中也广泛使用。回调函数的目的是允许用户在某个操作完成后执行某些代码，而不必等待该操作完成。
6.1.1 回调函数的基本概念
回调函数可以是匿名函数（Lambda Function）也可以是定义了的函数。当事件触发时，它被内部函数调用，但参数和时间由内部函数决定。这种机制在异步编程中非常常见，因为回调函数可以保证在事件发生后及时处理结果。
6.1.2 在Python中使用回调函数的方法
在Python中，我们可以定义一个函数并将其作为参数传递给另一个函数。以下是一个简单的回调函数示例：
def callback_function(data):
print(f"Data received: {data}")
def function_that_does_something(callback):
# 假设这里有一个异步操作，比如IO操作
# 操作完成后，调用回调函数
result = perform_io_operation()
callback(result)
def perform_io_operation():
# 模拟IO操作
return "Example Data"
# 调用函数，并传入回调函数
function_that_does_something(callback_function)
在上面的代码中， callback_function 是被作为参数传递给 function_that_does_something 的回调函数。当 perform_io_operation 完成其操作时，它返回一些数据，然后 callback_function 被调用并接收到这些数据作为参数。
6.2 接收JSON数据并处理消息的回调函数机制
6.2.1 设计回调函数处理消息的基本步骤
在消息队列中，接收消息通常涉及到监听队列并处理接收到的消息。使用回调函数可以帮助我们定义如何处理这些消息。以下是在RabbitMQ中接收JSON数据并用回调函数处理消息的基本步骤：
- 连接到RabbitMQ服务器 ：首先需要建立与RabbitMQ的连接。
- 创建通道 ：在连接上创建通道。
- 声明队列 ：声明一个队列，以便RabbitMQ知道在何处存储消息。
- 监听队列 ：使用回调函数来监听队列，当消息到达时，回调函数将被调用。
- 接收消息 ：在回调函数中处理接收到的消息，例如解析JSON格式的数据。
- 消息确认 ：在消息处理完成后，向RabbitMQ确认消息已经被处理。
6.2.2 处理消息时可能遇到的问题及解决办法
在处理消息的过程中可能会遇到各种问题，例如网络中断、消息格式错误或业务逻辑出错。为了解决这些问题，通常会实现错误处理机制和消息重新处理机制。例如，可以将无法处理的消息放入一个死信队列（Dead Letter Queue）中供后续分析和处理。
def on_message_callback(channel, method_frame, header_frame, body):
try:
message = json.loads(body)
# 假设我们处理一个用户注册的场景
process_user_registration(message)
channel.basic_ack(delivery_tag=method_frame.delivery_tag)
except Exception as e:
# 处理异常情况，例如将消息重新发布到死信队列
channel.basic.reject(delivery_tag=method_frame.delivery_tag, requeue=False)
log_error(e)
def process_user_registration(data):
# 这里进行业务逻辑处理，例如验证数据有效性，保存到数据库等
pass
# 这里省略了创建连接、通道、声明队列等步骤
channel.basic_consume(
queue='user_registration_queue', on_message_callback=on_message_callback
)
channel.start_consuming()
在这个例子中，如果 process_user_registration 函数在处理消息时发生异常，消息将不会被确认，并且会被拒绝， requeue=False 参数确保消息不会被重新放入队列中。
6.3 错误处理和连接恢复机制
6.3.1 错误处理的基本方法
错误处理是在软件开发中非常重要的环节。它可以帮助程序在遇到错误时不会立即崩溃，而是可以优雅地进行恢复或者记录错误日志。在RabbitMQ的Python客户端中，错误处理通常通过try-except块来实现。
6.3.2 连接恢复机制的实现和应用
连接恢复机制是指在与RabbitMQ的连接意外丢失时，程序能够自动尝试重新连接。大部分RabbitMQ的客户端库都提供了重连机制。例如，在pika中，你可以使用 Connection.add_on_connection破裂回调 方法添加一个连接破裂后的回调函数。
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
def on_connection破裂(connection, exception):
print("Connection broken, attempting to reconnect...")
connection.add_on_connection破裂_callback(on_connection破裂)
channel.add_on_close_callback(on_connection破裂)
6.4 消息确认机制
6.4.1 消息确认机制的基本概念和原理
消息确认机制是用来保证消息不会因为程序异常或网络问题而丢失的关键机制。在RabbitMQ中，有两种消息确认模式：自动确认和手动确认。在自动确认模式下，消息一旦被RabbitMQ投递，就会认为已经成功处理。手动确认模式需要在程序端调用 basic_ack 方法来确认消息。
6.4.2 在Python中实现消息确认机制的方法
在Python中使用pika时，可以通过在回调函数中调用 channel.basic_ack(delivery_tag=method_frame.delivery_tag) 来实现消息的手动确认。
def on_message_callback(channel, method_frame, header_frame, body):
try:
# 处理消息的逻辑
process_message(body)
channel.basic_ack(delivery_tag=method_frame.delivery_tag)
except Exception as e:
# 处理异常情况
handle_exception(e)
channel.basic_consume(queue='some_queue', on_message_callback=on_message_callback)
channel.start_consuming()
以上，我们深入探讨了在Python中使用RabbitMQ时的回调函数机制，包括如何设计和实现回调函数、处理消息、错误以及确保消息确认。这些机制是确保消息能够被可靠地处理和恢复的关键组件。
简介：消息队列是IT中用于异步通信的应用程序间技术，RabbitMQ是流行的开源消息代理软件。本项目"rabbit-queue-python"聚焦于Python与RabbitMQ的交互，重点在于发送和接收JSON数据。项目将展示如何使用pika库建立连接、序列化JSON、定义交换机和队列以及消息的发送和接收流程。还涵盖了错误处理、连接恢复和消息确认机制，这对于分布式系统和微服务架构等应用具有重要意义。
扫一扫
619
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
