RocketMQ消息中间件项目实战入门教程-原创手记-慕课网

概述

本文介绍了RocketMQ消息中间件的基本概念和特点，详细讲解了其架构和组件，并通过实战项目展示了如何在实际项目中应用RocketMQ进行消息发送和接收，涵盖了环境搭建、快速开始、常见消息模式及实战项目案例，适合希望深入了解和实战应用RocketMQ消息中间件的读者。

RocketMQ简介

什么是RocketMQ

RocketMQ是由阿里巴巴开源的一款分布式消息中间件。它提供了高吞吐量、高可用性、低延时的消息发送和接收服务，主要用于异步通信、解耦系统、流量削峰等场景。RocketMQ的设计目标是为大规模分布式系统提供可靠的异步通信能力。

RocketMQ的特点和优势

高吞吐量和低延时：RocketMQ能够支持每秒百万级的消息发送，延时可以达到毫秒级别。
高可用性：通过主从复制和多活机制，确保在节点故障时服务不中断。
消息顺序保障：RocketMQ支持消息的全局顺序和部分顺序。
消息过滤和路由：通过过滤器和路由规则，可以灵活地处理消息。
集群管理：支持灵活的集群管理模式，可以通过配置文件或者控制台轻松管理集群。
多种客户端支持：提供了Java、C++、Python等语言的客户端支持。

RocketMQ的架构和组件

RocketMQ的架构主要由以下几个部分组成：

NameServer：负责维护整个集群的信息，接受客户端的查询请求并返回消息队列的位置信息。
Broker：消息转发角色，负责接收生产者发送的消息，存储消息并转发给消费者。
Producer：消息生产者，负责发送消息到Broker。
Consumer：消息消费者，负责从Broker接收消息并处理。
消息存储：RocketMQ使用文件系统进行消息存储，也可以通过配置连接到其他存储系统。

NameServer和Broker的关系

NameServer会定期向Broker发送心跳包，以确认Broker的状态。
当生产者或消费者请求消息队列的位置时，NameServer会返回对应的Broker地址。
每个Broker会定时向NameServer注册，NameServer会缓存Broker的信息。

消息发送流程

生产者发送消息到NameServer。
NameServer返回Broker地址。
生产者将消息发送到Broker。
Broker将消息存入磁盘或内存中。

消息消费流程

消费者向NameServer请求订阅的消息队列的位置。
NameServer返回Broker地址。
消费者从Broker拉取消息或接收推送给它的消息。

消息的存储和恢复

CommitLog：持久化的消息存储。
ConsumeQueue：索引文件，用于快速定位到CommitLog中的消息位置。
IndexFile：索引文件，用于快速定位到CommitLog中的消息位置。

环境搭建

安装Java环境

访问Oracle官方网站或使用其他可靠的源下载Java JDK。
解压下载的JDK包到指定目录。
配置环境变量。

# 设置环境变量
export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

验证安装

java -version

下载并解压RocketMQ

访问RocketMQ的官方GitHub仓库，下载最新版本的压缩包。
解压文件到指定目录。

tar -zxvf rocketmq-all-4.6.0-release.tar.gz -C /path/to/rocketmq
cd /path/to/rocketmq

配置RocketMQ环境变量

设置环境变量。

export ROCKETMQ_HOME=/path/to/rocketmq
export PATH=$PATH:$ROCKETMQ_HOME/bin

配置RocketMQ的相关配置文件。

# rocketmq.properties
# 设置NameServer地址
namesrv.addr=localhost:9876

# broker.properties
# 设置Broker ID
broker.id=0
# 设置Broker名称
broker.name=brokerA
# 设置Broker的IP地址
broker.ip=127.0.0.1
# 设置是否启用消息顺序
broker.topicConfigHashCheckEnable=true

启动RocketMQ服务器

启动NameServer。

nohup sh bin/mqnamesrv &

启动Broker。

nohup sh bin/mqbroker -n localhost:9876 &

查询所有运行中的RocketMQ进程。

ps -ef | grep mq

快速开始

发送和接收消息的基本步骤

消息生产者

创建生产者实例。
设置生产者的名称。
设置NameServer地址。
启动生产者。
发送消息。
关闭生产者。

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 {
        // 创建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
                null // properties
        );
        // 发送消息
        SendResult sendResult = producer.send(msg);
        System.out.printf("%s%n", sendResult);
        // 关闭Producer
        producer.shutdown();
    }
}

消息消费者

创建消费者实例。
设置消费者的名称。
设置NameServer地址。
设置订阅主题。
启动消费者。
消费消息。

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("ConsumerGroupName");
        // 设置NameServer地址
        consumer.setNamesrvAddr("localhost:9876");
        // 设置订阅的主题
        consumer.subscribe("TopicTest", "*");
        // 设置从哪开始消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 注册消息监听器
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("Receive New Messages: " + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        // 启动消费者
        consumer.start();
        System.out.println("Consumer Started.");
    }
}

常见消息模式

简单模式（单射模式）

简单模式是最基本的消息模式，生产者将消息发送到指定的队列中，消费者从队列中拉取消息进行处理。

生产者代码示例

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

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

        for (int i = 0; i < 10; i++) {
            Message msg = new Message("TopicTest", "TagA", (i + 1) * 100, ("Simple Message " + i).getBytes());
            SendResult result = producer.send(msg);
            System.out.printf("%s%n", result);
        }
        producer.shutdown();
    }
}

消费者代码示例

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
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("ConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("TopicTest", "*");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("Received: " + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        consumer.start();
        System.out.println("Consumer Started.");
    }
}

发布/订阅模式

发布/订阅模式是一种消息的广播模式，生产者将消息发布到一个主题，所有订阅该主题的消费者都会接收到消息。

生产者代码示例

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

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

        for (int i = 0; i < 10; i++) {
            Message msg = new Message("TopicTest", "TagA", "PubSub Message " + i, "Hello World".getBytes());
            SendResult result = producer.send(msg);
            System.out.printf("%s%n", result);
        }
        producer.shutdown();
    }
}

消费者代码示例

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

public class PubSubConsumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("TopicTest", "*");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("Received: " + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        consumer.start();
        System.out.println("Consumer Started.");
    }
}

消息过滤和路由

RocketMQ支持通过规则过滤和路由消息。例如，可以通过设置消息的Tag来过滤只接收特定主题的消息。

生产者代码示例

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

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

        for (int i = 0; i < 10; i++) {
            Message msg = new Message("TopicTest", "TagA", "Filter Message " + i, "Hello World".getBytes());
            SendResult result = producer.send(msg);
            System.out.printf("%s%n", result);
        }
        producer.shutdown();
    }
}

消费者代码示例

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

public class FilterConsumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("TopicTest", "TagA");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("Received: " + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        consumer.start();
        System.out.println("Consumer Started.");
    }
}

实战项目案例

在实际项目中应用RocketMQ

在实际项目中，RocketMQ可以用于异步通信、解耦系统、流量削峰等场景。例如，在电商系统中，订单创建后可以异步发送到物流系统，减少延迟；在金融系统中，交易系统可以将交易记录异步发送到审计系统，提高系统稳定性。

实战项目开发流程

需求分析：分析项目需求，确定是否需要使用RocketMQ。
环境搭建：搭建RocketMQ环境，确保Java环境已经配置好。
设计消息队列：设计消息队列的结构，包括主题、标签和消息体等。
编写代码：编写生产者和消费者代码。
测试：测试消息的发送和接收流程。
部署：将生产者和消费者部署到服务器。

项目部署和调试技巧

配置文件优化：根据实际需求调整RocketMQ的配置文件。
监控和日志：使用RocketMQ自带的监控工具，监控消息队列的状态。
性能测试：进行压力测试，确保在高并发情况下RocketMQ的性能。
故障排查：根据日志分析和监控数据排查故障。

案例代码

生产者代码

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("ProducerGroupName");
        producer.setNamesrvAddr("localhost:9876");
        producer.start();

        for (int i = 0; i < 10; i++) {
            Message msg = new Message("TopicTest", "TagA", "Order Message " + i, "Hello World".getBytes());
            SendResult result = producer.send(msg);
            System.out.printf("%s%n", result);
        }
        producer.shutdown();
    }
}

消费者代码

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

public class OrderConsumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("TopicTest", "TagA");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("Received: " + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        consumer.start();
        System.out.println("Consumer Started.");
    }
}

实战项目代码

生产者代码示例

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("ProducerGroupName");
        producer.setNamesrvAddr("localhost:9876");
        producer.start();

        for (int i = 0; i < 10; i++) {
            Message msg = new Message("TopicTest", "TagA", "Order Message " + i, "Hello World".getBytes());
            SendResult result = producer.send(msg);
            System.out.printf("%s%n", result);
        }
        producer.shutdown();
    }
}

消费者代码示例

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

public class OrderConsumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("TopicTest", "TagA");
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("Received: " + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        consumer.start();
        System.out.println("Consumer Started.");
    }
}

常见问题与解决方法

常见错误及解决方法

消息发送失败

错误代码15: 该错误代码通常表示消息发送被拒绝，可能是因为队列已满。
- 解决方法：增加队列的存储容量或优化消息发送的频率。
错误代码12: 该错误代码通常表示消息发送被拒绝，可能是因为磁盘空间不足。
- 解决方法：检查Broker的磁盘空间，确保有足够的空间存储消息。

消息接收失败

错误代码16: 该错误代码通常表示消息接收失败，可能是因为消费者未能成功拉取消息。
- 解决方法：检查消费者配置，确保正确设置订阅的主题和标签。

消息推送延迟

错误代码17: 该错误代码通常表示消息推送延迟，可能是因为网络延迟或服务器负载过高。
- 解决方法：优化网络配置，确保网络连接顺畅；优化服务器资源分配，避免过载。

性能优化和故障排查

性能优化

增加Broker实例：通过增加Broker实例的数量来提高并发处理能力。
优化消息存储：调整CommitLog和ConsumeQueue的大小，提高消息存储效率。
使用异步模式：通过使用异步模式减少消息发送和接收的延迟。

故障排查

检查日志：通过查看RocketMQ的日志文件，分析报错信息。
监控工具：使用RocketMQ自带的监控工具，监控系统的运行状况。

日志分析和监控

日志分析

RocketMQ的日志文件通常位于logs目录下，包括broker.log、consumer.log等。通过查看日志文件，可以了解系统的运行状态和出现问题的具体情况。

日志分析代码

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class LogAnalyzer {
    public static void main(String[] args) {
        try {
            List<String> lines = Files.readAllLines(Paths.get("/path/to/broker.log"));
            for (String line : lines) {
                if (line.contains("ERROR")) {
                    System.out.println(line);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

监控工具

RocketMQ提供了监控工具，可以通过控制台或API获取监控数据，从而更好地了解系统的运行状态。

监控代码


import org.apache.rocketmq.remoting.RPCHook;
import org.apache.rocketmq.srvutil.ServerUtil;
import org.apache.rocketmq.tools.admin.RocketMQAdminStartup;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;

public class RocketMQMonitor {
    public static void main(String[] args) {
        Options options = new Options();
        options.addOption(new Option("c", "config", true, "config file"));
        options.addOption(new Option("n", "namesrvAddr", true, "name server address"));
        options.addOption(new Option("h", "help", false, "print help"));

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = null;
        try {
            cmd = parser.parse(options, args);
        } catch (Exception e) {
            e.printStackTrace();
        }

        String config = cmd.getOptionValue("c");
        String namesrvAddr = cmd.getOptionValue("n");
        boolean help = cmd.hasOption("h");

        if (help) {
            ServerUtil.printHelp("mqadmin", options);
        } else {
            RocketMQAdminStartup rocketmqAdminStartup = new RocketMQAdminStartup();
            rocketmqAdminStartup.setConfigFile(config);
            rocketmqAdminStartup.setNamesrvAddr(namesrvAddr);
            rocketmqAdminStartup.execute();
        }
    }
}
``

以上是使用RocketMQ的入门教程和实战案例，希望对您有所帮助。