为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 手写rocketMQ资料：入门教程与实践指南

手写rocketMQ资料：入门教程与实践指南

标签：
中间件
概述

本文详细介绍了RocketMQ的消息中间件特性及其应用场景，涵盖了安装配置、基本消息发送与接收等操作，并深入讲解了RocketMQ的手写rocketMQ资料，包括高级特性和故障处理方法。文章还提供了丰富的示例代码和常见问题的解决方案。

RocketMQ简介
RocketMQ是什么

RocketMQ是阿里巴巴开源的一款分布式消息中间件，它基于Java语言开发，具有高吞吐量、高可用以及支持多种消息模式等特性。RocketMQ采用了多点广播、消息发布/订阅模式，支持分布式事务，可以应用于多种场景，如异步通信、流量削峰、数据分发等。

RocketMQ的特点和优势

RocketMQ具有以下特点和优势：

  1. 高吞吐量：RocketMQ能够在毫秒级别内处理大量消息，每秒可以处理数十万条消息。
  2. 高可用：RocketMQ通过多副本复制和主从切换等机制保证系统的高可用性。
  3. 分布式事务支持：RocketMQ支持分布式事务，可以保证消息的可靠发送和消费。
  4. 多种消息模式：RocketMQ支持发布/订阅、消息队列、消息路由等多种消息模式。
  5. 消息过滤与路由：RocketMQ支持根据消息属性进行过滤和路由，便于实现复杂的业务逻辑。
  6. 可扩展性：RocketMQ具备良好的可扩展性，可以根据业务需求增加节点，提高系统的容量和可用性。
RocketMQ应用场景

RocketMQ广泛应用于各种场景，包括但不限于以下几个方面：

  1. 异步通信：在分布式系统中，通过RocketMQ进行异步通信可以降低系统间耦合度，提高系统响应速度。
    2.. 流量削峰：在高并发场景下，通过RocketMQ可以实现流量削峰，保障系统稳定运行。
  2. 数据分发：RocketMQ可以将数据从一个系统高效地分发到多个系统，实现数据的实时同步。
  3. 任务调度：RocketMQ可以作为任务调度系统的核心组件，实现任务的异步执行。
  4. 日志采集与分析：RocketMQ可以用于采集系统日志并进行实时分析，提升系统的运维效率。
安装与配置RocketMQ
安装环境准备

在安装RocketMQ之前，需要确保系统中安装了以下软件：

  • Java环境：RocketMQ基于Java开发，需要安装Java 8及以上版本。
  • Zookeeper：RocketMQ使用Zookeeper来进行集群的管理和服务发现。
RocketMQ下载与解压

下载RocketMQ的最新版本，可以从Apache RocketMQ的官方网站获取。下载完成后，解压下载的压缩包到指定目录，例如/usr/local/rocketmq。

cd /usr/local
wget https://mirrors.tuna.tsinghua.edu.cn/apache/rocketmq/4.9.1/apache-rocketmq-4.9.1-bin.tar.gz
tar -xvf apache-rocketmq-4.9.1-bin.tar.gz
cd apache-rocketmq-4.9.1
快速启动RocketMQ服务

RocketMQ提供了脚本方便快速启动服务。在RocketMQ的bin目录下，运行启动脚本：

cd /usr/local/apache-rocketmq-4.9.1/bin
./mqnamesrv &
./mqbroker -n 127.0.0.1:9876 -c ~/apache-rocketmq-4.9.1/conf/broker.properties &

这里，mqnamesrv是Name Server启动脚本，而mqbroker是Broker的启动脚本。-n参数指定了Name Server的地址，-c参数指定了Broker的配置文件。

可以通过访问http://127.0.0.1:8081来查看RocketMQ的Web管理界面，验证服务是否正常启动。

配置RocketMQ环境变量与启动参数

为了方便使用RocketMQ，建议配置环境变量。编辑/etc/profile文件，添加以下内容：

export ROCKETMQ_HOME=/usr/local/apache-rocketmq-4.9.1
export PATH=$PATH:$ROCKETMQ_HOME/bin

然后执行source /etc/profile使环境变量生效。

修改RocketMQ的配置文件broker.properties来设置启动参数。例如，设置Broker的名称、IP地址、端口号等：

brokerName=broker-a
brokerId=0
brokerRole=ASYNC_MASTER
namesrvAddr=127.0.0.1:9876
listenPort=10911
RocketMQ核心概念详解
Topic与Tag

在RocketMQ中，Topic是消息的分类标准，可以理解为消息的发布和订阅的主题。每个Topic可以包含多个消息，生产者发送消息时需要指定Topic，消费者订阅消息时也需要指定Topic。

Tag是对消息的进一步分类，可以理解为Topic下的子主题。Tag用于更细粒度的消息路由和过滤。

例如，假设有一个电商系统，可以定义一个Topic为ecommerce，并在该Topic下定义不同的Tag，例如order-create、order-update等，分别表示订单创建和订单更新的消息。

Producer与Consumer

在RocketMQ中，Producer负责生产消息，Consumer负责消费消息。Producer和Consumer在消息的生产和消费过程中扮演重要的角色。

Producer

Producer负责将消息发送到指定的Topic。Producer需要指定要发送的Topic和Tag，并设置消息的属性和内容。Producer通常以异步的方式发送消息，以提高消息发送的效率。

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 {
        // 创建Producer实例
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 启动Producer
        producer.start();

        // 创建消息
        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes(RemotingHelper.DEFAULT_CHARSET));
        // 发送消息
        SendResult sendResult = producer.send(message);
        System.out.printf("%s%n", sendResult);

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

Consumer

Consumer负责从指定的Topic中消费消息。Consumer订阅Topic时需要指定Topic和Tag，可以设置消费模式（同步或异步）以及消费线程的数量等。Consumer收到消息后可以进行处理，如业务逻辑的执行、日志记录等。

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");
        // 设置Name Server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消费起始位置
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 订阅Topic
        consumer.subscribe("TopicTest", "*");
        // 注册消息监听器
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt message : msgs) {
                System.out.println("Received message: " + new String(message.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动Consumer
        consumer.start();
    }
}
消息模型（同步与异步）

RocketMQ支持两种消息模型：同步和异步。

同步消息模型

在同步消息模型中，Producer发送消息后会等待Broker的确认，只有在收到确认后才会继续执行后续的操作。同步消息模型保证了消息发送的可靠性，但是降低了消息发送的效率。

import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class SyncProducer {
    public static void main(String[] args) throws Exception {
        // 创建Producer实例
        TransactionMQProducer producer = new TransactionMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 设置事务提交回调
        producer.setTransactionCheckListener((localMsg, arg) -> {
            // 事务提交成功
            return MessageExtBatchProcessor.CommitMessage;
        });
        // 启动Producer
        producer.start();

        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes(RemotingHelper.DEFAULT_CHARSET));
        SendResult sendResult = producer.sendMessage(message);
        System.out.printf("%s%n", sendResult);

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

异步消息模型

在异步消息模型中，Producer发送消息后不会等待Broker的确认，而是通过回调函数来处理确认结果。异步消息模型提高了消息发送的效率，但可能会牺牲消息的可靠性。

import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class AsyncProducer {
    public static void main(String[] args) throws Exception {
        // 创建Producer实例
        TransactionMQProducer producer = new TransactionMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 设置事务提交回调
        producer.setTransactionCheckListener((localMsg, arg) -> {
            // 事务提交成功
            return MessageExtBatchProcessor.CommitMessage;
        });
        // 启动Producer
        producer.start();

        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes(RemotingHelper.DEFAULT_CHARSET));
        producer.send(message, (sendResult, context) -> {
            System.out.printf("%s%n", sendResult);
        });

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

事务消息

RocketMQ还支持事务消息，确保消息的可靠发送和消费。以下是一个简单的事务消息发送示例：

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

public class TransactionProducer {
    public static void main(String[] args) throws Exception {
        // 创建Producer实例
        TransactionMQProducer producer = new TransactionMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 设置事务提交回调
        producer.setTransactionCheckListener((localMsg, arg) -> {
            // 事务提交成功
            return MessageExtBatchProcessor.CommitMessage;
        });
        // 启动Producer
        producer.start();

        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes(RemotingHelper.DEFAULT_CHARSET));
        TransactionSendResult sendResult = producer.sendMessage(message);
        System.out.printf("%s%n", sendResult);

        // 关闭Producer
        producer.shutdown();
    }
}
消息过滤与消息路由

RocketMQ提供了强大的消息过滤和路由功能，以支持复杂的业务逻辑。

消息过滤

RocketMQ支持根据消息的属性进行过滤，例如根据Tag进行过滤。消费者可以指定要订阅的消息的Tag，只有匹配的消息才会被接收。

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 {
        // 创建Consumer实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 设置Name Server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消费起始位置
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 订阅Topic并指定过滤规则
        consumer.subscribe("TopicTest", "TagA");
        // 注册消息监听器
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt message : msgs) {
                System.out.println("Received message: " + new String(message.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动Consumer
        consumer.start();
    }
}

消息路由

RocketMQ支持根据消息的路由规则将消息发送到指定的Broker。例如，可以通过配置文件或代码的方式设置消息的路由规则，以实现消息的分布式处理。

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 RouteProducer {
    public static void main(String[] args) throws Exception {
        // 创建Producer实例
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 启动Producer
        producer.start();

        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes(RemotingHelper.DEFAULT_CHARSET));
        // 发送消息
        SendResult sendResult = producer.send(message);
        System.out.printf("%s%n", sendResult);

        // 关闭Producer
        producer.shutdown();
    }
}
手写RocketMQ的基本消息发送与接收
创建Producer与Consumer

在RocketMQ中，Producer负责发送消息，Consumer负责接收消息。通过Java代码可以创建Producer和Consumer实例，并设置相应的配置。

创建Producer

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

public class MessageProducer {
    public static void main(String[] args) throws Exception {
        // 创建Producer实例
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 启动Producer
        producer.start();

        // 创建消息
        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes());
        // 发送消息
        producer.send(message);

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

创建Consumer

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

public class MessageConsumer {
    public static void main(String[] args) throws Exception {
        // 创建Consumer实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 设置Name Server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消费起始位置
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 订阅Topic
        consumer.subscribe("TopicTest", "*");
        // 注册消息监听器
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt message : msgs) {
                System.out.println("Received message: " + new String(message.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动Consumer
        consumer.start();
    }
}
发送消息的基本步骤

在发送消息的基本步骤中，需要创建Producer实例，设置Name Server地址，启动Producer，创建消息并发送，最后关闭Producer。

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

public class SendMessage {
    public static void main(String[] args) throws Exception {
        // 创建Producer实例
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 启动Producer
        producer.start();

        // 创建消息
        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes());
        // 发送消息
        SendResult sendResult = producer.send(message);
        System.out.printf("%s%n", sendResult);

        // 关闭Producer
        producer.shutdown();
    }
}
接收消息的基本步骤

在接收消息的基本步骤中，需要创建Consumer实例，设置Name Server地址，启动Consumer，订阅Topic并注册消息监听器，最后启动Consumer开始接收消息。

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

public class ReceiveMessage {
    public static void main(String[] args) throws Exception {
        // 创建Consumer实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 设置Name Server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消费起始位置
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 订阅Topic
        consumer.subscribe("TopicTest", "*");
        // 注册消息监听器
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt message : msgs) {
                System.out.println("Received message: " + new String(message.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动Consumer
        consumer.start();
    }
}
消息发送与接收的简单示例代码

以下是一个简单的消息发送与接收的示例代码，展示了如何使用RocketMQ进行基本的消息通信。

发送消息

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 {
        // 创建Producer实例
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 启动Producer
        producer.start();

        // 创建消息
        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes());
        // 发送消息
        SendResult sendResult = producer.send(message);
        System.out.printf("%s%n", sendResult);

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

接收消息

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

public class SimpleConsumer {
    public static void main(String[] args) throws Exception {
        // 创建Consumer实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 设置Name Server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消费起始位置
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 订阅Topic
        consumer.subscribe("TopicTest", "*");
        // 注册消息监听器
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt message : msgs) {
                System.out.println("Received message: " + new String(message.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动Consumer
        consumer.start();
    }
}
RocketMQ的高级特性与实践
消息重试与消息回溯

消息重试

在RocketMQ中，当消息发送失败时，可以通过配置消息重试机制来自动重新发送失败的消息。这可以提高消息的可靠性和系统的稳定性。

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

public class RetryProducer {
    public static void main(String[] args) throws Exception {
        // 创建Producer实例
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消息重试配置
        producer.setRetryTimesWhenSendFailed(5);
        // 启动Producer
        producer.start();

        // 创建消息
        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes());
        // 发送消息
        producer.send(message);

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

消息回溯

RocketMQ支持消息回溯功能，可以在消息消费出现问题时回溯到之前的消息进行重新消费。这可以避免消息丢失或重复消费的问题。

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

public class MessageConsumerWithBacktrace {
    public static void main(String[] args) throws Exception {
        // 创建Consumer实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 设置Name Server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消费起始位置
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 订阅Topic
        consumer.subscribe("TopicTest", "*");
        // 注册消息监听器
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt message : msgs) {
                try {
                    System.out.println("Received message: " + new String(message.getBody()));
                    // 模拟消费失败
                    if (new String(message.getBody()).contains("Error")) {
                        throw new Exception("消费失败");
                    }
                } catch (Exception e) {
                    // 回溯处理
                    System.out.println("消息回溯...");
                    return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
                }
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动Consumer
        consumer.start();
    }
}
消息广播与集群模式

消息广播

在消息广播模式下，生产者发送的消息会被复制到所有的消费者实例上。这种模式适用于需要将消息发送到所有节点的情况。

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

public class BroadcastProducer {
    public static void main(String[] args) throws Exception {
        // 创建Producer实例
        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 启动Producer
        producer.start();

        // 创建消息
        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes());
        // 发送消息
        SendResult sendResult = producer.send(message);
        System.out.printf("%s%n", sendResult);

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

消息集群

在消息集群模式下，生产者发送的消息会被复制到一个或多个消费者实例上。这种模式适用于需要实现负载均衡和容错的情况。

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

public class ClusterConsumer {
    public static void main(String[] args) throws Exception {
        // 创建Consumer实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 设置Name Server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消费起始位置
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 订阅Topic
        consumer.subscribe("TopicTest", "*");
        // 注册消息监听器
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt message : msgs) {
                System.out.println("Received message: " + new String(message.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动Consumer
        consumer.start();
    }
}
消息过滤与批量消费

消息过滤

RocketMQ支持根据消息的属性进行过滤，例如可以根据Tag进行过滤。在消费消息时，可以指定要订阅的消息的Tag，只有匹配的消息才会被接收。

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

public class FilterConsumerDemo {
    public static void main(String[] args) throws Exception {
        // 创建Consumer实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 设置Name Server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消费起始位置
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 订阅Topic并指定过滤规则
        consumer.subscribe("TopicTest", "TagA");
        // 注册消息监听器
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt message : msgs) {
                System.out.println("Received message: " + new String(message.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动Consumer
        consumer.start();
    }
}

批量消费

RocketMQ支持批量消费，可以通过配置参数来控制每次消费的消息数量。这可以减少网络通信的次数，提高消息消费的效率。

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

public class BatchConsumerDemo {
    public static void main(String[] args) throws Exception {
        // 创建Consumer实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 设置Name Server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消费起始位置
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 订阅Topic
        consumer.subscribe("TopicTest", "*");
        // 设置Batch消费
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.setPullBatchSize(10); // 设置每次消费的消息数量
        // 注册消息监听器
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt message : msgs) {
                System.out.println("Received message: " + new String(message.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动Consumer
        consumer.start();
    }
}
消息顺序与事务消息

消息顺序

RocketMQ支持在指定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.message.MessageExt;

public class OrderedConsumerDemo {
    public static void main(String[] args) throws Exception {
        // 创建Consumer实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupName");
        // 设置Name Server地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 设置消费起始位置
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        // 订阅Topic并设置顺序消费
        consumer.subscribe("TopicTest", "*");
        consumer.setMessageModel(MessageModel.CLUSTERING); // 设置顺序模式
        // 注册消息监听器
        consumer.registerMessageListener((msgs, context) -> {
            for (MessageExt message : msgs) {
                System.out.println("Received message: " + new String(message.getBody()));
            }
            return ConsumeOrderlyStatus.SUCCESS;
        });
        // 启动Consumer
        consumer.start();
    }
}

事务消息

在分布式系统中，事务消息可以确保消息的可靠发送和消费。RocketMQ支持通过分布式事务来保证消息的一致性和可靠性。

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

public class TransactionProducer {
    public static void main(String[] args) throws Exception {
        // 创建Producer实例
        TransactionMQProducer producer = new TransactionMQProducer("ProducerGroupName");
        // 设置Name Server地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        // 设置事务提交回调
        producer.setTransactionCheckListener((localMsg, arg) -> {
            // 事务提交成功
            return MessageExtBatchProcessor.CommitMessage;
        });
        // 启动Producer
        producer.start();

        Message message = new Message("TopicTest", // Topic
                "TagA", // Tag
                "OrderID188", // Message内容
                ("Hello RocketMQ").getBytes(RemotingHelper.DEFAULT_CHARSET));
        TransactionSendResult sendResult = producer.sendMessage(message);
        System.out.printf("%s%n", sendResult);

        // 关闭Producer
        producer.shutdown();
    }
}
RocketMQ常见问题与解决方法
常见错误代码解析

RocketMQ在运行过程中可能会遇到各种错误代码，以下是一些常见的错误代码及其含义和解决方法：

  • 50001 - NetworkException

    • 含义：网络异常，通常是因为网络连接问题导致的。
    • 解决方法：检查网络连接是否正常，确保Name Server和Broker之间的网络通信畅通。

  • 50002 - NotLeaderForQueueException

    • 含义：不是队列的Leader，通常是在集群中消息路由出现问题时产生的。
    • 解决方法：检查消息的路由配置是否正确，确保消息能够正确路由到相应的Broker。

  • 50003 - MessageQueueEmptyException

    • 含义：消息队列为空，通常是在消息队列没有消息可消费时产生的。
    • 解决方法：检查消息生产者是否正常发送消息，确保消息队列中有足够的消息。
  • 50004 - OffsetOutOfRangeException
    • 含义：偏移量超出范围，通常是在消费消息时偏移量设置不正确导致的。
    • 解决方法：检查消费者设置的消费偏移量是否正确，确保偏移量在合理范围内。
性能优化与集群扩展

为了提高RocketMQ的性能和扩展性，可以采取以下措施：

  1. 增加Broker节点：通过增加Broker节点来提高系统的吞吐量和并发处理能力。
  2. 负载均衡：通过配置负载均衡策略，将消息均匀地分配到不同的Broker节点上。
  3. 优化网络通信：优化网络通信配置，减少网络延迟和丢包率。
  4. 使用缓存机制：通过缓存机制减少对消息存储系统的访问次数，提高性能。
  5. 优化消息处理逻辑：优化消息处理逻辑，减少不必要的计算和资源消耗。
容灾与故障转移策略

RocketMQ支持容灾和故障转移策略，以提高系统的可用性和稳定性。

  1. 多副本备份：通过配置多副本备份，可以在主节点发生故障时自动切换到备份节点。
  2. 负载均衡：通过负载均衡策略，将流量均匀地分配到不同的节点，避免单点故障。
  3. 消息重试机制：通过消息重试机制，可以自动重新发送失败的消息，提高消息的可靠性。
  4. 集群扩展：通过扩展集群规模，提高系统的容灾能力和故障恢复能力。
日志与监控

为了更好地管理和维护RocketMQ，需要对系统的日志和监控进行管理和分析。

  1. 日志管理：RocketMQ提供了丰富的日志记录功能，可以记录系统运行的各种信息，包括错误日志、操作日志等。
  2. 监控系统：通过监控系统可以实时监控RocketMQ的运行状态，包括消息的发送和消费情况、系统的资源使用情况等。
  3. 报警机制：通过报警机制可以在系统出现异常时及时通知管理员，以便及时采取措施。
  4. 性能分析：通过性能分析工具可以对系统的性能进行深入分析，找出性能瓶颈并进行优化。

通过以上措施，可以确保RocketMQ系统的稳定运行和高效管理。

点击查看更多内容
发表于 2024.11.27 01:13， 共 66 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

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

评论

作者其他优质文章

正在加载中

函数式编程

手记
篇
粉丝
14
获赞与收藏
30

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消