手写RocketMQ资料：入门级教程详解

概述

手写RocketMQ资料详细介绍了RocketMQ的安装、配置、生产和消费消息的过程，以及集群部署的方法。文章涵盖了从环境准备到启动RocketMQ服务的各项步骤，帮助读者全面了解RocketMQ的使用方法。

RocketMQ简介 RocketMQ的基本概念

RocketMQ 是一款由阿里巴巴开源并贡献给 Apache 社区的分布式消息中间件。它主要被设计用于大规模分布式系统中，以满足高性能、高吞吐量、高可用性的需求。RocketMQ 基于 Java 语言开发，支持多种消息类型，包括同步消息、异步消息、单向消息等。它具有强大的消息堆积能力，能够在网络状况不佳时暂时缓存消息，待网络恢复后继续发送，从而保证消息不丢失。

RocketMQ的特点与优势

RocketMQ 具有以下特点与优势：

• 高吞吐量：RocketMQ 的设计架构允许每秒钟发送数百万条消息，具备极高的消息吞吐量。
• 高可用性：通过集群部署，RocketMQ 可以实现数据的多副本存储，从而确保系统的高可用性。
• 消息堆积能力：在消息发送方与接收方网络不稳定的情况下，RocketMQ 可以暂时将消息堆积在消息队列中，待网络恢复后再进行发送。
• 多种消息模式：RocketMQ 支持同步、异步、单向等多种消息模式，满足不同场景的需求。
• 灵活的消息路由：RocketMQ 提供了灵活的消息路由机制，可以实现消息的精准推送和负载均衡。
• 消息过滤与重试机制：RocketMQ 支持消息过滤和消息重试机制，保证消息的可靠性和最终一致性。

RocketMQ的应用场景

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

• 电商系统：如订单系统、支付系统、物流系统等，可以利用 RocketMQ 实现消息的异步处理和削峰填谷。
• 金融系统：金融系统要求高可用性和数据一致性，RocketMQ 可以满足这些需求。
• 物联网（IoT）系统：在 IoT 系统中，需要处理大量的传感器数据，RocketMQ 可以作为消息中间件来支持大规模数据的传输和处理。
• 日志收集与处理：RocketMQ 可以用来收集系统日志，然后通过消息队列将日志发送到后台处理系统，实现日志的集中存储和分析。
• 实时数据处理：RocketMQ 可以作为实时数据处理系统的一部分，与大数据处理框架配合使用，如 Spark Streaming、Flink 等。

安装与配置RocketMQ 安装环境准备

在安装RocketMQ之前，需要确保环境满足以下条件：

• 操作系统：RocketMQ支持多种操作系统，如Linux、Windows等，推荐使用Linux环境进行部署。
• Java环境：RocketMQ需要运行在Java环境中，建议使用Java 8及以上版本。
• 硬件资源：根据实际需求，适当调整CPU、内存和磁盘空间。

下载与解压RocketMQ

1. 访问官方下载页面，选择适合的版本。
2. 下载完成后，使用tar命令解压文件包，命令如下：

   tar -zxvf rocketmq-all-4.9.10-bin-release.tar.gz

配置RocketMQ

RocketMQ的配置文件主要位于conf目录下，包括broker.properties、logback.xml、server.properties等。

broker.properties 文件

配置文件broker.properties是Broker的配置文件，用于设置Broker的运行参数。例如：

brokerName=broker-a
brokerId=0
brokerClusterName=myCluster
namesrvAddr=127.0.0.1:9876

• brokerName：Broker的名称
• brokerId：Broker的ID，集群部署时需要设置为不同的值
• brokerClusterName：Broker所属的集群名称
• namesrvAddr：NameServer地址

logback.xml 文件

logback.xml文件用于配置RocketMQ的日志输出。例如：

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

server.properties 文件

server.properties文件用于配置NameServer的运行参数。例如：

# 指定NameServer端口，默认为9876
port=9876

启动RocketMQ服务

启动RocketMQ服务需要先启动NameServer，然后启动Broker。以下是启动步骤：

1. 启动NameServer：

   nohup sh bin/mqnamesrv &

2. 启动Broker：

   nohup sh bin/mqbroker -n 127.0.0.1:9876 -c ~/rocketmq-all-4.9.10/conf/broker.properties &

通过上述步骤，RocketMQ的安装与配置就完成了。

手写RocketMQ生产者 创建生产者实例

生产者实例用于向消息队列发送消息。下面是一个简单的生产者实例的代码示例：

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.common.protocol.heartbeat.MessageModel;

public class Producer {
    public static void main(String[] args) throws Exception {
        // 创建生产者实例
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");

        // 设置生产者的名字服务地址
        producer.setNamesrvAddr("127.0.0.1:9876");

        // 启动生产者实例
        producer.start();

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

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

        // 打印结果
        System.out.println(sendResult);

        // 关闭生产者实例
        producer.shutdown();
    }
}

发送同步消息

同步消息是指消息发送方在发送消息后会等待消息的成功或失败确认。以下是发送同步消息的代码示例：

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

public class SyncProducer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        producer.setNamesrvAddr("127.0.0.1:9876");
        producer.start();

        Message msg = new Message("TopicTest", "TagA", "OrderID188", ("Hello RocketMQ.").getBytes());
        SendResult sendResult = producer.send(msg);

        if (sendResult.getSendStatus() == SendStatus.SEND_OK) {
            System.out.println("消息发送成功");
        } else {
            System.out.println("消息发送失败");
        }

        producer.shutdown();
    }
}

发送异步消息

异步消息是指消息发送方在发送消息后不会等待消息的成功或失败确认，而是通过回调函数来处理结果。以下是发送异步消息的代码示例：

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

public class AsyncProducer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        producer.setNamesrvAddr("127.0.0.1:9876");
        producer.start();

        producer.send(new Message("TopicTest", "TagA", "OrderID188", ("Hello RocketMQ.").getBytes()), new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                System.out.println("消息发送成功");
            }

            @Override
            public void onException(Throwable e) {
                System.out.println("消息发送失败");
            }
        });

        producer.shutdown();
    }
}

发送单向消息

单向消息是指消息发送方在发送消息后不会等待任何确认，适用于不需要接收方确认的消息场景。以下是发送单向消息的代码示例：

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.common.protocol.heartbeat.MessageModel;

public class OneWayProducer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        producer.setNamesrvAddr("127.0.0.1:9876");
        producer.start();

        producer.sendOneway(new Message("TopicTest", "TagA", "OrderID188", ("Hello RocketMQ.").getBytes()));

        producer.shutdown();
    }
}

手写RocketMQ消费者 创建消费者实例

消费者实例用于从消息队列中接收并处理消息。下面是一个简单的消费者实例的代码示例：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;
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("ConsumerGroupName");

        // 设置消费者的名字服务地址
        consumer.setNamesrvAddr("127.0.0.1:9876");

        // 设置消费者从何处开始消费消息
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);

        // 订阅主题和标签
        consumer.subscribe("TopicTest", "TagA");

        // 注册消息消费监听器
        consumer.registerMessageListener(message -> {
            // 处理消息
            System.out.println("接收到消息： " + new String(message.getBody()));
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        });

        // 启动消费者实例
        consumer.start();
    }
}

接收消息

消费者通过消息监听器来接收和处理消息。这是消息监听器的代码示例：

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.message.MessageExt;

public class MessageListener implements MessageListenerOrderly {
    @Override
    public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
        for (MessageExt msg : msgs) {
            System.out.println("接收到消息：" + new String(msg.getBody()));
        }
        return ConsumeOrderlyStatus.SUCCESS;
    }
}

处理异常情况

在消费者中，需要处理各种异常情况，如消息处理失败、网络中断等。这是异常处理的代码示例：

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.message.MessageExt;

public class MessageListener implements MessageListenerOrderly {
    @Override
    public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
        for (MessageExt msg : msgs) {
            try {
                System.out.println("接收到消息：" + new String(msg.getBody()));
            } catch (Exception e) {
                System.out.println("消息处理失败");
                return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
            }
        }
        return ConsumeOrderlyStatus.SUCCESS;
    }
}

消息过滤与重试机制

消息过滤

消息过滤是通过设置消息过滤器来决定是否接收某条消息。这是消息过滤的代码示例：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;

public class FilteredConsumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        consumer.setNamesrvAddr("127.0.0.1:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
        consumer.subscribe("TopicTest", "TagA");
        consumer.setMessageModel(MessageModel.CLUSTERING);
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt msg : msgs) {
                if (msg.getTag().equals("TagA")) {
                    System.out.println("接收消息：" + new String(msg.getBody()));
                }
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        consumer.start();
    }
}

重试机制

RocketMQ 提供了消息重试机制，可以在消息处理失败后自动重试。这是重试机制的代码示例：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;

public class RetryConsumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        consumer.setNamesrvAddr("127.0.0.1:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
        consumer.setMessageModel(MessageModel.CLUSTERING);
        consumer.subscribe("TopicTest", "TagA");
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt msg : msgs) {
                try {
                    System.out.println("接收到消息：" + new String(msg.getBody()));
                    // 模拟消息处理失败
                    throw new RuntimeException("模拟消息处理失败");
                } catch (Exception e) {
                    System.out.println("消息处理失败，将重试");
                    return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
                }
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        consumer.start();
    }
}

RocketMQ集群部署 集群部署的基本概念

RocketMQ的集群部署主要分为NameServer和Broker两个部分。NameServer作为名字服务器，负责维护Broker的路由信息；Broker是实际的消息存储节点，负责消息的发送与接收。

集群部署可以实现消息的高可用性，避免单点故障。通过配置多台Broker，可以实现消息的冗余存储和负载均衡，提高系统的稳定性和性能。

NameServer与Broker的角色

• NameServer：NameServer主要负责维护Broker的路由信息，并将这些信息推送给客户端，使客户端能够找到合适的Broker执行消息发送与接收操作。
• Broker：Broker是消息存储节点，负责接收客户端发送过来的消息，并将消息存储在本地磁盘上。同时，Broker还负责将消息推送给消费者。

搭建RocketMQ集群

搭建RocketMQ集群需要多台机器，每台机器上都需要安装并配置RocketMQ。以下是集群搭建的步骤：

1. 安装RocketMQ：在每台机器上安装RocketMQ。
2. 配置NameServer：在配置文件server.properties中设置NameServer的端口和地址。
3. 配置Broker：在配置文件broker.properties中设置Broker的名称、ID、集群名称等。
4. 启动NameServer：在每台机器上启动NameServer。
5. 启动Broker：在每台机器上启动Broker，并指定NameServer地址。

配置示例

假设我们有两台机器，IP地址分别为192.168.1.1和192.168.1.2。在每台机器上进行如下配置：

NameServer配置

在server.properties文件中设置端口：

port=9876

启动NameServer：

nohup sh bin/mqnamesrv &

Broker配置

在broker.properties文件中设置Broker的信息：

brokerName=broker-a
brokerId=0
brokerClusterName=myCluster
namesrvAddr=192.168.1.1:9876,192.168.1.2:9876

启动Broker：

nohup sh bin/mqbroker -n 192.168.1.1:9876,192.168.1.2:9876 -c ~/rocketmq-all-4.9.10/conf/broker.properties &

测试集群部署

在一台机器上启动生产者，发送消息；在另一台机器上启动消费者，接收消息。通过这种方式，可以测试集群部署的正确性。

集群部署的常见问题及解决方案

1. NameServer启动失败：检查NameServer的配置文件是否正确，端口是否被占用。
2. Broker启动失败：检查Broker的配置文件是否正确，NameServer地址是否正确。
3. 网络不通：检查机器之间的网络连接是否正常。
4. 消息丢失：检查Broker的配置文件，确保消息的持久化设置正确。

常见问题与调试 常见问题解析

1. 消息发送失败：检查生产者和NameServer、Broker的网络连接是否正常。
2. 消息接收失败：检查消费者和NameServer、Broker的网络连接是否正常。
3. 消息堆积：检查Broker的磁盘空间是否充足，网络带宽是否足够。

日志文件解读

RocketMQ的日志文件主要位于logs目录下，包括consumer.log、producer.log、broker.log、namesrv.log等。

• consumer.log：记录消费者实例的日志信息。
• producer.log：记录生产者实例的日志信息。
• broker.log：记录Broker实例的日志信息。
• namesrv.log：记录NameServer实例的日志信息。

通过查看日志文件，可以了解RocketMQ的运行状态，排查问题。

调试与优化技巧

1. 监控与报警：可以使用监控工具，如Zabbix、Prometheus等，监控RocketMQ的运行状态，并设置报警规则。
2. 日志分析：定期分析日志文件，找出潜在的问题。
3. 网络优化：优化网络配置，提高网络带宽和稳定性。
4. 硬件资源调整：根据实际负载，调整CPU、内存和磁盘资源。

通过上述调试和优化技巧，可以提高RocketMQ的运行效率和稳定性。

总结

通过以上内容，我们详细了解了RocketMQ的基本概念、特点与优势，以及安装与配置的步骤。同时，我们也学习了如何编写RocketMQ的生产者和消费者实例，以及如何进行集群部署和常见问题的解决。RocketMQ是一款强大的分布式消息中间件，能够满足大规模分布式系统的消息处理需求。希望本文能帮助你更好地理解和使用RocketMQ。