首页手记手写rocketMQ入门：从零开始搭建与使用指南

手写rocketMQ入门：从零开始搭建与使用指南

标签：

Java 大数据中间件

概述

本文详细介绍了手写RocketMQ入门的相关内容，涵盖了RocketMQ的基本概念、环境搭建、快速入门实例以及手写代码示例。通过本文的学习，读者可以快速掌握RocketMQ的使用方法，为实际项目中的应用打下坚实基础。手写RocketMQ入门教程帮助读者理解RocketMQ的核心功能和应用场景。

RocketMQ简介与环境搭建

RocketMQ是什么

RocketMQ是由阿里集团开源的一个分布式消息中间件，它基于高可用设计原则，使用了发布/订阅模式，支持多种消息类型，适用于大流量、高并发的场景。RocketMQ提供了丰富的功能，包括消息的发布、订阅、过滤、排序、重试等，可以满足不同业务需求。

学习RocketMQ的意义

学习RocketMQ可以帮助你掌握分布式系统中的消息通信技术，提高系统的可靠性和可扩展性。RocketMQ在阿里云等大型互联网平台上有广泛的应用，掌握了它，可以增强你的技术竞争力，适应当今分布式系统的需求。

开发环境搭建

安装Java环境

确保你的系统上已经安装了Java环境，建议版本为Java 8或以上。可以通过以下命令检查Java版本：

java -version

下载RocketMQ

访问RocketMQ的GitHub仓库下载源码或二进制发布包。
解压下载的文件，将解压后的文件夹添加到系统环境变量中。

启动RocketMQ

进入RocketMQ的bin目录，运行如下命令启动Name Server：

nohup sh mqnamesrv &

启动Broker时，需要指定配置文件。通常，配置文件位于conf目录下，包括broker-a.properties和broker-b.properties。运行如下命令启动Broker：

nohup sh mqbroker -c ~/rocketmq-all/conf/broker-a.properties &

验证安装

启动完成后，可以在Name Server的log文件中查看启动日志，确保Name Server和Broker成功启动。

tail -f ~/rocketmq-4.6.0/logs/rocketmqlogs/NameServer/log.*

快速入门实例

发布消息

首先，编写一个简单的Java程序来发布消息。创建一个Java项目，并添加RocketMQ的依赖。

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

编写发布消息的代码：

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

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

        Message msg = new Message("TopicTest", // topic
                "TagA", // tag
                "Hello World".getBytes(RemotingHelper.DEFAULT_CHARSET)); // body
        SendResult sendResult = producer.send(msg);
        System.out.printf("%s%n", sendResult);
        producer.shutdown();
    }
}

接收消息

接下来编写一个简单的Java程序来接收消息。同样，创建一个Java项目，并添加RocketMQ的依赖。

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

编写接收消息的代码：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderedSuccess;
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("ConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("TopicTest", "*");
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt msg : msgs) {
                System.out.printf("%s%n", msg);
            }
            return ConsumeOrderedSuccess;
        });
        consumer.start();
    }
}

运行程序

启动消费端，然后启动生产端，观察控制台输出，确保消息已被成功接收。

RocketMQ核心概念

消息模型

RocketMQ的消息模型包括发布/订阅模型、顺序消息模型和广播消息模型。发布/订阅模型是最基本的消息模型，消息生产者向指定的Topic发送消息，消息消费者通过订阅Topic接收消息。

发布/订阅模型

在发布/订阅模型中，生产者将消息发送到指定的Topic，消费者通过订阅该Topic来接收消息。

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

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

        Message msg = new Message("TopicTest", // topic
                "TagA", // tag
                "Hello World".getBytes(RemotingHelper.DEFAULT_CHARSET)); // body
        SendResult sendResult = producer.send(msg);
        System.out.printf("%s%n", sendResult);
        producer.shutdown();
    }
}

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderedSuccess;
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("ConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("TopicTest", "*");
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt msg : msgs) {
                System.out.printf("%s%n", msg);
            }
            return ConsumeOrderedSuccess;
        });
        consumer.start();
    }
}

名词解释

Broker：RocketMQ的消息代理，负责消息的存储、转发等工作。
Name Server：提供名称服务，用于路由消息，它不存储消息，只是一个路由信息的服务。
Topic：消息分类的逻辑标识符，消息按Topic分类。
Message：消息类型，包含消息体、键、标记等。
Consumer：消息消费者，用于接收和处理消息。
Producer：消息生产者，用于发送消息到指定的Topic。
Message Queue：消息队列，每种类型的Topic都有一个或多个消息队列，消息发送到消息队列中，消费者从消息队列中拉取消息。
Cluster：集群，通常指由多个Broker组成的集群，提供高可用性。
Transaction Message：事务消息，保证消息的可靠传输，只有事务完整提交后消息才会被消费者接收到。

消息发送与接收流程

发送流程

Producer连接到Name Server，获取Broker地址。
Producer将消息发送到指定的Broker。
Broker将消息写入到消息队列。
Broker返回消息发送结果给Producer。

接收流程

Consumer连接到Name Server，获取Broker地址。
Consumer从Broker拉取消息。
Broker返回消息队列中的消息给Consumer。
Consumer处理接收到的消息。

手写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.remoting.common.RemotingHelper;

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

        Message msg = new Message("TopicTest", // topic
                "TagA", // tag
                "Hello World".getBytes(RemotingHelper.DEFAULT_CHARSET)); // body
        SendResult sendResult = producer.send(msg);
        System.out.printf("%s%n", sendResult);
        producer.shutdown();
    }
}

消息接收的代码实现

下面是一个简单的消息接收示例：

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderedSuccess;
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.remoting.common.RemotingHelper;

public class Consumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("TopicTest", "*");
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt msg : msgs) {
                System.out.printf("%s%n", msg);
            }
            return ConsumeOrderedSuccess;
        });
        consumer.start();
    }
}

异步消息处理

RocketMQ支持异步消息处理，下面是一个异步消息处理的示例：

import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderedSuccess;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class AsyncConsumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("TopicTest", "*");

        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt msg : msgs) {
                System.out.printf("%s%n", msg);
            }
            return ConsumeOrderedSuccess;
        });

        consumer.setMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.printf("%s%n", msg);
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        consumer.start();
    }
}

RocketMQ配置与调优

配置文件解析

RocketMQ的配置文件主要位于conf目录下，包括broker-a.properties、broker-b.properties、server.properties等。这些配置文件中包含了RocketMQ运行时的各种参数。

broker-a.properties

brokerClusterName=DefaultCluster
brokerName=broker-a
brokerId=0
brokerRole=ASYNC_MASTER
flushDiskType=ASYNC_FLUSH
storePathRootDir=/home/rocketmq/store
storePathCommitLog=/home/rocketmq/store/commitlog
storePathConsumeQueue=/home/rocketmq/store/consumequeue
storePathIndex=/home/rocketmq/store/index
storePathCommitLog=/home/rocketmq/store/commitlog
storePathIndex=/home/rocketmq/store/index
storePathMessageIndex=/home/rocketmq/store/messageindex
maxMessageSize=4194304

server.properties

logFile=logs/rocketmqlogs/rocketmq.log
logDir=/home/rocketmq/logs
deleteWhen=0
fileReservedDays=14
brokerPermission=READWRITE

常见参数调优方法

ConcurrentMessageMaxSize：消息队列中最大消息数。
MaxMessageSize：单条消息的最大大小。
CommitLogFileSize：CommitLog文件大小。
ConsumeQueueFileNums：每个Topic在磁盘上保存的ConsumeQueue文件数量。
ConsumeQueueMapedFileSize：每个ConsumeQueue文件的大小。

示例调优

# broker-a.properties
ConcurrentMessageMaxSize=10000
MaxMessageSize=1024
CommitLogFileSize=32M
ConsumeQueueFileNums=10
ConsumeQueueMapedFileSize=16M

性能优化技巧

增加Broker节点：通过增加Broker节点数量来提高系统的可用性和吞吐量。
使用分区：合理设置Topic的分区数量，以达到更好的负载均衡。
减少网络延迟：优化网络环境，减少网络延迟。
增加磁盘I/O性能：使用高速磁盘，提高磁盘读写速度。
异步模式：使用异步模式发送和接收消息，可以提高系统的性能。

RocketMQ常见问题与解决方案

常见错误及解决办法

连接超时：检查Name Server和Broker是否正常运行，确保网络通畅。
消息丢失：检查消息发送和接收的配置，确保消息的可靠传输。
消息积压：增加消费者数量，调整消费者配置，优化消息处理逻辑。
性能瓶颈：调整RocketMQ的配置，优化网络环境，提高硬件性能。

示例错误解决

[ERROR] org.apache.rocketmq.store.MessageStore - [Broker-1000] SELECT_MAPEDFILE_ERROR, broker=Broker-1000, topic=TopicTest, queueId=0, selectResult=false, maxPhyOffset=0, minPhyOffset=0, startPhyOffset=0, startLogSize=0, endPhyOffset=0, endLogSize=0, fileStore=file:/home/rocketmq/store/commitlog/00000000000000000000000000000000.mq

解决方法：检查磁盘空间是否充足，确保磁盘I/O性能良好。

日志分析与异常处理

RocketMQ提供了详细的日志记录，包括运行日志、异常日志等。通过分析日志，可以定位问题原因，进行故障排除。

日志分析示例

[INFO] org.apache.rocketmq.broker.BrokerRunServerThread - [Broker-1000] Run server on Broker(127.0.0.1:10911) success.
[WARN] org.apache.rocketmq.broker.BrokerRunServerThread - [Broker-1000] Receive a message with an unknown body format.

从日志中可以看出，消息体格式未知，需要检查消息体是否符合规定格式。

异常处理示例

try {
    // 发送消息
    SendResult sendResult = producer.send(msg);
} catch (Exception e) {
    // 捕获异常并处理
    logger.error("Failed to send message", e);
}

集群部署与维护

部署RocketMQ集群需要配置多个Broker节点，确保集群的高可用性。维护RocketMQ集群需要定期检查集群状态，调整配置参数，确保集群稳定运行。

集群部署示例

# broker-a.properties
brokerClusterName=ClusterA
brokerName=broker-a
brokerId=0
brokerRole=ASYNC_MASTER

# broker-b.properties
brokerClusterName=ClusterA
brokerName=broker-b
brokerId=1
brokerRole=SLAVE

集群维护示例

# 检查集群状态
sh mqadmin clusterList -n localhost:9876

# 检查Broker状态
sh mqadmin brokerList -n localhost:9876

RocketMQ应用场景与案例分享

RocketMQ在实际项目中的应用

RocketMQ广泛应用于分布式系统中，特别是在高并发、大数据量的场景下。它可以提供可靠的消息传输、负载均衡、容错等功能，满足各种业务需求。

案例分析与经验分享

案例一：电商订单系统

在电商订单系统中，使用RocketMQ进行订单消息的传输，确保订单状态的实时更新。当用户下单时，订单消息会被发送到RocketMQ，然后通过订阅该Topic的消费者处理订单信息。

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

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

        Message msg = new Message("OrderTopic", // topic
                "OrderTag", // tag
                "Order Information".getBytes(RemotingHelper.DEFAULT_CHARSET)); // body
        SendResult sendResult = producer.send(msg);
        System.out.printf("%s%n", sendResult);
        producer.shutdown();
    }
}

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderedSuccess;
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("OrderConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("OrderTopic", "*");
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt msg : msgs) {
                System.out.printf("%s%n", msg);
            }
            return ConsumeOrderedSuccess;
        });
        consumer.start();
    }
}

案例二：金融交易系统

在金融交易系统中，RocketMQ用于实时处理交易消息，确保交易操作的可靠性和一致性。通过配置事务消息，确保交易操作的回滚和提交。

import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.client.producer.TransactionSendResult;
import org.apache.rocketmq.common.message.Message;

public class TransactionProducer {
    public static void main(String[] args) throws Exception {
        TransactionMQProducer producer = new TransactionMQProducer("TransactionProducerGroupName");
        producer.setNamesrvAddr("localhost:9876");
        producer.setTransactionListener(new TransactionListener() {
            @Override
            public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
                // 执行本地事务逻辑
                return LocalTransactionState.COMMIT_MESSAGE;
            }

            @Override
            public LocalTransactionState checkLocalTransaction(Message msg) {
                // 检查本地事务状态
                return LocalTransactionState.COMMIT_MESSAGE;
            }
        });
        producer.start();

        Message msg = new Message("TransactionTopic", // topic
                "TransactionTag", // tag
                "Transaction Information".getBytes(RemotingHelper.DEFAULT_CHARSET)); // body
        TransactionSendResult sendResult = producer.send(msg);
        System.out.printf("%s%n", sendResult);
        producer.shutdown();
    }
}

案例三：实时日志分析

在实时日志分析系统中，RocketMQ用于传输日志消息，保证日志数据的实时处理。通过设置多个消费者，可以实现日志数据的并行处理。

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderedSuccess;
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("LogConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("LogTopic", "*");
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt msg : msgs) {
                System.out.printf("%s%n", msg);
            }
            return ConsumeOrderedSuccess;
        });
        consumer.start();
    }
}

未来发展方向展望

未来，RocketMQ将继续优化其性能和可靠性，支持更多高级特性，如分布式事务、消息追踪等。同时，RocketMQ将进一步加强与云平台的集成，提供更丰富的云服务。随着分布式系统的不断发展，RocketMQ将成为更多企业级应用的选择。

示例：未来发展方向

分布式事务：提供更强大的分布式事务支持，确保分布式系统中的数据一致性和事务完整性。
消息追踪：提供消息的全链路追踪功能，帮助用户快速定位问题。
云原生集成：更好地与Kubernetes等云原生技术集成，提供更灵活的部署方式。

以上是RocketMQ入门的详细指南，通过本文的学习，你可以快速掌握RocketMQ的基本使用方法，为实际项目中使用RocketMQ打下坚实的基础。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

MM们

手记
篇

粉丝

4

获赞与收藏

14

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340924 3155

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空