手写RocketMQ教程：入门与实践指南

本文详细介绍了手写RocketMQ教程，包括RocketMQ的基本概念、安装步骤、发送和接收消息的实现方法，以及消息模型和路由机制的详解。通过本文，读者可以全面掌握RocketMQ的手动配置和使用技巧。

RocketMQ是什么

RocketMQ是由阿里巴巴开源的一款高性能分布式消息中间件。它主要用来实现异步通信、解耦系统、流量削峰等场景。RocketMQ采用高可用设计，支持高并发的消息生产和消费，能够在大规模分布式环境中稳定运行。RocketMQ的核心组件包括NameServer、Broker、Producer和Consumer。其中，NameServer负责路由信息的广播，Broker负责消息存储和转发，Producer负责发送消息，Consumer负责消费消息。

RocketMQ的特点和优势

1. 高性能：RocketMQ支持每秒百万级的消息吞吐量，具有极高的并发处理能力。
2. 高可用性：RocketMQ通过集群和分布式部署，保证了系统的高可用性和稳定性。
3. 消息可靠传输：RocketMQ支持消息的顺序发送、幂等性消费以及消息重试机制，确保消息的可靠传输。
4. 灵活的消息模型：RocketMQ提供了多种消息模型，如发布订阅、点对点、广播等，适应不同业务场景的需求。
5. 消息过滤与消息重试：RocketMQ支持多种消息过滤策略，并且能够自动重试失败的消息。
6. 丰富的监控与管理：RocketMQ提供了详细的监控和管理接口，方便运维人员进行监控及故障排查。

RocketMQ的应用场景

RocketMQ适用于多种应用场景，包括但不限于：

1. 异步通信：通过消息队列实现服务间的异步通信，提高系统的响应速度和稳定性。
2. 流量削峰：在高并发场景下，使用消息队列来削峰填谷，避免瞬间的高负载对系统造成冲击。
3. 解耦系统：通过解耦生产者和消费者，实现应用之间的松耦合，提高系统的灵活性和可扩展性。
4. 可靠性保证：在分布式系统中使用消息队列来保证消息的可靠传输，避免数据丢失。
5. 数据分发与处理：将数据通过消息队列发送到多个消费者，实现数据的分布式处理。

准备环境

1. 操作系统：RocketMQ支持Linux和Windows系统，推荐在生产环境中使用Linux。本文基于Linux系统进行演示。
2. Java环境：RocketMQ运行需要Java环境，建议使用JDK 1.8或以上版本。
3. 磁盘空间：RocketMQ需要一定的磁盘空间来存储消息，建议至少有5GB以上的可用空间。
4. 网络环境：确保网络环境畅通，能够访问RocketMQ的官方网站以下载必要的文件。

创建Java项目

创建一个Java项目，引入RocketMQ的依赖。如果你使用Maven管理依赖，可以在pom.xml中添加以下依赖：

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.9.2</version>
</dependency>

下载与解压RocketMQ

1. 访问RocketMQ的官方网站或GitHub仓库，获取最新的RocketMQ版本。
2. 下载RocketMQ压缩包。例如，使用wget或curl命令下载：

   wget https://github.com/apache/rocketmq/releases/download/v4.9.2/rocketmq-all-4.9.2-bin-release.zip

3. 解压下载的压缩包：

   unzip rocketmq-all-4.9.2-bin-release.zip
   cd rocketmq-all-4.9.2

4. 进入解压后的目录，查看RocketMQ的启动脚本和配置文件：

   ls

   目录结构如下：

   bin        lib        NOTICE.md  README.md  scripts

启动RocketMQ服务

1. 启动NameServer：

   nohup sh bin/mqnamesrv &

   启动完成后，NameServer会在日志文件中打印启动成功的信息：

   The Name Server boot success. serializeType=JSON, listenPort=9876

2. 启动Broker：

   nohup sh bin/mqbroker -n localhost:9876 &

   启动完成后，Broker会在日志文件中打印启动成功的信息：

   The Broker boot success, serializeType=JSON, clusterName=DEFAULT, listenPort=10911, rpcPort=10912

3. 查看RocketMQ的服务是否正常启动：

   tail -f logs/last.log

   期望看到的信息如下：

   The Name Server boot success. serializeType=JSON, listenPort=9876
   ...
   The Broker boot success, serializeType=JSON, clusterName=DEFAULT, listenPort=10911, rpcPort=10912

创建发送端应用

创建一个Java项目，用于发送消息。如果使用Maven管理依赖，可以在pom.xml中添加以下依赖：

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.9.2</version>
</dependency>

创建一个主类Producer.java，用于发送消息。以下是一个简单的发送端示例代码：

import org.apache.rocketmq.client.producer.DefaultMQProducer;
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 {
        // 创建一个Producer实例
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");

        // 设置NameServer地址
        producer.setNamesrvAddr("localhost:9876");

        // 启动Producer实例
        producer.start();

        // 创建一个消息对象
        Message msg = new Message("TopicTest", // topic
                                  "TagA", // tag
                                  ("Hello RocketMQ").getBytes(RemotingHelper.DEFAULT_CHARSET)); // body

        // 发送消息
        producer.send(msg);

        // 等待发送完成
        Thread.sleep(1000);

        // 关闭Producer实例
        producer.shutdown();
    }
}

编写发送消息的代码

1. 初始化Producer实例：

   DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
   producer.setNamesrvAddr("localhost:9876");

2. 启动Producer实例：

   producer.start();

3. 创建消息对象：

   Message msg = new Message("TopicTest", // topic
                             "TagA", // tag
                             ("Hello RocketMQ").getBytes(RemotingHelper.DEFAULT_CHARSET)); // body

4. 发送消息：

   producer.send(msg);

5. 关闭Producer实例：

   producer.shutdown();

执行发送消息操作

1. 编译并运行Producer.java：

   javac -cp rocketmq-client-4.9.2.jar:. Producer.java
   java -cp rocketmq-client-4.9.2.jar:. Producer

2. 查看Broker日志文件，确认消息是否被成功接收：

   tail -f logs/broker.log

3. 期望看到的消息接收日志信息：

   [INFO] Message Received [Message{topic='TopicTest', body='Hello RocketMQ', properties={storeHost=127.0.0.1:10911, transactionId=, tags=TagA, keys=}, queueId=0, queueOffset=0, bornTimestamp=1681489707000, bornHost=/127.0.0.1, bornApp=ProducerGroupName, storeTimestamp=1681489707000, storeHost=/127.0.0.1:10911, size=14, offset=316128}]

创建接收端应用

创建一个Java项目，用于接收消息。如果使用Maven管理依赖，可以在pom.xml中添加以下依赖：

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.9.2</version>
</dependency>

创建一个主类Consumer.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 {
        // 创建一个Consumer实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");

        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");

        // 订阅指定topic和tag的消息
        consumer.subscribe("TopicTest", "TagA");

        // 设置从队列头部开始消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

        // 注册消息监听器
        consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
            msgs.forEach(msg -> {
                System.out.println("Received message: " + new String(msg.getBody()));
            });
            return ConsumeOrderlyStatus.SUCCESS;
        });

        // 启动Consumer实例
        consumer.start();

        // 等待消费完成
        Thread.sleep(10000);

        // 关闭Consumer实例
        consumer.shutdown();
    }
}

编写接收消息的代码

1. 初始化Consumer实例：

   DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
   consumer.setNamesrvAddr("localhost:9876");

2. 订阅指定topic和tag的消息：

   consumer.subscribe("TopicTest", "TagA");

3. 设置从队列头部开始消费：

   consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

4. 注册消息监听器：

   consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
      msgs.forEach(msg -> {
          System.out.println("Received message: " + new String(msg.getBody()));
      });
      return ConsumeOrderlyStatus.SUCCESS;
   });

5. 启动Consumer实例：

   consumer.start();

6. 关闭Consumer实例：

   consumer.shutdown();

执行接收消息操作

1. 编译并运行Consumer.java：

   javac -cp rocketmq-client-4.9.2.jar:. Consumer.java
   java -cp rocketmq-client-4.9.2.jar:. Consumer

2. 运行发送端的Producer.java，发送一条消息。

3. 查看接收端的日志输出，确认消息是否被成功接收：

   Received message: Hello RocketMQ

RocketMQ的消息模型详解

RocketMQ支持多种消息模型，包括发布订阅模型和点对点模型。

1. 发布订阅模型：

   • 发布者：发布消息到特定的Topic。
   • 订阅者：订阅指定的Topic和Tag，接收匹配的消息。
   • 实现方式：通过subscribe方法订阅消息，consumeMessage方法消费消息。
2. 点对点模型：
   • 队列：消息被发送到一个队列中。
   • 消息消费：一个消费者从队列中消费消息，保证消息不会被重复消费。
   • 实现方式：通过pullMessage方法从队列中拉取消息，ackMessage方法确认消息已消费。

消息路由的原理与实现

1. 路由表：

   • RocketMQ维护一个路由表，记录了每个Topic所对应的所有Broker的信息。
   • 路由表由NameServer维护，每个Broker定时向NameServer上报自己的路由信息。

2. 路由更新：

   • 当Broker启动或停止时，会向NameServer上报自己的路由信息。
   • NameServer更新路由表，并将更新后的路由信息广播给所有订阅了该Topic的Producer和Consumer。
3. 路由匹配：
   • Producer在发送消息时，根据消息的Topic和Tag信息，查询路由表，找到对应的Broker。
   • Consumer在消费消息时，根据订阅的Topic和Tag信息，查询路由表，找到对应的Broker。

动手实践消息路由

1. 创建一个新的Topic：

   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 TopicManager {
      public static void main(String[] args) throws Exception {
          DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
          producer.setNamesrvAddr("localhost:9876");
          producer.start();
   
          // 创建一个新的Topic
          Message msg = new Message("NewTopic", // topic
                                    "TagA", // tag
                                    ("Hello NewTopic").getBytes(RemotingHelper.DEFAULT_CHARSET)); // body
          SendResult result = producer.send(msg);
   
          // 关闭Producer实例
          producer.shutdown();
      }
   }

2. 查看NameServer和Broker的日志，确认新的Topic是否被创建成功：

   tail -f logs/NameServer.log
   tail -f logs/broker.log

3. 创建一个新的Consumer订阅新的Topic：

   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 NewConsumer {
      public static void main(String[] args) throws Exception {
          DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
          consumer.setNamesrvAddr("localhost:9876");
          consumer.subscribe("NewTopic", "TagA");
          consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
          consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
              msgs.forEach(msg -> {
                  System.out.println("Received new message: " + new String(msg.getBody()));
              });
              return ConsumeOrderlyStatus.SUCCESS;
          });
          consumer.start();
          Thread.sleep(10000);
          consumer.shutdown();
      }
   }

4. 运行新的Producer发送一条消息到NewTopic：

   javac -cp rocketmq-client-4.9.2.jar:. TopicManager.java
   java -cp rocketmq-client-4.9.2.jar:. TopicManager

5. 运行新的Consumer接收消息：

   javac -cp rocketmq-client-4.9.2.jar:. NewConsumer.java
   java -cp rocketmq-client-4.9.2.jar:. NewConsumer

6. 查看Consumer的日志输出，确认消息是否被成功接收：

   Received new message: Hello NewTopic

常见错误及解决方法

1. NameServer启动失败：

   • 检查NameServer的日志文件，查看是否有详细的错误信息。
   • 确认NameServer的启动命令是否正确。
   • 检查网络是否畅通，确保NameServer能够访问到其他网络资源。

2. Broker启动失败：

   • 检查Broker的日志文件，查看是否有详细的错误信息。
   • 检查Broker的启动命令是否正确。
   • 确认磁盘空间是否足够，Broker需要一定的磁盘空间来存储消息。
   • 检查JDK版本是否兼容。

3. 消息发送失败：

   • 检查Producer的日志文件，查看是否有详细的错误信息。
   • 确认Producer的配置是否正确，包括NameServer地址、Topic名称等。
   • 检查网络是否畅通，确保Producer能够连接到NameServer和Broker。
4. 消息接收失败：
   • 检查Consumer的日志文件，查看是否有详细的错误信息。
   • 确认Consumer的配置是否正确，包括NameServer地址、订阅的Topic和Tag等。
   • 检查网络是否畅通，确保Consumer能够连接到NameServer和Broker。

性能优化建议

1. 集群部署：

   • 使用多个Broker和NameServer节点进行集群部署，提高系统的可用性和性能。
   • 多个Broker节点可以分散消息负载，避免单点故障。
   • 多个NameServer节点可以提供高可用的服务，避免单点故障。

2. 负载均衡：

   • 使用负载均衡器（如Nginx或HAProxy）来分发消息请求到不同的Broker节点。
   • 配置负载均衡器的策略，如轮询、最少连接等，使消息请求均匀地分配到各个节点。

3. 磁盘优化：

   • 确保Broker节点的磁盘空间足够，避免因磁盘空间不足导致消息无法存储。
   • 配置Broker的磁盘空间阈值，当磁盘空间达到一定比例时，自动触发清理操作，释放磁盘空间。

4. 消息压缩：

   • 对发送的消息进行压缩，减少网络传输的数据量，提高传输效率。
   • 使用消息压缩算法（如GZIP、Snappy等），在消息发送和接收时进行压缩和解压缩。
5. 消息积压：
   • 配置消息积压策略，当消息积压达到一定数量时，自动触发消息重试机制。
   • 配置消息积压阈值，当积压的消息达到一定数量时，自动触发警告机制，通知运维人员进行干预。

日志分析与问题排查

1. 日志文件位置：

   • NameServer的日志文件位于logs/NameServer.log。
   • Broker的日志文件位于logs/broker.log。
   • Producer和Consumer的日志文件位于各自的日志配置文件中。

2. 日志文件内容：

   • 日志文件中记录了RocketMQ各个组件的运行状态和错误信息。
   • 日志文件中的错误信息通常包含了详细的错误代码和描述，可以根据错误代码在网上查找对应的解决方案。

3. 排查步骤：

   • 检查NameServer的日志文件，查看是否有NameServer启动失败的错误信息。
   • 检查Broker的日志文件，查看是否有Broker启动失败的错误信息。
   • 检查Producer的日志文件，查看是否有消息发送失败的错误信息。
   • 检查Consumer的日志文件，查看是否有消息接收失败的错误信息。
   • 根据错误信息中的错误代码和描述，查找对应的解决方案。
   • 如果无法解决，可以访问RocketMQ的官方论坛或GitHub仓库，寻求社区的帮助。
4. 注意事项：
   • 日志文件中的错误信息需要仔细阅读，不要忽略任何细节。
   • 如果日志文件中的错误信息不清楚，可以尝试搜索错误代码或描述，查找更多相关信息。
   • 如果日志文件中的错误信息仍然无法解决问题，可以尝试联系RocketMQ的社区或技术支持，获取帮助。