RocketMQ 是一个分布式消息中间件，具有高吞吐量、低延迟、可靠性高等特点。它广泛应用于大规模分布式系统中，用于解耦服务之间的直接调用、异步处理、流量削峰等场景。
一、关键组件
NameServer
作用：轻量级服务发现组件，管理集群的元数据（Broker 地址、Topic 路由信息）。Broker
作用：消息存储与转发核心节点，负责消息持久化、投递和查询。Producer
特点：支持同步/异步/单向发送，可指定消息队列（MessageQueue）或由负载均衡策略选择。
分组（Producer Group）：用于事务消息，同一组的生产者需保证事务一致性。Consumer
分组（Consumer Group）：多个消费者共同消费同一 Topic，实现负载均衡。
消费模式：
集群消费：同组消费者分摊消息。
广播消费：每个消费者收到全量消息。
拉取/推送模型：底层为拉取（Pull），封装为推送（Push）接口。Topic
逻辑消息分类，可跨多个 Broker 分布。Queue
是并行存储和消费的最小单元。
其他组件
Filter Server：消息过滤（基于 SQL 表达式或 Tag）。
事务消息：二阶段提交机制，支持分布式事务。
二、Topic、GroupName 和 Tag
在 Apache RocketMQ 中，Topic、GroupName 和 Tag 是用于管理和组织消息传递的关键概念，各自承担着不同的角色：
Topic
定义：Topic 是消息的一级分类方法。每个消息都必须指定一个 Topic，类似于消息的主题或者类别。
作用：生产者将消息发送到特定的 Topic，消费者则订阅自己指定的 Topic 来接收消息。这样可以实现消息的发布/订阅模式，使得消息的生产和消费解耦。
GroupName
生产者 Group 是用于标识一组生产者实例的名称。同一个生产者 Group 中的生产者实例共享相同的配置和状态。如果不指定生产者组，大多数版本的RocketMQ 会使用默认的组名（如 DEFAULT_PRODUCER）。
（1）标识生产者身份
生产者 Group 是 RocketMQ 中唯一标识一组生产者实例的名称。
通过生产者 Group，RocketMQ 可以管理和监控生产者的状态。
（2）事务消息支持
如果使用 RocketMQ 的事务消息功能，生产者 Group 是必须的。
RocketMQ 会根据生产者 Group 来回查事务状态（即检查本地事务是否执行成功）。
（3）消息重试
生产者 Group 与消息的重试机制相关。如果消息发送失败，RocketMQ 会根据生产者 Group 的配置进行重试。
（4）监控和管理
在 RocketMQ 控制台或监控系统中，生产者 Group 用于区分不同的生产者实例，方便运维和监控。
消费者 Group 是用于标识一组消费者实例的名称。同一个消费者 Group 中的消费者实例共享相同的订阅配置和消费进度。
（1）标识消费者身份
消费者 Group 是 RocketMQ 中唯一标识一组消费者实例的名称。
通过消费者 Group，RocketMQ 可以管理和监控消费者的状态。
（2）消费模式
消费者 Group 决定了消息的消费模式：
集群模式（CLUSTERING）：同一个消费者 Group 中的多个消费者实例共同消费消息，每条消息只会被一个消费者实例消费。
广播模式（BROADCASTING）：同一个消费者 Group 中的每个消费者实例都会消费所有的消息。
（3）消费进度管理
RocketMQ 会为每个消费者 Group 维护消费进度（Offset），确保消息不会被重复消费或丢失。
（4）监控和管理
在 RocketMQ 控制台或监控系统中，消费者 Group 用于区分不同的消费者实例，方便运维和监控。
Tag
定义：Tag 是附加在消息上的二级分类标签，允许对 Topic 下的消息做进一步细分。
作用：消费者可以根据需要订阅 Topic 下带有特定 Tag 的消息。这提供了一种更细粒度的消息过滤机制，使得消费者能够更加精确地控制它们想要接收的消息类型。
三、Rocket MQ初始化
1.安装并启动RocketMQ
2.引入依赖
在每个微服务的pom.xml加入依赖
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-spring-boot-starter</artifactId>
<version>2.2.3</version>
</dependency>四、MQ生产者初始化
1.配置文件
server:
port: 8080
rocketmq:
name-server: 127.0.0.1:9876
producer:
group: demo_producer_group_V3
max-message-size: 4194304 # 4MB
send-message-timeout: 2000
retry-times-when-send-failed: 1
retry-times-when-send-async-failed: 12.配置类(RocketMQ 生产者的 Spring Bean)
@Getter
@Setter
@ToString
@Configuration
@ConfigurationProperties(prefix = "rocketmq.producer")
public class MQProducerConfigure {
private String group; // 生产者的group
private String nameServer; // 与配置文件中的 name-server 匹配
private int maxMessageSize = 4194304; // 默认值 4MB
private int sendMessageTimeout = 3000; // 默认值 3秒
private int retryTimesWhenSendFailed = 2; // 默认值 2次
private int retryTimesWhenSendAsyncFailed = 2; // 默认值 2次
@Bean
public DefaultMQProducer defaultProducer() throws MQClientException {
DefaultMQProducer producer = new DefaultMQProducer(group);
producer.setNamesrvAddr(nameServer);
producer.setMaxMessageSize(maxMessageSize);
producer.setSendMsgTimeout(sendMessageTimeout);
producer.setRetryTimesWhenSendFailed(retryTimesWhenSendFailed);
producer.setRetryTimesWhenSendAsyncFailed(retryTimesWhenSendAsyncFailed);
producer.start();
return producer;
}
}如果你的项目需要需要不同的生产者组来处理不同的业务逻辑，可以配置多个 DefaultMQProducer Bean，用：@Bean("producer1")，每个 Bean 使用不同的 group。
//发送配置类追加Bean
@Bean("producer2")
public DefaultMQProducer producer2() throws MQClientException {
DefaultMQProducer producer = new DefaultMQProducer("ProducerGroup2")；
//......
producer.start();
return producer;
}
//MQ发送类使用@Qualifier区分Bean
@Autowired
@Qualifier("producer2")
private DefaultMQProducer producer2;
//发送逻辑五、MQ消费者初始化
1.配置文件
server:
port: 8081
rocketmq:
consumer:
group-name: your_consumer_group
namesrv-addr: 127.0.0.1:9876
topic: TestTopic
tag: TestTag
consume-message-batch-max-size: 102.配置类
配置类目前的设计是针对 topics 的配置格式相同的 topics 进行订阅的，如果你需要支持多个不同的 topic和group，可以采用在配置类里面为每个编写单独的配置Bean。
被@Bean注解标注的消费者方法会在Spring容器初始化期间被执行，而其中关键是.start()方法启动了消费者进程，使得接下来的流程将进入消息消费的循环中。
RocketMQ 支持两种消费模式：
集群模式（CLUSTERING）默认模式。
同一个消费者组（Consumer Group）中的多个消费者共同消费同一个 Topic 的消息。
每条消息只会被消费者组中的一个消费者消费。
适合负载均衡场景。
广播模式（BROADCASTING）
同一个消费者组中的每个消费者都会消费所有的消息。
每条消息会被消费者组中的每个消费者消费一次。
适合消息需要广播到所有消费者的场景。
设置：
consumer.setMessageModel(MessageModel.CLUSTERING); // 集群模式
consumer.setMessageModel(MessageModel.BROADCASTING); // 广播模式
@Getter
@Setter
@ToString
@Configuration
@ConfigurationProperties(prefix = "rocketmq.consumer")
public class MQConsumerOneConfigure {
private String groupName;
private String namesrvAddr;
private String topic;
private String tag;
private Integer consumeMessageBatchMaxSize = 1; // 默认每次消费一条消息
@Bean("defaultMQPushConsumer")
public DefaultMQPushConsumer defaultConsumer() throws MQClientException {
// 创建消费者实例
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(groupName);
consumer.setNamesrvAddr(namesrvAddr);
consumer.setConsumeThreadMin(5);
consumer.setConsumeThreadMax(20);
consumer.setConsumeMessageBatchMaxSize(consumeMessageBatchMaxSize);
consumer.registerMessageListener(new MQConsumeMsgListenerProcessor());
consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
// 订阅主题并启动消费者
try {
//void subscribe(String topic, String tag);
consumer.subscribe(topic,tag);
consumer.start();
} catch (MQClientException e) {
throw new RuntimeException("Failed to start RocketMQ consumer", e);
}
return consumer;
}
}3.监听器方法
@Component
public class MQConsumeMsgListenerProcessor implements MessageListenerConcurrently {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgList, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
if (CollectionUtils.isEmpty(msgList)) {
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
MessageExt messageExt = msgList.get(0);
try {
String topic = messageExt.getTopic();
String tags = messageExt.getTags();
String body = new String(messageExt.getBody(), "utf-8");
} catch (Exception e) {
// TODO 异常处理逻辑
}
// 手动 ACK
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
}六、MQ生产者发送
1.同步消息
生产者阻塞等待Broker返回发送结果（SendResult）。这种模式提供了较高的可靠性，但性能较低，因为它涉及到网络往返延迟。
/*通过 @ConfigurationProperties 注解，
可以将配置文件中的属性绑定到 MQProducerConfigure 类的字段上，
然后通过 @Bean 方法创建并配置 DefaultMQProducer 实例。
*/
@Autowired
private DefaultMQProducer defaultMQProducer;
@GetMapping("/send")
public SendResult send(String msg) throws InterruptedException, RemotingException, MQClientException, MQBrokerException {
if (StringUtils.isEmpty(msg)) {
return null;
}
LOGGER.info("发送MQ消息内容：" + msg);
Message sendMsg = new Message("TestTopic", "TestTag", msg.getBytes());
// 默认3秒超时
SendResult sendResult = defaultMQProducer.send(sendMsg);
LOGGER.info("消息发送响应：" + sendResult.toString());
return sendResult;
}2.异步消息
生产者发送消息后不需要等待Broker的响应，而是提供一个回调函数，在消息发送成功或失败时会被调用。这种方式提高了吞吐量，适用于对响应时间敏感的应用场景。
defaultMQProducer.send(sendMsg, new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
System.out.printf("消息发送成功: %s%n", sendResult);
}
@Override
public void onException(Throwable e) {
System.err.println("消息发送失败: " + e.getMessage());
}
});3.单向消息
生产者只负责发送消息，不关心消息是否成功送达。这种方式适用于某些日志收集等对丢失消息容忍度较高的场景。
defaultMQProducer.sendOneway(sendMsg);4.批量消息
List<Message> messages = new ArrayList<>();
for (int i = 0; i < 10; i++) {
Message sendMsg = new Message("TestTopic", "TestTag",msg.getBytes(RemotingHelper.DEFAULT_CHARSET));
messages.add(sendMsg);
}
// 批量发送消息
defaultMQProducer.send(messages);七、RocketMQTempate简化操作
简化配置
通过 Spring Boot 的自动配置，无需手动创建 DefaultMQProducer 和 DefaultMQPushConsumer。
易用性
提供了更简洁的 API，支持同步、异步、单向、延迟、批量等多种消息发送方式。
与 Spring 生态集成
支持 Spring 的依赖注入、事务管理、AOP 等特性。
自动序列化和反序列化
支持将 Java 对象自动序列化为消息体，以及将消息体反序列化为 Java 对象。
1.依赖注入
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-spring-boot-starter</artifactId>
<version>2.2.2</version> <!-- 使用最新版本 -->
</dependency>2.配置文件
（1）生产者服务配置
# application.yml 示例
rocketmq:
name-server: 127.0.0.1:9876 # 替换为你的NameServer地址
producer:
group: your-producer-group
send-message-timeout: 3000 # 发送超时时间，默认3000ms
retry-times-when-send-failed: 2 # 发送失败时的重试次数（2）消费者服务配置
# application.yml 示例
rocketmq:
name-server: 127.0.0.1:9876 # 替换为你的NameServer地址
consumer:
consume-thread-min: 5 # 最小消费线程数
consume-thread-max: 10 # 最大消费线程数
namesrvAddr: 127.0.0.1:9876 # 如果没有全局设置，则可以在这里单独设置NameServer地址
# broadcast: true # 默认false, 表示集群消费模式；如果设为true则表示广播消费模式3.代码示例
（1）生产者代码示例
同步消息
@Service
public class RocketMQService {
@Autowired
private RocketMQTemplate rocketMQTemplate;
public void sendMessage(String topic, User userMessage) {
rocketMQTemplate.convertAndSend(topic, userMessage);
}
}异步消息
rocketMQTemplate.asyncSend("your-topic", userMessage, new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
// 成功回调处理
}
@Override
public void onException(Throwable throwable) {
// 异常回调处理
}
});单向消息
rocketMQTemplate.sendOneWay("your-topic", "your-message");（2）消费者代码示例
@RocketMQMessageListener可以追加selecrorExpression实现对tag的过滤
@Service
@RocketMQMessageListener(topic = "your-topic", consumerGroup = "your-consumer-group")
public class YourMessageListener implements RocketMQListener<User> {
@Override
public void onMessage(User userMessage) {
// 处理接收到的消息
}
}4.生产者多个Group
在 RocketMQ 中，RocketMQTemplate 的 group 是通过配置文件（如 application.yml）指定的，默认情况下，一个 RocketMQTemplate 实例只需绑定一个生产者 Group。如果你需要支持多个生产者 Group，可以通过以下方式实现：
（1）定义多个 RocketMQTemplate Bean
每个 RocketMQTemplate 实例绑定一个生产者 Group。
rocketmq:
name-server: localhost:9876
producer:
group1:
group: ProducerGroup1 # 生产者 Group1
send-message-timeout: 3000
retry-times-when-send-failed: 2
group2:
group: ProducerGroup2 # 生产者 Group2
send-message-timeout: 5000
retry-times-when-send-failed: 3@Configuration
@ConfigurationProperties(prefix = "rocketmq.producer")
public class RocketMQConfig {
private Map<String, ProducerConfig> group1 = new HashMap<>();
private Map<String, ProducerConfig> group2 = new HashMap<>();
public Map<String, ProducerConfig> getGroup1() {
return group1;
}
public void setGroup1(Map<String, ProducerConfig> group1) {
this.group1 = group1;
}
public Map<String, ProducerConfig> getGroup2() {
return group2;
}
public void setGroup2(Map<String, ProducerConfig> group2) {
this.group2 = group2;
}
@Bean("rocketMQTemplate1")
public RocketMQTemplate rocketMQTemplate1() {
RocketMQTemplate template = new RocketMQTemplate();
template.setProducerGroup(group1.get("group")); // 动态注入 Group1
template.setNameServer("localhost:9876");
return template;
}
@Bean("rocketMQTemplate2")
public RocketMQTemplate rocketMQTemplate2() {
RocketMQTemplate template = new RocketMQTemplate();
template.setProducerGroup(group2.get("group")); // 动态注入 Group2
template.setNameServer("localhost:9876");
return template;
}
public static class ProducerConfig {
private String group;
private int sendMessageTimeout;
private int retryTimesWhenSendFailed;
// Getters and Setters
public String getGroup() {
return group;
}
public void setGroup(String group) {
this.group = group;
}
public int getSendMessageTimeout() {
return sendMessageTimeout;
}
public void setSendMessageTimeout(int sendMessageTimeout) {
this.sendMessageTimeout = sendMessageTimeout;
}
public int getRetryTimesWhenSendFailed() {
return retryTimesWhenSendFailed;
}
public void setRetryTimesWhenSendFailed(int retryTimesWhenSendFailed) {
this.retryTimesWhenSendFailed = retryTimesWhenSendFailed;
}
}
}（2）在代码中通过 @Qualifier 注入不同的 RocketMQTemplate&动态切换生产者 Group
发送消息时，选择对应的 RocketMQTemplate。
@Service
public class MessageService {
@Autowired
@Qualifier("rocketMQTemplate1")
private RocketMQTemplate rocketMQTemplate1;
@Autowired
@Qualifier("rocketMQTemplate2")
private RocketMQTemplate rocketMQTemplate2;
/**
* 使用 ProducerGroup1 发送消息
*/
public void sendToGroup1(String topic, String tag, String message) {
rocketMQTemplate1.syncSend(topic + ":" + tag, message);
}
/**
* 使用 ProducerGroup2 发送消息
*/
public void sendToGroup2(String topic, String tag, String message) {
rocketMQTemplate2.syncSend(topic + ":" + tag, message);
}
}八、MQ分区顺序消费
生产者使用 MessageQueueSelector 指定队列选择策略，将同一业务ID（如订单ID）的消息发送到同一个 MessageQueue。消费者注册 MessageListenerOrderly 监听器，单线程处理同一队列的消息。
添加队列：sh mqadmin updateTopic -n <namesrvAddr> -t <topicName> -r <readQueueNums> -w <writeQueueNums>
1.RocketMQTemplate实现
（1）生产者配置
生产者需要确保同一业务ID的消息发送到同一个MessageQueue，这样才能保证顺序性。
public void sendOrderedMessage(String topic, String message, String shardingKey) {
try {
SendResult result = rocketMQTemplate.syncSendOrderly(topic,
MessageBuilder.withPayload(message).build(),
shardingKey,
2000); // 超时时间
log.info("消息发送成功: {}", result);
} catch (Exception e) {
log.error("消息发送失败", e);
// 根据业务需要处理失败逻辑
}
}（2）消费者配置
消费者需要配置为顺序消费模式，并且正确处理消费失败的情况。
@Service
@Slf4j
@RocketMQMessageListener(
topic = "your_topic",
consumerGroup = "your_consumer_group",
consumeMode = ConsumeMode.ORDERLY, // 设置为顺序消费
messageModel = MessageModel.CLUSTERING // 集群模式
)
public class RocketConsumer implements RocketMQListener<String> {
@Override
public void onMessage(String message) {
try {
// 处理消息
log.info("Received ordered message: {}", message);
// 实际业务处理...
} catch (BusinessException e) { // 业务异常
log.error("业务处理失败但可重试, message: {}-{}", message, e);
throw new RuntimeException(e); // 触发重试
} catch (Exception e) {
log.error("系统异常，需要人工干预, message: {}", message, e);
// 可以将消息存入数据库或死信队列
// 注意：这里仍要抛出异常才能保证不会ACK
throw new RuntimeException(e);
}
}
}2.原生API实现
（1）使用MessageQueueSelector去设置路由策略
@Autowired
private DefaultMQProducer defaultMQProducer;
// SendResult 仅仅是消息发送的结果
public SendResult sendOrderedMessage(String topic, String messageBody, String shardingKey) throws Exception {
Message message = new Message(topic, messageBody.getBytes());
// 使用 shardingKey 选择队列，确保相同 shardingKey 进入同一队列
SendResult sendResult = defaultMQProducer.send(message, new MessageQueueSelector() {
@Override
public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
String key = (String) arg;
int index = Math.abs(key.hashCode()) % mqs.size(); // 取模计算队列索引
return mqs.get(index);
}
}, shardingKey); // 传入 shardingKey 作为路由依据
return sendResult;
}（2）设置独立单线程的消费者配置类并加载监听器
@Getter
@Setter
@Configuration
@ConfigurationProperties(prefix = "rocketmq.consumer.orderly") // 独立配置前缀
public class OrderConsumerConfigure {
private String groupName;
private String namesrvAddr;
private String topic;
private String tag = "*";
private Integer consumeThreadMin = 1; // 顺序消费建议单线程
private Integer consumeThreadMax = 1; // 必须为1
@Bean(name = "orderlyConsumer", initMethod = "start", destroyMethod = "shutdown")
public DefaultMQPushConsumer orderlyConsumer() throws MQClientException {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(groupName);
consumer.setNamesrvAddr(namesrvAddr);
consumer.setConsumeThreadMin(consumeThreadMin);
consumer.setConsumeThreadMax(consumeThreadMax); // 关键点：单线程
consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
consumer.setMessageListener(new OrderlyMessageListener()); // 使用顺序监听器
// 订阅主题并启动消费者
try {
//void subscribe(String topic, String tag);
consumer.subscribe(topic,tag);
consumer.start();
} catch (MQClientException e) {
throw new RuntimeException("Failed to start RocketMQ consumer", e);
}
return consumer;
}
}（3）配置监听器
MessageListenerOrderly确保消息按照它们在队列中的顺序被消费。RocketMQ 将每个队列分配给一个线程进行处理，从而保证了该队列中消息的顺序性。
@Component
public class OrderlyMessageListener implements MessageListenerOrderly { // 关键接口变更
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> messages, ConsumeOrderlyContext context) {
// 1. 空消息判断
if (messages == null || messages.isEmpty()) {
return ConsumeOrderlyStatus.SUCCESS;
}
// 2. 顺序处理（单队列串行执行）
MessageExt message = messages.get(0); // 顺序消费通常每次一条
try {
String body = new String(message.getBody(), "UTF-8");
String shardingKey = message.getKeys(); // 生产者发送时指定的路由键
System.out.printf("[顺序消费] QueueId=%d, ShardingKey=%s, Body=%s%n",
message.getQueueId(), shardingKey, body);
// TODO: 业务处理（如订单状态机变更）
// 注意：此处必须保证幂等性（可能因重试导致重复处理）
return ConsumeOrderlyStatus.SUCCESS;
} catch (Exception e) {
System.err.println("消费失败，等待重试: " + message);
// 挂起当前队列（同一队列的消息会阻塞，其他队列不受影响）
return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
}
}
}九、异步请求-响应模式
服务A：发送消息时设置Response Topic和CorrelationId（uuid）
服务B：消费消息后向Response Topic发送响应消息
服务A：监听响应主题，通过CorrelationId匹配响应
1.服务A代码（RocketMQTemplate实现）
@Service
@RocketMQMessageListener(topic = "response-topic", consumerGroup = "a-consumer-group")
public class RocketMqServiceA implements RocketMQListener<MessageExt> {
@Autowired
private RocketMQTemplate rocketMQTemplate;
private Map<String, CompletableFuture<String>> pendingRequests = new ConcurrentHashMap<>();
//手动调用发送消息
public void process() {
String request = "Request from A";
String correlationId = UUID.randomUUID().toString();
// 发送请求
Message<String> message = MessageBuilder.withPayload(request)
.setHeader(RocketMQHeaders.KEYS, correlationId)
.setHeader("responseTopic", "response-topic") // 指定响应主题
.build();
rocketMQTemplate.send("request-topic", message);
System.out.println("[A] Sent request: " + request);
// 异步等待响应
CompletableFuture<String> future = new CompletableFuture<>();
pendingRequests.put(correlationId, future);
try {
String response = future.get(10, TimeUnit.SECONDS);
System.out.println("[A] Received response: " + response);
} catch (TimeoutException | InterruptedException | ExecutionException e) {
System.out.println("[A] Response timeout");
} finally {
pendingRequests.remove(correlationId);
}
}
@Override
public void onMessage(MessageExt message) {
String corrId = message.getKeys();
String response = new String(message.getBody());
CompletableFuture<String> future = pendingRequests.get(corrId);
if (future != null) {
future.complete(response);
}
}
}2.服务B代码（RocketMQTemplate实现）
@Service
@RocketMQMessageListener(topic = "request-topic", consumerGroup = "b-consumer-group")
public class RocketMqServiceB implements RocketMQListener<MessageExt> {
@Autowired
private RocketMQTemplate rocketMQTemplate;
@Override
public void onMessage(MessageExt message) {
String request = new String(message.getBody());
System.out.println("[B] Received: " + request);
// 处理业务逻辑
String response = "Processed by B: " + request;
// 获取回调信息
String replyTo = message.getProperty("response-topic");
String corrId = message.getKeys();
// 发送响应
Message<String> responseMsg = MessageBuilder.withPayload(response)
.setHeader(RocketMQHeaders.KEYS, corrId)
.build();
rocketMQTemplate.send(replyTo, responseMsg);
}
}
扫一扫
4838
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
