首页手记 Rocket消息队列入门教程

Rocket消息队列入门教程

标签：

大数据中间件

概述

RocketMQ是一款由阿里巴巴开源的消息队列产品，其设计灵感来源于Kafka和ActiveMQ，它在大规模分布式系统中具有高性能、高可用性和高可扩展性等特点。RocketMQ采用了分布式架构，支持多节点部署，能够满足大规模数据处理的需求，适用于电商、金融、物联网等高并发场景。

RocketMQ具有以下主要特性：

高吞吐量：RocketMQ能够支持每秒数百万的消息吞吐量，适用于高并发场景。
高可用性：通过主从复制机制和消息重试机制，保证消息的可靠传输。
高可扩展性：支持水平扩展，可以根据业务需求动态调整集群规模。
消息过滤与路由：支持根据消息属性进行过滤和路由，满足复杂的业务需求。
持久化存储：通过分布式文件系统存储消息，保证消息的持久化。
消息顺序性：支持在某些场景下保证消息的顺序性。
集群管理与监控：提供集群管理工具和监控界面，方便运维。

RocketMQ不仅支持Java开发环境，还提供了丰富的客户端支持，包括C++、Python、Go等，能够满足不同开发语言的需求。

Rocket消息队列简介

RocketMQ具有以下主要特性：

高吞吐量：RocketMQ能够支持每秒数百万的消息吞吐量，适用于高并发场景。
高可用性：通过主从复制机制和消息重试机制，保证消息的可靠传输。
高可扩展性：支持水平扩展，可以根据业务需求动态调整集群规模。
消息过滤与路由：支持根据消息属性进行过滤和路由，满足复杂的业务需求。
持久化存储：通过分布式文件系统存储消息，保证消息的持久化。
消息顺序性：支持在某些场景下保证消息的顺序性。
集群管理与监控：提供集群管理工具和监控界面，方便运维。

RocketMQ不仅支持Java开发环境，还提供了丰富的客户端支持，包括C++、Python、Go等，能够满足不同开发语言的需求。

Rocket消息队列安装与配置

在开始使用RocketMQ之前，需要先完成安装和配置工作。以下步骤将详细说明如何在Linux环境下安装RocketMQ。

安装与配置说明

下载RocketMQ：
从阿里云或GitHub上下载RocketMQ的最新版本源码包。

wget https://github.com/apache/rocketmq/releases/download/v4.9.3/apache-rocketmq-4.9.3-bin.tar.gz

解压并进入RocketMQ目录：
对下载的压缩包进行解压操作。
```
tar -zxvf apache-rocketmq-4.9.3-bin.tar.gz
cd apache-rocketmq-4.9.3
```
配置环境变量：
添加RocketMQ的bin目录到环境变量中，以便直接调用RocketMQ的命令。
```
export ROCKETMQ_HOME=$(pwd)
export PATH=$PATH:$ROCKETMQ_HOME/bin
```
启动NameServer：
RocketMQ的NameServer负责维护Broker的元数据，包括地址信息、集群信息等。启动NameServer。
```
nohup sh bin/mqnamesrv &>logs/namesrv.log &
```
启动Broker：
RocketMQ的Broker是消息的生产者和消费者的代理，负责消息的接收、存储和转发。启动Broker。
```
nohup sh bin/mqbroker -n localhost:9876 &>logs/broker.log &
```
验证启动情况：
检查NameServer和Broker的日志文件，确保它们已成功启动。
```
tail -f logs/namesrv.log
tail -f logs/broker.log
```
确认日志中已输出相关信息，表明RocketMQ已经成功安装和启动。

环境变量配置

为了方便管理和调用RocketMQ的命令行工具，需要将RocketMQ的bin目录添加到环境变量中。具体操作方法如下：

编辑配置文件：
在Linux环境中，通常编辑~/.bashrc或~/.bash_profile文件。
```
vim ~/.bashrc
```
添加环境变量：
在文件中添加以下内容，确保RocketMQ的bin目录被正确添加到环境变量中。
```
export ROCKETMQ_HOME=/path/to/rocketmq
export PATH=$PATH:$ROCKETMQ_HOME/bin
```
使配置生效：
执行以下命令，使环境变量配置生效。
```
source ~/.bashrc
```
验证环境变量：
运行echo $ROCKETMQ_HOME命令，确保RocketMQ的安装路径已经正确设置。

网络配置

RocketMQ的网络配置主要包括IP地址和端口号。确保NameServer和Broker的网络配置正确，避免因网络设置不正确导致RocketMQ无法正常启动或通信。

NameServer的网络配置：
- IP地址：NameServer的IP地址。
- 端口号：通常使用9876端口。
Broker的网络配置：
- IP地址：Broker的IP地址。
- 端口号：Broker的端口号。默认情况下，Broker监听10911端口用于接收消息，10912端口用于发送消息。
- 名称服务器地址：NameServer的地址和端口号，用于注册Broker。

防火墙配置

如果机器上安装了防火墙软件（例如iptables或firewalld），需要确保RocketMQ使用的端口是开放的，避免因防火墙规则导致RocketMQ无法正常运行。

查看当前防火墙规则：
使用命令查看当前开放的端口。
```
sudo iptables -L
```

开放RocketMQ端口：
根据实际情况开放RocketMQ使用的端口。

sudo iptables -I INPUT -p tcp --dport 9876 -j ACCEPT
sudo iptables -I INPUT -p tcp --dport 10911 -j ACCEPT
sudo iptables -I INPUT -p tcp --dport 10912 -j ACCEPT

保存防火墙规则：
保存当前的防火墙规则。
```
sudo iptables-save
```

以上步骤完成后，RocketMQ的安装与配置工作基本完成，可以开始进行消息队列的开发和使用。

Rocket消息队列核心概念解析

RocketMQ的核心概念包括生产者（Producer）、消费者（Consumer）、消息（Message）、主题（Topic）、队列（Queue）和标签（Tag）等。

生产者（Producer）

生产者是发送消息的一方。在RocketMQ中，生产者负责将消息发送到指定的Topic和Queue。生产者可以通过编程接口创建并发送消息。

生产者代码示例

以下是一个简单的Java生产者示例：

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class Producer {
    public static void main(String[] args) throws Exception {
        // 创建生产者
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroup");
        // 设置NameServer地址
        producer.setNamesrvAddr("localhost:9876");
        // 启动生产者
        producer.start();
        // 创建消息
        Message msg = new Message("TestTopic", // topic
                "TagA", // tag
                "Hello RocketMQ".getBytes(RemotingHelper.DEFAULT_CHARSET), // body
                null // properties
        );
        // 发送消息
        SendResult sendResult = producer.send(msg);
        // 输出发送结果
        System.out.printf("%s%n", sendResult);
        // 关闭生产者
        producer.shutdown();
    }
}
``

#### 生产者参数说明

- `DefaultMQProducer`：生产者的构造函数，需要传递一个唯一的生产者组名作为参数。
- `setNamesrvAddr`：设置NameServer的地址，用于查找Broker。
- `start`：启动生产者。
- `Message`：消息对象，包含Topic、Tag、Body等属性。
- `send`：发送消息的方法，返回一个`SendResult`对象，包含发送结果信息。
- `shutdown`：关闭生产者，释放资源。

### 消费者（Consumer）

消费者是接收消息的一方。在RocketMQ中，消费者负责从指定的Topic和Queue中拉取消息。消费者可以通过编程接口接收并处理消息。

#### 消费者代码示例

以下是一个简单的Java消费者示例：

```java
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;

public class Consumer {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("TestTopic", "TagA");
        // 设置从队列头部开始消费
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (MessageExt msg : msgs) {
                System.out.printf("Received message: %s%n", new String(msg.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("Consumer started.");
    }
}

消费者参数说明

DefaultMQPushConsumer：消费者的构造函数，需要传递一个唯一的消费者组名作为参数。
setNamesrvAddr：设置NameServer的地址，用于查找Broker。
subscribe：订阅指定的Topic和Tag。
setMessageModel：设置消息模型，RocketMQ支持广播和集群两种消息模型。
setConsumeFromWhere：设置从队列的哪个位置开始消费。
registerMessageListener：注册消息监听器，用于处理接收到的消息。
start：启动消费者。

消息（Message）

消息是RocketMQ的基本传输单元，由消息头和消息体组成。消息头包含消息的属性信息，如Topic、Tag、Key等；消息体是消息的实际内容。

消息类型

RocketMQ支持多种消息类型，包括普通消息、定时消息、延时消息等。

普通消息：最常用的消息类型，用于实时传输数据。
定时消息：可以在指定时间点发送的消息，适用于定时任务。
延时消息：可以在一定时间后发送的消息，适用于业务处理。

消息发送与接收

在生产者中，使用Message对象封装消息，并通过send方法发送消息。在消费者中，通过消息监听器接收并处理消息。

主题（Topic）

主题是RocketMQ中消息的分类标识。生产者发送的消息需要指定一个Topic，消费者需要订阅相应的Topic才能接收到消息。主题可以看作是消息的逻辑分类，方便管理和路由。

主题命名规则

主题命名规则是TopicName，通常由业务场景决定，例如OrderTopic。

队列（Queue）

队列是RocketMQ中消息的物理存储单元。每个Topic可以包含多个队列，每个队列可以独立处理消息，提高了系统的并发处理能力。

队列分配规则

RocketMQ采用轮询机制将消息分发到不同的队列中，确保消息的均匀分布。

标签（Tag）

标签是对消息进行分类的标识符，可以用于消息过滤和路由。生产者发送消息时可以指定一个Tag，消费者可以订阅特定的Tag来筛选消息。

标签命名规则

标签命名规则是TagName，通常由业务需求决定，例如TagOrder。

消息模型

RocketMQ支持两种消息模型：广播模型（Broadcasting）和集群模型（Clustering）。

广播模型：每个消费者都会接收到相同的消息，适用于需要每个消费者都处理相同消息的场景。
集群模型：每个消费者只会接收到一条消息，适用于需要每个消费者处理不同消息的场景。

消息过滤与路由

RocketMQ支持根据消息的属性进行过滤和路由，满足复杂的业务需求。例如，可以根据Topic、Tag、Key等属性过滤消息。

消息过滤示例

以下是一个简单的Java消费者示例，展示了如何根据Tag过滤消息：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;

public class FilteredConsumer {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("FilteredConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("TestTopic", "TagA");
        // 设置从队列头部开始消费
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (MessageExt msg : msgs) {
                if (new String(msg.getTopic()).equals("TestTopic") && new String(msg.getTag()).equals("TagA")) {
                    System.out.printf("Received message: %s%n", new String(msg.getBody()));
                }
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("FilteredConsumer started.");
    }
}

持久化和消息存储

RocketMQ支持消息的持久化存储，通过分布式文件系统存储消息，确保消息的可靠性。消息存储在Broker中，可以通过配置文件调整存储策略。

消息持久化配置

在broker.conf文件中，可以配置以下参数控制消息的持久化：

fileReservedTime：消息文件保留时间。
fileReservedCount：消息文件保留数量。
brokerRole：Broker的角色，可以是ASYNC_MASTER或SYNC_SLAVE。

消息顺序性

RocketMQ支持在某些场景下保证消息的顺序性，例如在单个ConsumerGroup内消费同一Topic的消息时，可以保证消息的顺序性。

消息顺序性配置

在consumer.properties文件中，可以配置以下参数控制消息的顺序性：

consumeMessageOrderly：是否按顺序消费消息。

多活机制

RocketMQ支持多活机制，多个Broker可以同时处于主角色，确保系统的高可用性和负载均衡。

多活机制配置

在broker.conf文件中，可以配置以下参数控制多活机制：

brokerId：Broker的唯一标识。
brokerName：Broker的名称。

消费者组（ConsumerGroup）

消费者组是消费者的一种组织形式，可以看作是一个逻辑上的消费者集合。消费者组内的多个消费者可以协同工作，共同消费消息。

消费者组配置

在consumer.properties文件中，可以配置以下参数控制消费者组：

consumerId：消费者的唯一标识。
group：消费者组名。

通过以上核心概念的解析，可以更好地理解RocketMQ的工作原理和使用方法。在后续的章节中，将进一步探讨RocketMQ的基本使用方法、常见问题及解决办法，并通过实践案例进行深入分析。

Rocket消息队列基本使用方法

在Rocket消息队列中，消息的发送和接收是通过生产者和消费者来实现的。本节将详细介绍RocketMQ的基本使用方法，包括消息发送、消息接收、消息确认和异常处理等。

消息发送

消息发送是生产者的主要职责。生产者将消息发送到指定的Topic和Queue，然后由Broker负责将消息存储和传递给消费者。

消息发送代码示例

以下是一个Java生产者的完整示例，展示了如何发送消息：

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class SimpleProducer {
    public static void main(String[] args) throws Exception {
        // 创建生产者
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroup");
        // 设置NameServer地址
        producer.setNamesrvAddr("localhost:9876");
        // 启动生产者
        producer.start();
        // 创建消息
        Message msg = new Message("TestTopic", // topic
                "TagA", // tag
                "Hello RocketMQ".getBytes(RemotingHelper.DEFAULT_CHARSET), // body
                null // properties
        );
        // 发送消息
        SendResult sendResult = producer.send(msg);
        // 输出发送结果
        System.out.printf("Message sent: %s%n", sendResult);
        // 关闭生产者
        producer.shutdown();
    }
}

消息发送参数说明

DefaultMQProducer：生产者的构造函数，需要传递一个唯一的生产者组名作为参数。
setNamesrvAddr：设置NameServer的地址，用于查找Broker。
start：启动生产者。
Message：消息对象，包含Topic、Tag、Body等属性。
send：发送消息的方法，返回一个SendResult对象，包含发送结果信息。
shutdown：关闭生产者，释放资源。

消息接收

消息接收是消费者的主要职责。消费者从指定的Topic和Queue中拉取消息，并对消息进行处理。

消息接收代码示例

以下是一个Java消费者的完整示例，展示了如何接收消息：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;

public class SimpleConsumer {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("TestTopic", "TagA");
        // 设置从队列头部开始消费
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (MessageExt msg : msgs) {
                System.out.printf("Received message: %s%n", new String(msg.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("SimpleConsumer started.");
    }
}

消息接收参数说明

DefaultMQPushConsumer：消费者的构造函数，需要传递一个唯一的消费者组名作为参数。
setNamesrvAddr：设置NameServer的地址，用于查找Broker。
subscribe：订阅指定的Topic和Tag。
setMessageModel：设置消息模型，RocketMQ支持广播和集群两种消息模型。
setConsumeFromWhere：设置从队列的哪个位置开始消费。
registerMessageListener：注册消息监听器，用于处理接收到的消息。
start：启动消费者。

消息确认

在RocketMQ中，消费者在处理完消息后需要进行消息确认，以告知Broker消息已被成功消费。如果消息未被确认，Broker会将消息重新放入队列中，以便其他消费者再次尝试处理。

消息确认代码示例

以下是一个Java消费者的完整示例，展示了如何进行消息确认：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;

public class ConfirmConsumer {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConfirmConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("TestTopic", "TagA");
        // 设置从队列头部开始消费
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (MessageExt msg : msgs) {
                System.out.printf("Received message: %s%n", new String(msg.getBody()));
                // 消息处理完成后进行确认
                context.putMessage(msg, ConsumeOrderlyStatus.SUCCESS);
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("ConfirmConsumer started.");
    }
}

消息确认参数说明

context.putMessage：将消息放入确认上下文中，传递ConsumeOrderlyStatus.SUCCESS表示消息已被成功处理。

异常处理

在消息发送和接收过程中，可能会遇到各种异常情况，例如网络异常、消息格式错误等。RocketMQ提供了异常处理机制，帮助开发者应对这些异常情况。

异常处理代码示例

以下是一个Java消费者的完整示例，展示了如何处理异常：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.message.MessageQueue;

public class ExceptionConsumer {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ExceptionConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("TestTopic", "TagA");
        // 设置从队列头部开始消费
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (MessageExt msg : msgs) {
                try {
                    System.out.printf("Received message: %s%n", new String(msg.getBody()));
                    // 模拟异常处理
                    if (new String(msg.getBody()).equals("ExceptionMessage")) {
                        throw new RuntimeException("Exception occurred during message processing.");
                    }
                } catch (Exception e) {
                    // 处理异常
                    System.err.println("Exception caught: " + e.getMessage());
                    // 将消息放入失败队列
                    context.putMessage(msg, ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT);
                }
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("ExceptionConsumer started.");
    }
}

异常处理参数说明

context.putMessage：将消息放入失败队列，传递ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT表示暂时停止处理该队列的消息。

通过以上基本使用方法的介绍，可以更好地了解RocketMQ的消息发送、接收、确认和异常处理过程。在实际项目中，可以根据具体业务需求灵活使用这些功能，以实现高效可靠的消息传递。

Rocket消息队列常见问题及解决办法

在使用Rocket消息队列的过程中，可能会遇到一些常见的问题。本节将详细介绍这些问题及其解决办法，帮助开发者更好地使用RocketMQ。

问题1：生产者发送消息失败

生产者发送消息失败可能是因为网络问题、配置错误或消息格式不正确等原因。以下是一些解决办法：

解决办法

检查网络连接：
- 确保NameServer和Broker的网络连接正常。
- 使用ping命令检查NameServer和Broker的IP地址是否可以正常通信。
- 使用telnet命令检查NameServer和Broker的端口号是否开放。
确认配置正确：
- 检查生产者的setNamesrvAddr配置是否正确，确保NameServer地址设置正确。
- 检查生产者的send方法返回的SendResult，查看发送结果中的sendStatus字段，判断发送是否成功。
检查消息格式：
- 确保消息的Topic、Tag、Body等属性设置正确。
- 使用RocketMQ的Message类创建消息时，确保参数传递正确。

示例代码

以下是一个检查生产者发送消息失败的示例代码：

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class ProducerCheck {
    public static void main(String[] args) throws Exception {
        // 创建生产者
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroup");
        // 设置NameServer地址
        producer.setNamesrvAddr("localhost:9876");
        // 启动生产者
        producer.start();
        // 创建消息
        Message msg = new Message("TestTopic", // topic
                "TagA", // tag
                "Hello RocketMQ".getBytes(RemotingHelper.DEFAULT_CHARSET), // body
                null // properties
        );
        try {
            // 发送消息
            SendResult sendResult = producer.send(msg);
            // 输出发送结果
            System.out.printf("Message sent: %s%n", sendResult.getSendStatus());
        } catch (Exception e) {
            // 输出异常信息
            System.err.println("Exception occurred during message sending: " + e.getMessage());
        } finally {
            // 关闭生产者
            producer.shutdown();
        }
    }
}

问题2：消费者接收消息失败

消费者接收消息失败可能是因为网络问题、配置错误或消息不存在等原因。以下是一些解决办法：

解决办法

检查网络连接：
- 确保NameServer和Broker的网络连接正常。
- 使用ping命令检查NameServer和Broker的IP地址是否可以正常通信。
- 使用telnet命令检查NameServer和Broker的端口号是否开放。
确认配置正确：
- 检查消费者的setNamesrvAddr配置是否正确，确保NameServer地址设置正确。
- 检查消费者的subscribe方法是否正确订阅了指定的Topic和Tag。
检查消息是否存在：
- 确保在生产者发消息后，消费者能够接收到这些消息。
- 检查生产者发送的消息是否符合消费者的订阅条件。

示例代码

以下是一个检查消费者接收消息失败的示例代码：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;

public class ConsumerCheck {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("TestTopic", "TagA");
        // 设置从队列头部开始消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (org.apache.rocketmq.common.message.Message msg : msgs) {
                System.out.printf("Received message: %s%n", new String(msg.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("Consumer started.");
    }
}

问题3：消息丢失

消息丢失可能是因为网络中断、消息确认失败或消息被其他消费者处理等原因。以下是一些解决办法：

解决办法

检查网络连接：
- 确保生产者和消费者之间的网络连接正常。
- 使用ping命令检查生产者和消费者的IP地址是否可以正常通信。
- 使用telnet命令检查生产者和消费者的端口号是否开放。
确认消息确认机制：
- 消费者在处理完消息后，需要进行消息确认，以告知Broker消息已被成功消费。
- 如果消息未被确认，Broker会将消息重新放入队列中，以便其他消费者再次尝试处理。
检查消费者组配置：
- 确保消费者的消费者组配置正确，避免多个消费者处理同一消息。
- 使用RocketMQ的集群模型，确保每个消费者只会接收到一条消息。

示例代码

以下是一个检查消息丢失的示例代码：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;

public class ConfirmConsumerCheck {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConfirmConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("TestTopic", "TagA");
        // 设置从队列头部开始消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (org.apache.rocketmq.common.message.Message msg : msgs) {
                System.out.printf("Received message: %s%n", new String(msg.getBody()));
                // 消息处理完成后进行确认
                context.putMessage(msg, ConsumeOrderlyStatus.SUCCESS);
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("ConfirmConsumer started.");
    }
}

问题4：消费失败的消息重新发送

消费失败的消息需要重新发送，以确保消息能够被正确处理。以下是一些解决办法：

解决办法

检查异常处理机制：
- 在消息监听器中捕获异常，并进行相应的处理。
- 使用context.putMessage方法将异常消息放入失败队列，以便后续重试。
- 根据异常类型选择适当的重试策略，避免消息重复处理。
配置消息重试：
- 根据业务需求配置消息重试次数和间隔时间。
- 使用RocketMQ的consumer.properties文件配置消息重试参数，例如retryTimesWhenSendFailed和retryTimesWhenSendAsyncFailed。

示例代码

以下是一个检查消费失败并重新发送消息的示例代码：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;

public class RetryConsumerCheck {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("RetryConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("TestTopic", "TagA");
        // 设置从队列头部开始消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (org.apache.rocketmq.common.message.Message msg : msgs) {
                try {
                    System.out.printf("Received message: %s%n", new String(msg.getBody()));
                    // 模拟异常处理
                    if (new String(msg.getBody()).equals("ExceptionMessage")) {
                        throw new RuntimeException("Exception occurred during message processing.");
                    }
                } catch (Exception e) {
                    // 处理异常
                    System.err.println("Exception caught: " + e.getMessage());
                    // 将消息放入失败队列
                    context.putMessage(msg, ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT);
                }
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("RetryConsumer started.");
    }
}

问题5：消息堆积

消息堆积可能是因为消费者处理能力不足、网络延迟或消费者组配置不当等原因。以下是一些解决办法：

解决办法

增加消费者数量：
- 通过增加消费者数量来提高消息处理能力。
- 使用RocketMQ的集群模型，确保每个消费者只会接收到一条消息。
- 根据业务需求调整消费者数量，避免消费者过多导致资源浪费。
优化消息处理逻辑：
- 确保消息处理逻辑高效，避免不必要的耗时操作。
- 使用异步处理机制，提高消息处理速度。
调整消费者组配置：
- 根据业务需求调整消费者组配置，避免消费者处理能力过低。
- 使用RocketMQ的consumer.properties文件配置消费者组参数，例如pullBatchSize和pullInterval。

示例代码

以下是一个检查消息堆积的示例代码：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;

public class ConsumerGroupCheck {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("TestTopic", "TagA");
        // 设置从队列头部开始消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (org.apache.rocketmq.common.message.Message msg : msgs) {
                System.out.printf("Received message: %s%n", new String(msg.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("ConsumerGroup started.");
    }
}

通过以上常见问题及解决办法的介绍，可以更好地处理RocketMQ在实际使用中遇到的各种问题。在项目开发过程中，可以根据实际情况灵活应用这些解决办法，以确保RocketMQ系统的稳定性和可靠性。

Rocket消息队列实践案例分析

在实际项目中，RocketMQ可以应用于多种场景，例如实时数据处理、异步通信、分布式任务调度等。本节将通过几个具体的实践案例，介绍如何在实际项目中使用RocketMQ。

案例1：电商订单系统

在电商订单系统中，订单创建、支付、发货等操作会产生大量的订单信息，这些信息需要实时同步给多个服务，如库存系统、支付系统、物流系统等。使用RocketMQ可以实现订单信息在各个服务之间的异步通信，提高系统的响应速度和可用性。

订单创建

订单创建时，可以将订单信息发送到RocketMQ的某个Topic，例如OrderTopic，然后由相应的消费者接收并处理订单信息。

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class OrderProducer {
    public static void main(String[] args) throws Exception {
        // 创建生产者
        DefaultMQProducer producer = new DefaultMQProducer("OrderProducerGroup");
        // 设置NameServer地址
        producer.setNamesrvAddr("localhost:9876");
        // 启动生产者
        producer.start();
        // 创建消息
        Message msg = new Message("OrderTopic", // topic
                "OrderTag", // tag
                "Order12345".getBytes(RemotingHelper.DEFAULT_CHARSET), // body
                null // properties
        );
        // 发送消息
        SendResult sendResult = producer.send(msg);
        // 输出发送结果
        System.out.printf("Order sent: %s%n", sendResult);
        // 关闭生产者
        producer.shutdown();
    }
}

订单处理

订单创建后，需要将订单信息发送到相应的消费者，由消费者进行后续处理，例如库存扣减、支付确认、物流发货等。

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;

public class OrderConsumer {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("OrderConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("OrderTopic", "OrderTag");
        // 设置从队列头部开始消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (org.apache.rocketmq.common.message.Message msg : msgs) {
                String body = new String(msg.getBody());
                System.out.printf("Received order: %s%n", body);
                // 处理订单信息
                // ...
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("OrderConsumer started.");
    }
}

案例2：金融交易系统

在金融交易系统中，交易记录、账户变动等信息需要实时同步给多个服务，例如风控系统、审计系统、对账系统等。使用RocketMQ可以实现交易记录在各个服务之间的异步通信，确保交易信息的实时性和准确性。

交易记录

交易记录生成时，可以将交易信息发送到RocketMQ的某个Topic，例如TransactionTopic，然后由相应的消费者接收并处理交易信息。

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class TransactionProducer {
    public static void main(String[] args) throws Exception {
        // 创建生产者
        DefaultMQProducer producer = new DefaultMQProducer("TransactionProducerGroup");
        // 设置NameServer地址
        producer.setNamesrvAddr("localhost:9876");
        // 启动生产者
        producer.start();
        // 创建消息
        Message msg = new Message("TransactionTopic", // topic
                "TransactionTag", // tag
                "Transaction12345".getBytes(RemotingHelper.DEFAULT_CHARSET), // body
                null // properties
        );
        // 发送消息
        SendResult sendResult = producer.send(msg);
        // 输出发送结果
        System.out.printf("Transaction sent: %s%n", sendResult);
        // 关闭生产者
        producer.shutdown();
    }
}

交易处理

交易记录生成后，需要将交易信息发送到相应的消费者，由消费者进行后续处理，例如风控检查、审计记录、对账确认等。

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;

public class TransactionConsumer {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("TransactionConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("TransactionTopic", "TransactionTag");
        // 设置从队列头部开始消费
        consumer.setConsumeFromWhere(EndOffset.FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (org.apache.rocketmq.common.message.Message msg : msgs) {
                String body = new String(msg.getBody());
                System.out.printf("Received transaction: %s%n", body);
                // 处理交易信息
                // ...
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("TransactionConsumer started.");
    }
}

案例3：物联网设备监控系统

在物联网设备监控系统中，设备上报的传感器数据、设备状态等信息需要实时同步给多个服务，例如监控中心、告警系统、数据分析系统等。使用RocketMQ可以实现设备数据在各个服务之间的异步通信，确保数据的实时性和准确性。

设备数据上报

设备上报数据时，可以将设备数据发送到RocketMQ的某个Topic，例如DeviceTopic，然后由相应的消费者接收并处理设备数据。

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class DeviceProducer {
    public static void main(String[] args) throws Exception {
        // 创建生产者
        DefaultMQProducer producer = new DefaultMQProducer("DeviceProducerGroup");
        // 设置NameServer地址
        producer.setNamesrvAddr("localhost:9876");
        // 启动生产者
        producer.start();
        // 创建消息
        Message msg = new Message("DeviceTopic", // topic
                "DeviceTag", // tag
                "Device12345".getBytes(RemotingHelper.DEFAULT_CHARSET), // body
                null // properties
        );
        // 发送消息
        SendResult sendResult = producer.send(msg);
        // 输出发送结果
        System.out.printf("Device data sent: %s%n", sendResult);
        // 关闭生产者
        producer.shutdown();
    }
}

设备数据处理

设备数据上报后，需要将设备数据发送到相应的消费者，由消费者进行后续处理，例如实时监控、告警通知、数据分析等。

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;

public class DeviceConsumer {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("DeviceConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("DeviceTopic", "DeviceTag");
        // 设置从队列头部开始消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (org.apache.rocketmq.common.message.Message msg : msgs) {
                String body = new String(msg.getBody());
                System.out.printf("Received device data: %s%n", body);
                // 处理设备数据
                // ...
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("DeviceConsumer started.");
    }
}

案例4：日志收集系统

在日志收集系统中，日志文件需要从多个源实时收集并同步到集中式日志服务器，实现日志的统一管理和分析。使用RocketMQ可以实现日志文件在各个服务之间的异步通信，确保日志的实时性和完整性。

日志文件上报

日志文件上报时，可以将日志文件内容发送到RocketMQ的某个Topic，例如LogTopic，然后由相应的消费者接收并处理日志文件。

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class LogProducer {
    public static void main(String[] args) throws Exception {
        // 创建生产者
        DefaultMQProducer producer = new DefaultMQProducer("LogProducerGroup");
        // 设置NameServer地址
        producer.setNamesrvAddr("localhost:9876");
        // 启动生产者
        producer.start();
        // 创建消息
        Message msg = new Message("LogTopic", // topic
                "LogTag", // tag
                "Log12345".getBytes(RemotingHelper.DEFAULT_CHARSET), // body
                null // properties
        );
        // 发送消息
        SendResult sendResult = producer.send(msg);
        // 输出发送结果
        System.out.printf("Log sent: %s%n", sendResult);
        // 关闭生产者
        producer.shutdown();
    }
}

日志文件处理

日志文件上报后，需要将日志文件内容发送到相应的消费者，由消费者进行后续处理，例如日志归档、日志分析、日志监控等。

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;

public class LogConsumer {
    public static void main(String[] args) throws Exception {
        // 创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("LogConsumerGroup");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 订阅主题和Tag
        consumer.subscribe("LogTopic", "LogTag");
        // 设置从队列头部开始消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            for (org.apache.rocketmq.common.message.Message msg : msgs) {
                String body = new String(msg.getBody());
                System.out.printf("Received log: %s%n", body);
                // 处理日志文件
                // ...
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动消费者
        consumer.start();
        System.out.println("LogConsumer started.");
    }
}

通过以上案例分析，可以看到RocketMQ在实际项目中的广泛应用。在电商订单系统、金融交易系统、物联网设备监控系统和日志收集系统中，RocketMQ都能够实现异步通信和实时数据处理，提高系统的响应速度和可用性。在项目开发过程中，可以根据具体业务需求灵活使用RocketMQ的功能，以实现高效可靠的消息传递。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

哈士奇WWW

手记
篇

粉丝

71

获赞与收藏

400

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

Pandas 入门教程

25个小节 18499 337

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Rocket消息队列入门教程

安装与配置说明

环境变量配置

网络配置

防火墙配置

生产者（Producer）

生产者代码示例

消费者参数说明

消息（Message）

消息类型

消息发送与接收

主题（Topic）

主题命名规则

队列（Queue）

队列分配规则

标签（Tag）

标签命名规则

消息模型

消息过滤与路由

消息过滤示例

持久化和消息存储

消息持久化配置

消息顺序性

消息顺序性配置

多活机制

多活机制配置

消费者组（ConsumerGroup）

消费者组配置

消息发送

消息发送代码示例

消息发送参数说明

消息接收

消息接收代码示例

消息接收参数说明

消息确认

消息确认代码示例

消息确认参数说明

异常处理

异常处理代码示例

异常处理参数说明

问题1：生产者发送消息失败

解决办法

示例代码

问题2：消费者接收消息失败

解决办法

示例代码

问题3：消息丢失

解决办法

示例代码

问题4：消费失败的消息重新发送

解决办法

示例代码

问题5：消息堆积

解决办法

示例代码

案例1：电商订单系统

订单创建

订单处理

案例2：金融交易系统

交易记录

交易处理

案例3：物联网设备监控系统

设备数据上报

设备数据处理

案例4：日志收集系统

日志文件上报

日志文件处理

阅读免费教程