RocketMQ安装与集群配置实战-优快云博客

本文详细介绍了RocketMQ的安装过程，包括在Linux服务器上的解压、启动和关闭RocketMQ服务，以及集群配置和消息发送与接收。还涵盖了如何调整JVM内存，配置防火墙和端口，启动nameserver和Broker，以及监控配置和消息过滤方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、RocketMQ安装

下载地址：http://rocketmq.apache.org/dowloading/releases/

2、上传linux服务器并解压

2.1 启动rocketmq

2.1.1启动nameserver

a.启动nameserver

nohup sh /usr/soft/rocketmq-all-4.8.0-bin-release/bin/mqnamesrv &

b.查看日志

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

2.1.2启动Broker

a.启动Broker

nohup sh /usr/soft/rocketmq-all-4.8.0-bin-release/bin/mqbroker -n localhost:9876 &

b.查看日志

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

2.2关闭rocketmq

2.2.1关闭nameserver

sh /usr/soft/rocketmq-all-4.8.0-bin-release/bin/mqshutdown namesrv

2.2.1关闭Broker

sh /usr/soft/rocketmq-all-4.8.0-bin-release/bin/mqshutdown broker

问题描述：
       RockerMQ默认的虚拟机内存较大，启动Broker如果因为内存不足失败，需要编辑如下两个文件，修改jvm内存大小
           vi runbroker.sh
           JAVA_OPT="${JAVA_OPT} -server -Xms256m -Xmx256m -Xmn128m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m"
           vi runserver.sh

2.3 jps命令查看进程是否启动关闭正常

3、rocketmq 集群

3.1集群分类

多master
多master多slave 同步
多master多slave 异步

4、集群部署

4.1准备两套rocketmq环境

4.2配置host信息

vi /etc/host

#nameserver
192.168.0.102	rocketmq-nameserver1
192.168.0.103	rocketmq-nameserver2
#broker
192.168.0.102	rocketmq-master1
192.168.0.102	rocketmq-slave2
192.168.0.103	rocketmq-master2
192.168.0.103	rocketmq-slave1

4.3配置完成后重启网卡

systemctl restart network

4.4打开网络访问权限

4.4.1关闭防火墙

关闭防火墙
systemctl stop firewalld.service
查看防火墙状态
firewall-cmd --state
禁止firewalld开机启动
systemctl disable firewalld.service

4.4.2开发特定的端口

RocketMQ默认使用3个端口，9876、10911、11011

nameserver默认使用 9876

master默认使用 10911

slave默认使用 11011

执行以下命令
#开放name server端口
firewall-cmd --remove-port=9876/tcp --permanent
#开放master端口
firewall-cmd --remove-port=10911/tcp --permanent
#开放slave端口
firewall-cmd --remove-port=11011/tcp --permanent
#重启防火墙
firewall-cmd --reload

4.5配置环境变量信息

vi /etc/profile

在profile文件未追加如下信息

#set rocketmq
ROCKETMQ_HOME=/usr/soft/rocketmq-all-4.8.0-bin-release
PATH=$PATH:$ROCKETMQ_HOME/bin
export ROCKETMQ_HOME PATH
保存退出，并使得配置立即生效：
source /etc/profile

4.6配置消息存放路径

mkdir /usr/soft/rocketmq/store
mkdir /usr/soft/rocketmq/store/commitlog
mkdir /usr/soft/rocketmq/store/consumequeue
mkdir /usr/soft/rocketmq/store/index

4.7broker配置文件（双主双从同步）

rocketmq-master1 主broker broker-a.properties

brokerClusterName=rocketmq-cluster
brokerName=broker-a
#集群中 0 表示 Master，>0 表示 Slave
brokerId=0
brokerRole=SYNC_MASTER
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=SYNC_FLUSH

#指定broker的IP
#brokerIP1=192.168.8.113
#nameServer地址，集群用分号分割
namesrvAddr=rocketmq-master1:9876;rocketmq-master2:9876
#在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4
#是否允许 Broker 自动创建Topic，建议线下开启，线上关闭
autoCreateTopicEnable=true
#是否允许 Broker 自动创建订阅组，建议线下开启，线上关闭
autoCreateSubscriptionGroup=true
#Broker 对外服务的监听端口
listenPort=10911
#删除文件时间点，默认凌晨 4点
deleteWhen=04
#文件保留时间，默认 48 小时
fileReservedTime=120
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条，根据业务情况调整
mapedFileSizeConsumeQueue=300000
#destroyMapedFileIntervalForcibly=120000
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=88
#存储路径
storePathRootDir=/usr/soft/rocketmq/store

#commitLog 存储路径
storePathCommitLog=/usr/soft/rocketmq/store/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/usr/soft/rocketmq/store/consumequeue
#消息索引存储路径
storePathIndex=/usr/soft/rocketmq/store/index
#checkpoint 文件存储路径
storeCheckpoint=/usr/soft/rocketmq/store/checkpoint
#abort 文件存储路径
abortFile=/usr/soft/rocketmq/store/abort
#限制的消息大小
maxMessageSize=65536
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000

#checkTransactionMessageEnable=false
#发消息线程池数量
sendMessageThreadPoolNums=128
#拉消息线程池数量
#pullMessaeThreadPoolNums=128

#发送消息是否使用可重入锁
useReentrantLockWhenPutMessage=true
waitTimeMillsInSendQueue=300  #或者更大

rocketmq-master1 从broker broker-b-s.properties

brokerClusterName=rocketmq-cluster
brokerName=broker-b
#集群中 0 表示 Master，>0 表示 Slave
brokerId=1
brokerRole=SLAVE
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=ASYNC_FLUSH

#指定broker的IP
#brokerIP1=192.168.8.113
#nameServer地址，集群用分号分割
namesrvAddr=rocketmq-master1:9876;rocketmq-master2:9876
#在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4
#是否允许 Broker 自动创建Topic，建议线下开启，线上关闭
autoCreateTopicEnable=true
#是否允许 Broker 自动创建订阅组，建议线下开启，线上关闭
autoCreateSubscriptionGroup=true
#Broker 对外服务的监听端口
listenPort=11011
#删除文件时间点，默认凌晨 4点
deleteWhen=04
#文件保留时间，默认 48 小时
fileReservedTime=120
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条，根据业务情况调整
mapedFileSizeConsumeQueue=300000
#destroyMapedFileIntervalForcibly=120000
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=88
#存储路径
storePathRootDir=/usr/soft/rocketmq/store2
#commitLog 存储路径

storePathCommitLog=/usr/soft/rocketmq/store2/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/usr/soft/rocketmq/store2/consumequeue
#消息索引存储路径
storePathIndex=/usr/soft/rocketmq/store2/index
#checkpoint 文件存储路径
storeCheckpoint=/usr/soft/rocketmq/store2/checkpoint
#abort 文件存储路径
abortFile=/usr/soft/rocketmq/store2/abort
#限制的消息大小
maxMessageSize=65536
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000

#checkTransactionMessageEnable=false
#发消息线程池数量
sendMessageThreadPoolNums=128
#拉消息线程池数量
#pullMessaeThreadPoolNums=128

#发送消息是否使用可重入锁
useReentrantLockWhenPutMessage=true
waitTimeMillsInSendQueue=300  #或者更大

rocketmq-master2 主broker broker-b.properties

brokerClusterName=rocketmq-cluster
brokerName=broker-b
#集群中 0 表示 Master，>0 表示 Slave
brokerId=0
brokerRole=SYNC_MASTER
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=SYNC_FLUSH

#指定broker的IP
#brokerIP1=192.168.8.113
#nameServer地址，集群用分号分割
namesrvAddr=rocketmq-master1:9876;rocketmq-master2:9876
#在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4
#是否允许 Broker 自动创建Topic，建议线下开启，线上关闭
autoCreateTopicEnable=true
#是否允许 Broker 自动创建订阅组，建议线下开启，线上关闭
autoCreateSubscriptionGroup=true
#Broker 对外服务的监听端口
listenPort=10911
#删除文件时间点，默认凌晨 4点
deleteWhen=04
#文件保留时间，默认 48 小时
fileReservedTime=120
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条，根据业务情况调整
mapedFileSizeConsumeQueue=300000
#destroyMapedFileIntervalForcibly=120000
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=88
#存储路径
storePathRootDir=/usr/soft/rocketmq/store
#commitLog 存储路径
storePathCommitLog=/usr/soft/rocketmq/store/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/usr/soft/rocketmq/store/consumequeue
#消息索引存储路径
storePathIndex=/usr/soft/rocketmq/store/index
#checkpoint 文件存储路径
storeCheckpoint=/usr/soft/rocketmq/store/checkpoint
#abort 文件存储路径
abortFile=/usr/soft/rocketmq/store/abort
#限制的消息大小
maxMessageSize=65536
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000

#checkTransactionMessageEnable=false
#发消息线程池数量
sendMessageThreadPoolNums=128
#拉消息线程池数量
#pullMessaeThreadPoolNums=128

#发送消息是否使用可重入锁
useReentrantLockWhenPutMessage=true
waitTimeMillsInSendQueue=300  #或者更大

rocketmq-master2 从broker broker-a-s.properties

brokerClusterName=rocketmq-cluster
brokerName=broker-a
#集群中 0 表示 Master，>0 表示 Slave
brokerId=1
brokerRole=SLAVE
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=ASYNC_FLUSH

#指定broker的IP
#brokerIP1=192.168.8.113
#nameServer地址，集群用分号分割
namesrvAddr=rocketmq-master1:9876;rocketmq-master2:9876
#在发送消息时，自动创建服务器不存在的topic，默认创建的队列数
defaultTopicQueueNums=4
#是否允许 Broker 自动创建Topic，建议线下开启，线上关闭
autoCreateTopicEnable=true
#是否允许 Broker 自动创建订阅组，建议线下开启，线上关闭
autoCreateSubscriptionGroup=true
#Broker 对外服务的监听端口
listenPort=11011
#删除文件时间点，默认凌晨 4点
deleteWhen=04
#文件保留时间，默认 48 小时
fileReservedTime=120
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条，根据业务情况调整
mapedFileSizeConsumeQueue=300000
#destroyMapedFileIntervalForcibly=120000
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=88
#存储路径
storePathRootDir=/usr/soft/rocketmq/store2
#commitLog 存储路径

storePathCommitLog=/usr/soft/rocketmq/store2/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/usr/soft/rocketmq/store2/consumequeue
#消息索引存储路径
storePathIndex=/usr/soft/rocketmq/store2/index
#checkpoint 文件存储路径
storeCheckpoint=/usr/soft/rocketmq/store2/checkpoint
#abort 文件存储路径
abortFile=/usr/soft/rocketmq/store2/abort
#限制的消息大小
maxMessageSize=65536
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000

#checkTransactionMessageEnable=false
#发消息线程池数量
sendMessageThreadPoolNums=128
#拉消息线程池数量
#pullMessaeThreadPoolNums=128

#发送消息是否使用可重入锁
useReentrantLockWhenPutMessage=true
waitTimeMillsInSendQueue=300  #或者更大

4.8 修改启动脚本文件

4.8.1 runbroker.sh

vi runbroker.sh            
JAVA_OPT="${JAVA_OPT} -server -Xms256m -Xmx256m -Xmn128m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m"

4.8.2 runserver.sh

vi runserver.sh
JAVA_OPT="${JAVA_OPT} -server -Xms256m -Xmx256m -Xmn128m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m"

4.9 服务启动

4.9.1 nameserver集群启动

两台集群都启动如下命令

nohup sh /usr/soft/rocketmq-all-4.8.0-bin-release/bin/mqnamesrv &

4.9.2broker集群启动

rocketmq-master1上启动

master1

cd  /usr/soft/rocketmq-all-4.8.0-bin-release/bin/
nohup sh mqbroker -c /usr/soft/rocketmq-all-4.8.0-bin-release/conf/2m-2s-sync/broker-a.properties &

salve2

cd  /usr/soft/rocketmq-all-4.8.0-bin-release/bin/
nohup sh mqbroker -c /usr/soft/rocketmq-all-4.8.0-bin-release/conf/2m-2s-sync/broker-b-s.properties &

rocketmq-master2

master2

cd  /usr/soft/rocketmq-all-4.8.0-bin-release/bin/
nohup sh mqbroker -c /usr/soft/rocketmq-all-4.8.0-bin-release/conf/2m-2s-sync/broker-b.properties &

salve1

cd  /usr/soft/rocketmq-all-4.8.0-bin-release/bin/
nohup sh mqbroker -c /usr/soft/rocketmq-all-4.8.0-bin-release/conf/2m-2s-sync/broker-a-s.properties &

5.mqadmin 命令

参考：https://www.iteye.com/blog/jameswxx-2091971

6.rocketmq监控配置

6.1 到https://github.com/ 查找 rocketmq-externals 开源项目，clone到本地

6.2 找到 rocketmq-console 工程并修改其配置文件 application.properties

修改其中： rocketmq.config.namesrvAddr=你的rokcketmq机器1ip:9876;rokcketmq机器2ip:9876;

6.3 在项目pom.xml 文件所在目录下运行一下命令打包工程

mvn clean package -Dmaven.test.skip=true

打包后的jar文件在 \target目录下

将此jar文件上传至 rocketmq服务器上

运行 nohup java -jar rocketmq-console-ng-2.0.0.jar 启动服务

6.4 打开监控页面

http://ip:8080

7. rocketmq消息发送和接收

7.1 创建demo工程，并导入依赖

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

7.2 消息发送和接收步骤

7.2.1消息发送者

创建生产者producer，并制定生产者组名
指定nameServer地址
启动producer
创建消息对象，指定Topic、Tag和消息体
发送消息
关闭生产者

7.2.2消息消费者

创建消费者consumer，并制定消费者组名
指定nameServer地址
订阅Topic、Tag
设置回调函数，处理消息
启动消费者consumer

7.3同步消息发送

package com.learn.mq.rocketmq.base.producer;

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

import java.nio.charset.StandardCharsets;
import java.security.ProtectionDomain;
import java.util.concurrent.TimeUnit;

public class SyncProducer {
    public static void main(String[] args) throws Exception {
        //1.创建生产者producer，并制定生产者组名
        DefaultMQProducer producer=new DefaultMQProducer("sync-producer-01");
        //2.指定nameServer地址
        producer.setNamesrvAddr("192.168.0.102:9876;192.168.0.103:9876");
        //3.启动producer
        producer.start();
        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定Topic、Tag和消息体
            /**
             * arg1:消息主题 Topic
             * arg2:消息Tag
             * arg3:消息内容
             */
            Message msg=new Message("base","baseTag-sync",("Hello rocketmq"+i).getBytes(StandardCharsets.UTF_8));
            //5.发送消息
            SendResult result = producer.send(msg);
            System.out.println("消息发送结果："+result);
            //线程休眠一秒
            TimeUnit.SECONDS.sleep(1);
        }
        //6.关闭生产者
        producer.shutdown();
    }
}

7.4异步消息发送

package com.learn.mq.rocketmq.base.producer;

import org.apache.rocketmq.client.exception.MQClientException;
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 java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;

public class AsyncProducer {
    public static void main(String[] args) throws Exception {
        //1.创建生产者producer，并制定生产者组名
        DefaultMQProducer producer=new DefaultMQProducer("Async-producer-01");
        //2.指定nameServer地址
        producer.setNamesrvAddr("192.168.0.102:9876;192.168.0.103:9876");
        //3.启动producer
        producer.start();
        for (int i = 0; i < 20; i++) {
            //4.创建消息对象，指定Topic、Tag和消息体
            /**
             * arg1:消息主题 Topic
             * arg2:消息Tag
             * arg3:消息内容
             */
            Message message=new Message("base","baseTag-async",("Hi Async-rocketmq"+i).getBytes(StandardCharsets.UTF_8));
            //5.发送异步消息
            producer.send(message, new SendCallback() {
                /**
                 * 发送成功回调函数
                 * @param sendResult
                 */
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.println("发送结果"+sendResult);
                }

                /**
                 * 发送失败回调函数
                 * @param throwable
                 */
                @Override
                public void onException(Throwable throwable) {
                    System.out.println("发送异常返回"+throwable);
                }
            });
            //线程休眠一秒
            TimeUnit.SECONDS.sleep(1);
        }
    }
}

7.5 单向消息发送

package com.learn.mq.rocketmq.base.producer;

import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
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.exception.RemotingException;

import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;

public class OneWayProducer {
    public static void main(String[] args) throws Exception {
        //1.创建生产者producer，并制定生产者组名
        DefaultMQProducer producer=new DefaultMQProducer("oneway-producer-01");
        //2.指定nameServer地址
        producer.setNamesrvAddr("192.168.0.102:9876;192.168.0.103:9876");
        //3.启动producer
        producer.start();
        for (int i = 0; i < 20; i++) {
            //4.创建消息对象，指定Topic、Tag和消息体
            /**
             * arg1:消息主题 Topic
             * arg2:消息Tag
             * arg3:消息内容
             */
            Message msg=new Message("base","baseTag-oneWay",("Hello 单项发送 rocketmq"+i).getBytes(StandardCharsets.UTF_8));
            //5.发送消息
            producer.sendOneway(msg);
            //线程休眠一秒
            TimeUnit.SECONDS.sleep(1);
        }
        //6.关闭生产者
        producer.shutdown();
    }
}

7.6消费者消费消息

package com.learn.mq.rocketmq.base.consumer;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.创建消费者consumer，并制定消费者组名
        DefaultMQPushConsumer consumer=new DefaultMQPushConsumer("group1");
        //2.指定nameServer地址
        consumer.setNamesrvAddr("192.168.0.102:9876;192.168.0.103:9876");
        //3.订阅Topic、Tag
        consumer.subscribe("base","baseTag-sync");
        //设置消息模式：负载均衡 CLUSTERING / 广播模式 BROADCASTING
        consumer.setMessageModel(MessageModel.BROADCASTING);
        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            //接收消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg:list) {
                    byte[] body = msg.getBody();
                    System.out.println(new String(body));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();
    }
}

7.6.1 设置消费模式负载均衡 /广播模式

//设置消息模式：负载均衡 CLUSTERING / 广播模式 BROADCASTING
        consumer.setMessageModel(MessageModel.BROADCASTING);

7.7 消息发送保证顺序消费

7.7.1 构造消息集合

package com.learn.mq.rocketmq.order;

import java.util.ArrayList;
import java.util.List;

/**
 * 订单构造者
 */
public class OrderStep {
    private long orderId;
    private String orderDesc;

    public long getOrderId() {
        return orderId;
    }

    public void setOrderId(long orderId) {
        this.orderId = orderId;
    }

    public String getOrderDesc() {
        return orderDesc;
    }

    public void setOrderDesc(String orderDesc) {
        this.orderDesc = orderDesc;
    }

    @Override
    public String toString() {
        return "OrderStep{" +
                "orderId=" + orderId +
                ", orderDesc='" + orderDesc + '\'' +
                '}';
    }
    public static List<OrderStep> buildOrders(){
        List<OrderStep> list=new ArrayList<>();
        OrderStep orderStep=new OrderStep();
        orderStep.setOrderId(20210112001l);
        orderStep.setOrderDesc("创建订单");
        list.add(orderStep);
        orderStep=new OrderStep();
        orderStep.setOrderId(20210112001l);
        orderStep.setOrderDesc("支付订单");
        list.add(orderStep);
        orderStep=new OrderStep();
        orderStep.setOrderId(20210112001l);
        orderStep.setOrderDesc("发送请求");
        list.add(orderStep);
        orderStep=new OrderStep();
        orderStep.setOrderId(20210112001l);
        orderStep.setOrderDesc("完成订单");
        list.add(orderStep);
        orderStep=new OrderStep();
        orderStep.setOrderId(20210112002l);
        orderStep.setOrderDesc("创建订单");
        list.add(orderStep);
        orderStep=new OrderStep();
        orderStep.setOrderId(20210112002l);
        orderStep.setOrderDesc("支付订单");
        list.add(orderStep);
        orderStep=new OrderStep();
        orderStep.setOrderId(20210112002l);
        orderStep.setOrderDesc("完成订单");
        list.add(orderStep);
        orderStep=new OrderStep();
        orderStep.setOrderId(20210112003l);
        orderStep.setOrderDesc("创建订单");
        list.add(orderStep);
        orderStep=new OrderStep();
        orderStep.setOrderId(20210112003l);
        orderStep.setOrderDesc("发送请求");
        list.add(orderStep);
        orderStep=new OrderStep();
        orderStep.setOrderId(20210112003l);
        orderStep.setOrderDesc("完成订单");
        list.add(orderStep);
        return list;
    }
}

7.7.3 发送消息

package com.learn.mq.rocketmq.order;

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue;

import java.nio.charset.StandardCharsets;
import java.util.List;

public class Producer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer=new DefaultMQProducer("messageOrder");
        producer.setNamesrvAddr("192.168.0.102:9876;192.168.0.103:9876");
        producer.start();
        List<OrderStep> orderSteps=OrderStep.buildOrders();
        for(int i=0;i<orderSteps.size();i++){
            String order=orderSteps.get(i)+"";
            Message message=new Message("order","orderMessage","i:"+i,order.getBytes(StandardCharsets.UTF_8));
            /**
             * arg1 消息
             * arg2 消息队列的选择器
             * arg3 选择队列的业务标识
             */
            SendResult sendResult = producer.send(message, new MessageQueueSelector() {
                /**
                 *
                 * @param list 队列集合
                 * @param message   消息对象
                 * @param o 业务标识的参数
                 * @return
                 */
                @Override
                public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                    Long orderId = (Long) o;
                    long index = orderId % list.size();
                    return list.get((int) index);
                }
            }, orderSteps.get(i).getOrderId());
            System.out.println("消息发送结果："+sendResult);
        }
    }
}

7.7.4 消费消息

package com.learn.mq.rocketmq.order;

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.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.List;

public class Consumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer=new DefaultMQPushConsumer("orderConsumer");
        consumer.setNamesrvAddr("192.168.0.102:9876;192.168.0.103:9876");
        consumer.subscribe("order","orderMessage");
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
                for (MessageExt msg:list){
                    System.out.println("用户"+Thread.currentThread().getName()+"处理消息："+new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        consumer.start();
    }
}

7.5设置延迟发送消息

//设置延迟发送消息
msg.setDelayTimeLevel(2);

7.6 消息批量发送

package com.learn.mq.rocketmq.batch;

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

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

public class Producer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer=new DefaultMQProducer("batch-producer");
        producer.setNamesrvAddr("192.168.0.102:9876;192.168.0.103:9876");
        producer.start();
        Message message1=new Message("batch-producer","batch","Hello btach1".getBytes(StandardCharsets.UTF_8));
        Message message2=new Message("batch-producer","batch","Hello btach2".getBytes(StandardCharsets.UTF_8));
        Message message3=new Message("batch-producer","batch","Hello btach3".getBytes(StandardCharsets.UTF_8));
        List<Message> list=new ArrayList<>();
        list.add(message1);
        list.add(message2);
        list.add(message3);
        SendResult sendResult = producer.send(list);
        System.out.println("发送结果："+sendResult);
        producer.shutdown();
    }
}

注：消费发送的包不能大于 4MB

8. 消息过滤

8.1Tag形式过滤

consumer.subscribe("filter-tag","filter5 || filter6  || filter9");
或者
consumer.subscribe("filter-tag","*");