Rocketmq初识资料：新手入门教程

概述

RocketMQ 初识资料介绍了RocketMQ这款高性能、高可用的消息中间件的基本概念和特点，包括其在分布式系统中的应用场景，如异步解耦、流量削峰和数据同步。文章详细讲解了RocketMQ的安装步骤和基本概念，并通过实例代码展示了如何编写Hello World程序来发送和接收消息。

RocketMQ简介 RocketMQ是什么

RocketMQ 是一款由阿里巴巴开源的分布式消息中间件，基于Java语言开发，具有高可用、高性能、高可靠等特性。RocketMQ 采用了发布/订阅模式，支持顺序消息、定时消息、事务消息等多种消息类型，广泛应用于分布式系统中，以实现异步解耦、流量削峰、数据同步等功能。

RocketMQ的特点和优势

高性能

RocketMQ 在性能方面表现出色，主要体现在以下方面：

• 高吞吐量：RocketMQ 设计了高效的消息发送与接收机制，能够支持每秒数百万的消息吞吐量。
• 低延迟：RocketMQ 使用了异步刷盘、预取机制等技术，确保消息从发送到接收的延迟非常短。
• 集群模式：RocketMQ 支持多节点集群部署，通过负载均衡和容错机制，提高了系统的整体性能。

高可用性与可靠性

• 主从同步：RocketMQ 采用主从同步机制，保证消息的可靠传输。
• 多副本：消息可以配置多个副本，即使主节点故障，消息也不会丢失。
• 持久化存储：RocketMQ 支持消息持久化存储，在极端情况下仍能保证数据不丢失。

功能丰富

• 消息过滤：支持多种方式的消息过滤，如SQL过滤、标签过滤等。
• 消息重试：对失败的消息支持重试机制，保证消息最终能成功发送。
• 消息追踪：提供消息的追踪功能，可以定位消息在传输过程中的具体位置。

RocketMQ的应用场景

异步解耦

在分布式系统中，不同模块之间的调用可能存在时延和依赖性问题，通过使用RocketMQ进行消息传递，可以使系统各部分解耦，实现异步调用，提高系统的稳定性和灵活性。

流量削峰

在某些场景下，系统需要处理的请求量可能会瞬间激增，通过引入RocketMQ进行削峰，可以将大量请求平滑地分散到一定时间内处理，避免系统的瞬时压力过大。

数据同步

RocketMQ可用于数据同步场景，例如在不同数据中心之间同步数据，或者不同应用系统之间的数据同步，确保数据的一致性和可用性。

安装RocketMQ 准备工作

在开始安装RocketMQ之前，需要确保您的系统满足以下要求：

• 操作系统：支持Linux、Windows和MacOS。
• JDK版本：安装并配置好Java开发工具包（JDK），建议使用JDK 1.8及以上版本。
• 磁盘空间：确保有足够的磁盘空间用于RocketMQ的安装和数据存储。
• 网络环境：确保网络环境良好，安装过程中需要访问互联网以下载RocketMQ的安装包。

下载RocketMQ

访问RocketMQ的官方GitHub仓库，找到最新的版本下载链接，例如：

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

下载完成后，使用tar命令解压文件：

tar -zxvf apache-rocketmq-4.7.0-bin.tar.gz

这样会生成一个名为apache-rocketmq-4.7.0的目录，其中包含了RocketMQ的核心组件和配置文件。

安装RocketMQ

安装RocketMQ包括以下几个步骤：

1. 配置环境变量：编辑系统的环境变量配置文件（如Linux下的.bashrc或.bash_profile），添加RocketMQ的bin目录到PATH环境变量。

   export PATH=$PATH:/path/to/rocketmq/apache-rocketmq-4.7.0/bin

2. 启动NameServer：NameServer是RocketMQ的名字服务器，主要用于管理和发现Broker节点。启动NameServer之前，请确保已经配置好环境变量。

   nohup sh bin/mqnamesrv &

   启动成功后，可以通过以下命令查看NameServer的运行日志：

   tail -f ~/logs/rocketmqlogs/namesrv.log

3. 启动Broker：Broker是RocketMQ的消息代理服务器，负责消息的收发和存储。启动之前同样需要配置好环境变量。

   nohup sh bin/mqbroker -n localhost:9876 &

   启动成功后，可以通过以下命令查看Broker的运行日志：

   tail -f ~/logs/rocketmqlogs/broker.log

环境配置脚本示例

为了帮助读者更好地配置环境变量，提供一个简单的环境配置示例脚本：

#!/bin/bash
# 配置RocketMQ的bin目录到PATH环境变量
export PATH=$PATH:/path/to/rocketmq/apache-rocketmq-4.7.0/bin

RocketMQ的基本概念 名词解释

Topic

Topic是RocketMQ中消息的逻辑分类，类似于消息队列的概念。每一个Topic是一个消息的逻辑通道，生产者将消息发布到指定的Topic，而消费者则订阅相应的Topic来接收消息。通过Topic，可以将不同类型的业务消息区分开来，便于管理和处理。

Tag

Tag是对Topic的进一步细分，用于描述消息的属性，例如可以用来表示消息的优先级或业务类型。消费者可以通过指定Tag来过滤接收的消息，实现更加精细化的订阅。

Message

Message是RocketMQ中的基本单元，指在系统中传输的数据。它包含消息体（Message Body）、消息属性（Message Properties）等部分。消息体可以是任意类型的字符串或二进制数据，消息属性则用于附加有关消息的各种信息，如发送者、接收者、发送时间等。

Consumer

Consumer是消息的接收者，负责从Topic中订阅并接收消息。RocketMQ支持多种类型的消费者，包括Pull模型（主动拉取消息模式）和Push模型（被动推送消息模式）。

Producer

Producer是消息的发布者，负责将消息发送到指定的Topic。RocketMQ的生产者同样支持多种类型，常见的有同步发送、异步发送和批量发送等。

NameServer

NameServer是RocketMQ的名字服务器，负责维护Broker的列表，并提供Broker的信息查询服务，以实现Broker的动态发现和负载均衡。

Broker

Broker是消息的代理服务器，负责存储和转发消息，是RocketMQ的核心组件之一。RocketMQ支持集群部署Broker节点，通过多副本机制提高系统的可靠性和可用性。

Client

Client是RocketMQ的客户端，包括生产者（Producer）和消费者（Consumer），负责与消息中间件进行交互。客户端代码通常运行在应用程序所在的服务器上，处理消息的发送、接收和处理逻辑。

消息模型和消息路由机制

RocketMQ的消息模型主要包括Push模型和Pull模型，而消息路由机制则是RocketMQ用于确定消息如何通过Broker节点传输的策略。

消息模型

• Push模型：消息由Broker主动推送给消费者，适用于消费者需要实时处理消息的场景。
• Pull模型：消费者主动从Broker拉取消息，适用于消费者需要控制消息接收速度的场景。

消息路由机制

RocketMQ使用路由表来描述消息如何从生产者流向消费者，路由表包含Broker的信息，生产者发送消息时，RocketMQ会根据路由表将消息路由到合适的Broker节点上。当Broker节点发生故障时，RocketMQ能够动态更新路由表，保证消息的可靠传输。

消息模型示例代码

为了更好地理解RocketMQ的消息模型，下面提供了一个简单的消息模型示例代码：

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

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

        // 启动Producer
        producer.start();

        // 创建消息
        Message msg = new Message("TestTopic", "TagA", "Hello RocketMQ".getBytes());

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

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

编写Hello World程序 创建生产者发送消息

首先，创建一个Java程序来实现消息的发送功能。以下是创建Producer发送消息的基本步骤和示例代码。

步骤

1. 创建Producer实例：实例化一个RocketMQ的Producer对象，设置必要的属性，如NameServer地址。
2. 启动Producer：调用start方法启动Producer实例。
3. 发送消息：使用send方法发送消息，可以指定消息的主题（Topic）和内容。
4. 停止Producer：在发送完消息后，调用shutdown方法停止Producer实例。

示例代码

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

public class RocketMQProducer {
    public static void main(String[] args) throws Exception {
        // 实例化并配置Producer
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        producer.setNamesrvAddr("localhost:9876");

        // 启动Producer
        producer.start();

        // 创建消息
        Message msg = new Message("TestTopic", // 设置Topic名称
                "TagA", // 设置Tag
                "Hello RocketMQ".getBytes(RemotingHelper.DEFAULT_CHARSET)); // 设置消息内容

        // 发送消息
        SendResult sendResult = producer.send(msg);
        System.out.printf("%s%n", sendResult.getSendStatus());

        // 停止Producer
        producer.shutdown();
    }
}

创建消费者接收消息

接下来，创建一个Java程序来实现消息的接收功能。以下是创建Consumer接收消息的基本步骤和示例代码。

步骤

1. 创建Consumer实例：实例化一个RocketMQ的Consumer对象，设置必要的属性，如NameServer地址。
2. 订阅Topic：注册一个回调函数，用于处理接收到的消息。
3. 启动Consumer：调用start方法启动Consumer实例。
4. 停止Consumer：在接收到消息后，调用shutdown方法停止Consumer实例。

示例代码

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

public class RocketMQConsumer {
    public static class MessageListenerDemo implements MessageListenerOrderly {
        @Override
        public ConsumeOrderedResult consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
            for (MessageExt msg : msgs) {
                System.out.println("Receive New Messages: " + new String(msg.getBody()));
            }
            return ConsumeOrderedResult.SUCCESS;
        }
    }

    public static void main(String[] args) throws Exception {
        // 实例化并配置Consumer
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.setMessageModel(MessageModel.CLUSTERING);

        // 订阅Topic
        consumer.subscribe("TestTopic", "*");
        consumer.registerMessageListener(new MessageListenerDemo());

        // 启动Consumer
        consumer.start();

        // 程序挂起，保持运行状态
        System.in.read();
    }
}

运行程序和查看结果

在编写完发送和接收消息的程序后，可以分别运行它们来查看结果。

1. 启动RocketMQ：
   确保RocketMQ的NameServer和Broker都已经启动。

2. 运行Producer程序：
   运行RocketMQProducer类的main方法，发送一条消息。

3. 运行Consumer程序：
   运行RocketMQConsumer类的main方法，接收并处理消息。

4. 查看结果：
   在运行Consumer的终端窗口中，可以看到输出的消息内容，验证消息是否成功接收到。

常见问题及解决方法 启动RocketMQ失败

RocketMQ启动失败可能是由于多种原因造成的，包括配置文件错误、端口冲突等。以下是一些常见的问题和解决方法：

问题

• RocketMQ启动时报错。
• NameServer或Broker无法正常启动。

解决方法

1. 检查配置文件：确保配置文件中的路径、端口号等信息正确无误。
2. 检查端口冲突：使用netstat -anp | grep 端口号查看是否有其他进程占用了RocketMQ配置的端口。
3. 清理日志和数据目录：如果RocketMQ之前运行过，可能会有一些残留的日志文件或数据文件，建议先清理这些文件再尝试启动。
4. 检查硬盘空间：确保RocketMQ的数据存储路径有足够的磁盘空间。

发送消息时提示错误

当发送消息时遇到错误，通常与消息格式、配置设置或网络问题有关。

问题

• 发送消息时提示错误信息。
• 发送消息的速度慢或完全无法发送。

解决方法

1. 检查消息体和属性：确保消息体和属性是按照RocketMQ的要求格式化的。
2. 检查网络连接：确保NameServer和Broker节点之间的网络连接是通畅的。
3. 配置Broker端口：检查Broker节点的网络配置是否正确，端口是否被防火墙阻止。
4. 查看错误日志：查看RocketMQ的日志文件，特别是Broker节点的日志，获取更多的错误信息。

消息接收不成功

消息接收失败的原因可能包括配置错误、网络问题、消息发送失败等。

问题

• 消息接收端长时间没有接收到消息。
• Consumer无法正常订阅到Topic。

解决方法

1. 检查Consumer配置：确保Consumer的配置信息正确，如Topic名称、Tag等。
2. 检查Topic和Tag的一致性：确保生产者发送的消息和消费者的订阅信息一致。
3. 查看消息发送日志：确认生产者是否成功发送了消息。
4. 重启Consumer：有时候简单的重启Consumer可以解决问题。
5. 检查日志文件：查看Consumer的日志文件，定位可能存在的问题。

实践案例分享 案例一：简单的日志采集系统

场景描述

一个常见的场景是将系统产生的日志实时采集并发送到集中存储系统中以备后续分析和处理。这里我们可以使用RocketMQ来实现一个简单的日志采集系统。

实现步骤

1. 日志生产者：编写代码来监听并读取日志文件，当文件发生变化时，将日志内容打包成消息发送到RocketMQ。
2. 日志采集服务：编写一个Consumer程序，订阅日志Topic，接收并处理日志消息。
3. 日志存储：将接收到的日志信息保存到数据库或文件系统中。

示例代码

日志生产者代码

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

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

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

        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                try {
                    // 读取日志文件
                    BufferedReader reader = new BufferedReader(new FileReader("/path/to/logfile"));
                    String line;
                    while ((line = reader.readLine()) != null) {
                        // 将日志内容打包成消息
                        Message message = new Message("LogTopic", "LogTag", line.getBytes());
                        // 发送消息
                        SendResult sendResult = producer.send(message);
                        System.out.println(sendResult.getSendStatus());
                    }
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }, 0, 5, TimeUnit.SECONDS);
    }
}

日志采集服务代码

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

import java.util.List;

public class LogCollector {
    public static class LogCollectorListener implements MessageListenerOrderly {
        @Override
        public ConsumeOrderedResult consumeMessage(List<MessageExt> msgs, ConsumeOrderedContext context) {
            for (MessageExt msg : msgs) {
                String logContent = new String(msg.getBody());
                // 将日志内容保存到数据库或者文件中
                System.out.println("Received log: " + logContent);
            }
            return ConsumeOrderedResult.SUCCESS;
        }
    }

    public static void main(String[] args) throws Exception {
        // 实例化 Consumer
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("LogConsumer");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.setMessageModel(MessageModel.CLUSTERING);

        // 订阅 LogTopic
        consumer.subscribe("LogTopic", "*");
        consumer.registerMessageListener(new LogCollectorListener());

        // 启动 Consumer
        consumer.start();

        // 程序挂起，保持运行状态
        System.in.read();
    }
}

案例分析

通过上述代码，我们实现了一个简单的日志采集系统。生产者实时读取日志文件，并将日志内容发送到RocketMQ。消费者订阅日志Topic，接收日志消息并将其保存到数据库或文件系统中。这种方式不仅能够实现日志的实时采集，还能保证数据的可靠传输。

案例二：异步处理订单通知

场景描述

在电子商务系统中，当订单状态发生变化时，需要异步通知用户。这里我们可以利用RocketMQ来实现异步通知功能。

实现步骤

1. 订单服务：当订单状态发生变化时，调用RocketMQ的API发送消息。
2. 通知服务：通过RocketMQ订阅订单消息，并异步处理。处理完成后，可以通过其他手段（如邮件、短信等）通知用户。

示例代码

订单服务代码

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

public class OrderService {
    public static void main(String[] args) throws Exception {
        // 实例化 Producer
        DefaultMQProducer producer = new DefaultMQProducer("OrderProducer");
        producer.setNamesrvAddr("localhost:9876");
        producer.start();

        // 模拟订单状态变化
        String orderId = "1001";
        String status = "PAID";
        String messageBody = "订单 " + orderId + " 状态已更新为 " + status;

        // 发送消息
        Message message = new Message("OrderTopic", "OrderTag", messageBody.getBytes());
        SendResult sendResult = producer.send(message);
        System.out.println(sendResult.getSendStatus());

        // 停止 Producer
        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.protocol.heartbeat.MessageModel;

import java.util.List;

public class OrderNotification {
    public static class OrderNotificationListener implements MessageListenerOrderly {
        @Override
        public ConsumeOrderedResult consumeMessage(List<MessageExt> msgs, ConsumeOrderedContext context) {
            for (MessageExt msg : msgs) {
                String orderInfo = new String(msg.getBody());
                // 异步处理订单状态变化
                System.out.println("Processing order: " + orderInfo);

                // 处理完成后，通知用户
                // 例如发送邮件或短信
                // simulateNotification(orderInfo);

                return ConsumeOrderedResult.SUCCESS;
            }
            return ConsumeOrderedResult.SUCCESS;
        }

        // 模拟通知用户
        private void simulateNotification(String info) {
            // 简单的模拟通知逻辑
            System.out.println("Notified user about order: " + info);
        }
    }

    public static void main(String[] args) throws Exception {
        // 实例化 Consumer
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("OrderConsumer");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.setMessageModel(MessageModel.CLUSTERING);

        // 订阅 OrderTopic
        consumer.subscribe("OrderTopic", "*");
        consumer.registerMessageListener(new OrderNotificationListener());

        // 启动 Consumer
        consumer.start();

        // 程序挂起，保持运行状态
        System.in.read();
    }
}

案例分析

通过上述代码，我们实现了订单状态变化的异步通知。生产者通过RocketMQ发送订单状态更新的消息，消费者订阅OrderTopic并异步处理这些消息。这种方式不仅能实现订单状态的实时通知，还能确保系统的稳定性和可扩展性。

案例三：实时统计用户在线人数

场景描述

在一些社交应用中，实时统计用户在线人数是一项常见的功能。通过引入RocketMQ，可以实现用户登录和登出消息的异步处理。

实现步骤

1. 用户服务：当用户登录或登出时，发送消息到RocketMQ。
2. 统计服务：订阅用户登录登出消息，并实时更新在线人数统计。
3. 结果展示：将在线人数统计结果展示给用户。

示例代码

用户服务代码

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

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

        // 模拟用户登录
        String userId = "user01";
        String action = "LOGIN";
        String messageBody = "用户 " + userId + " " + action;

        // 发送消息
        Message message = new Message("UserTopic", "UserTag", messageBody.getBytes());
        SendResult sendResult = producer.send(message);
        System.out.println(sendResult.getSendStatus());

        // 模拟用户登出
        action = "LOGOUT";
        messageBody = "用户 " + userId + " " + action;
        message = new Message("UserTopic", "UserTag", messageBody.getBytes());
        sendResult = producer.send(message);
        System.out.println(sendResult.getSendStatus());

        // 停止 Producer
        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.protocol.heartbeat.MessageModel;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UserStatistics {
    public static class UserStatisticsListener implements MessageListenerOrderly {
        private Map<String, Integer> onlineUsers = new HashMap<>();

        @Override
        public ConsumeOrderedResult consumeMessage(List<MessageExt> msgs, ConsumeOrderedContext context) {
            for (MessageExt msg : msgs) {
                String content = new String(msg.getBody());
                String[] parts = content.split(" ");
                String userId = parts[1];
                String action = parts[2];

                // 更新在线人数统计
                if ("LOGIN".equals(action)) {
                    onlineUsers.put(userId, 1);
                } else if ("LOGOUT".equals(action)) {
                    onlineUsers.remove(userId);
                }
                System.out.println("当前在线人数: " + onlineUsers.size());
            }
            return ConsumeOrderedResult.SUCCESS;
        }
    }

    public static void main(String[] args) throws Exception {
        // 实例化 Consumer
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("UserStatisticsConsumer");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.setMessageModel(MessageModel.CLUSTERING);

        // 订阅 UserTopic
        consumer.subscribe("UserTopic", "*");
        consumer.registerMessageListener(new UserStatisticsListener());

        // 启动 Consumer
        consumer.start();

        // 程序挂起，保持运行状态
        System.in.read();
    }
}

案例分析

通过上述代码，我们实现了实时统计用户在线人数的功能。生产者发送用户登录和登出的消息到RocketMQ，消费者订阅UserTopic并更新在线人数统计。这种方式不仅可以实时跟踪用户的在线状态，还能提供更丰富的用户行为分析。