RocketMQ（一）—— 基本使用

已于 2022-10-15 15:13:13 修改
阅读量1.8k 收藏 6
点赞数 2
分类专栏： 微服务技术 文章标签： zookeeper spring 5 缓存
于 2021-12-01 15:40:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56697114/article/details/121592517
版权

目录

1、RocketMQ基本使用

1、启动

2、测试

3、关闭 

2、集群简介

 特点：

集群模式：

工作流程

3、双主双从集群搭建

关闭防火墙

环境变量配置

创建消息存储路径

broker配置文件

启动

集群监控平台搭建

4、消息发送

1、基本样例

1、消息发送

2、消费信息

2、顺序消息

3、延时消息

4、批量消息发送

5、过滤消息

6、事物消息

（1）事务消息发送及提交

（2）事务补偿

（3）事务消息状态

 使用限制

5、springboot整合

1、RocketMQ基本使用

1、启动

1.启动NameServer

# 1.启动NameServer
nohup sh bin/mqnamesrv &
# 2.查看启动日志
tail -f ~/logs/rocketmqlogs/namesrv.log
或者为
nohup sh bin/mqnamesrv > /dev/null 2>&1 &

2.启动Broker

# 1.启动Broker
nohup sh bin/mqbroker -n localhost:9876 &
# 2.查看启动日志
tail -f ~/logs/rocketmqlogs/broker.log 
nohup sh mqbroker -n localhost:9876 -c /root/rocketMQ/rocketmq-all-4.4.0-bin-release/conf/broker.conf autoCreateTopicEnable=true > /dev/null 2>&1 &

启动失败：RocketMQ默认的虚拟机内存较大，启动Broker如果因为内存不足失败，需要编辑如下两个配置文件（在bin中），修改JVM内存大小

# 编辑runbroker.sh和runserver.sh修改默认JVM大小
vi runbroker.sh
vi runserver.sh

2、测试

1.发送消息

# 1.设置环境变量
export NAMESRV_ADDR=localhost:9876
# 2.使用安装包的Demo发送消息
sh bin/tools.sh org.apache.rocketmq.example.quickstart.Producer

2.接收消息

# 1.设置环境变量
export NAMESRV_ADDR=localhost:9876
# 2.接收消息
sh bin/tools.sh org.apache.rocketmq.example.quickstart.Consumer

3、关闭 

# 1.关闭NameServer
sh bin/mqshutdown namesrv
# 2.关闭Broker
sh bin/mqshutdown broker

2、集群简介

  • Producer：消息的发送者；举例：发信者

  • Consumer：消息接收者；举例：收信者

  • Broker：暂存和传输消息；举例：邮局

  • NameServer：管理Broker；举例：各个邮局的管理机构

  • Topic：区分消息的种类；一个发送者可以发送消息给一个或者多个Topic；一个消息的接收者可以订阅一个或者多个Topic消息

  • Message Queue：相当于是Topic的分区；用于并行发送和接收消息

 特点：

  • NameServer是一个几乎无状态节点，可集群部署，节点之间无任何信息同步。

  • Broker部署相对复杂，Broker分为Master与Slave。一个Master可以对应多个Slave，但是一个Slave只能对应一个Master。Master与Slave的对应关系通过指定相同的BrokerName，不同的BrokerId来定义，BrokerId为0表示Master，非0表示Slave。Master也可以部署多个。每个Broker与NameServer集群中的所有节点建立长连接，定时注册Topic信息到所有NameServer。

  • Producer与NameServer集群中的其中一个节点（随机选择）建立长连接，定期从NameServer取Topic路由信息，并向提供Topic服务的Master建立长连接，且定时向Master发送心跳。Producer完全无状态，可集群部署。

  • Consumer与NameServer集群中的其中一个节点（随机选择）建立长连接，定期从NameServer取Topic路由信息，并向提供Topic服务的Master、Slave建立长连接，且定时向Master、Slave发送心跳。Consumer既可以从Master订阅消息，也可以从Slave订阅消息，订阅规则由Broker配置决定。

集群模式：

（1）单Master模式

这种方式风险较大，一旦Broker重启或者宕机时，会导致整个服务不可用。不建议线上环境使用,可以用于本地测试。

（2）多Master模式

一个集群无Slave，全是Master，例如2个Master或者3个Master，这种模式的优缺点如下：

  • 优点：配置简单，单个Master宕机或重启维护对应用无影响，在磁盘配置为RAID10时，即使机器宕机不可恢复情况下，由于RAID10磁盘非常可靠，消息也不会丢（异步刷盘丢失少量消息，同步刷盘一条不丢），性能最高；

  • 缺点：单台机器宕机期间，这台机器上未被消费的消息在机器恢复之前不可订阅，消息实时性会受到影响。

（3）多Master多Slave模式（异步）

每个Master配置一个Slave，有多对Master-Slave，HA采用异步复制方式，主备有短暂消息延迟（毫秒级），这种模式的优缺点如下：

  • 优点：即使磁盘损坏，消息丢失的非常少，且消息实时性不会受影响，同时Master宕机后，消费者仍然可以从Slave消费，而且此过程对应用透明，不需要人工干预，性能同多Master模式几乎一样；

  • 缺点：Master宕机，磁盘损坏情况下会丢失少量消息。

（4）多Master多Slave模式（同步）

每个Master配置一个Slave，有多对Master-Slave，HA采用同步双写方式，即只有主备都写成功，才向应用返回成功，这种模式的优缺点如下：

  • 优点：数据与服务都无单点故障，Master宕机情况下，消息无延迟，服务可用性与数据可用性都非常高；

  • 缺点：性能比异步复制模式略低（大约低10%左右），发送单个消息的RT会略高，且目前版本在主节点宕机后，备机不能自动切换为主机。

工作流程

  1. 启动NameServer，NameServer起来后监听端口，等待Broker、Producer、Consumer连上来，相当于一个路由控制中心。

  2. Broker启动，跟所有的NameServer保持长连接，定时发送心跳包。心跳包中包含当前Broker信息(IP+端口等)以及存储所有Topic信息。注册成功后，NameServer集群中就有Topic跟Broker的映射关系。

  3. 收发消息前，先创建Topic，创建Topic时需要指定该Topic要存储在哪些Broker上，也可以在发送消息时自动创建Topic。

  4. Producer发送消息，启动时先跟NameServer集群中的其中一台建立长连接，并从NameServer中获取当前发送的Topic存在哪些Broker上，轮询从队列列表中选择一个队列，然后与队列所在的Broker建立长连接从而向Broker发消息。

  5. Consumer跟Producer类似，跟其中一台NameServer建立长连接，获取当前订阅Topic存在哪些Broker上，然后直接跟Broker建立连接通道，开始消费消息。

3、双主双从集群搭建

准备两个虚拟机（都要进行配置）

编辑 /etc/hosts：

# nameserver
192.168.126.131 rocketmq-nameserver1
192.168.126.132 rocketmq-nameserver2
# broker
192.168.126.131 rocketmq-master1
192.168.126.131 rocketmq-slave2
192.168.126.132 rocketmq-master2
192.168.126.132 rocketmq-slave1

 配置完成后, 重启网卡

systemctl restart network

关闭防火墙

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

或者为了安全，只开放特定的端口号，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

环境变量配置

添加到 /etc / profile

#set rocketmq
ROCKETMQ_HOME=/root/rocketMQ/rocketmq-all-4.4.0-bin-release
PATH=$PATH:$ROCKETMQ_HOME/bin
export ROCKETMQ_HOME PATH
source /etc/profile

创建消息存储路径

mkdir /root/rocketMQ/store
mkdir /root/rocketMQ/store/commitlog
mkdir /root/rocketMQ/store/consumequeue
mkdir /root/rocketMQ/store/index

slave： 

mkdir /root/rocketMQ/store2
mkdir /root/rocketMQ/store2/commitlog
mkdir /root/rocketMQ/store2/consumequeue
mkdir /root/rocketMQ/store2/index

broker配置文件

131配置 m1、s2（还要加上 brokerIP1=192.168.126.131），132配置m2、s1（还要加上 brokerIP1=192.168.126.132）

添加：↓ 开启 sql过滤

enablePropertyFilter=true

 m1

#所属集群名字
brokerClusterName=rocketmq-cluster
#broker名字，注意此处不同的配置文件填写的不一样
brokerName=broker-a
#0 表示 Master，>0 表示 Slave
brokerId=0
#nameServer地址，分号分割
namesrvAddr=rocketmq-nameserver1:9876;rocketmq-nameserver2: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=/root/rocketMQ/store
#commitLog 存储路径
storePathCommitLog=/root/rocketMQ/store/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/root/rocketMQ/store/consumequeue
#消息索引存储路径
storePathIndex=/root/rocketMQ/store/index
#checkpoint 文件存储路径
storeCheckpoint=/root/rocketMQ/store/checkpoint
#abort 文件存储路径
abortFile=/root/rocketMQ/store/abort
#限制的消息大小
maxMessageSize=65536
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
brokerRole=SYNC_MASTER
#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=SYNC_FLUSH
#checkTransactionMessageEnable=false
#发消息线程池数量
#sendMessageThreadPoolNums=128
#拉消息线程池数量
#pullMessageThreadPoolNums=128

 s2

#所属集群名字
brokerClusterName=rocketmq-cluster
#broker名字，注意此处不同的配置文件填写的不一样
brokerName=broker-b
#0 表示 Master，>0 表示 Slave
brokerId=1
#nameServer地址，分号分割
namesrvAddr=rocketmq-nameserver1:9876;rocketmq-nameserver2: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=/root/rocketMQ/store2
#commitLog 存储路径
storePathCommitLog=/root/rocketMQ/store2/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/root/rocketMQ/store2/consumequeue
#消息索引存储路径
storePathIndex=/root/rocketMQ/store2/index
#checkpoint 文件存储路径
storeCheckpoint=/root/rocketMQ/store2/checkpoint
#abort 文件存储路径
abortFile=/root/rocketMQ/store2/abort
#限制的消息大小
maxMessageSize=65536
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
brokerRole=SLAVE
#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=ASYNC_FLUSH
#checkTransactionMessageEnable=false
#发消息线程池数量
#sendMessageThreadPoolNums=128
#拉消息线程池数量
#pullMessageThreadPoolNums=128

m2

#所属集群名字
brokerClusterName=rocketmq-cluster
#broker名字，注意此处不同的配置文件填写的不一样
brokerName=broker-b
#0 表示 Master，>0 表示 Slave
brokerId=0
#nameServer地址，分号分割
namesrvAddr=rocketmq-nameserver1:9876;rocketmq-nameserver2: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=/root/rocketMQ/store
#commitLog 存储路径
storePathCommitLog=/root/rocketMQ/store/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/root/rocketMQ/store/consumequeue
#消息索引存储路径
storePathIndex=/root/rocketMQ/store/index
#checkpoint 文件存储路径
storeCheckpoint=/root/rocketMQ/store/checkpoint
#abort 文件存储路径
abortFile=/root/rocketMQ/store/abort
#限制的消息大小
maxMessageSize=65536
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
brokerRole=SYNC_MASTER
#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=SYNC_FLUSH
#checkTransactionMessageEnable=false
#发消息线程池数量
#sendMessageThreadPoolNums=128
#拉消息线程池数量
#pullMessageThreadPoolNums=128

s1

#所属集群名字
brokerClusterName=rocketmq-cluster
#broker名字，注意此处不同的配置文件填写的不一样
brokerName=broker-a
#0 表示 Master，>0 表示 Slave
brokerId=1
#nameServer地址，分号分割
namesrvAddr=rocketmq-nameserver1:9876;rocketmq-nameserver2: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=/root/rocketMQ/store2
#commitLog 存储路径
storePathCommitLog=/root/rocketMQ/store2/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/root/rocketMQ/store2/consumequeue
#消息索引存储路径
storePathIndex=/root/rocketMQ/store2/index
#checkpoint 文件存储路径
storeCheckpoint=/root/rocketMQ/store2/checkpoint
#abort 文件存储路径
abortFile=/root/rocketMQ/store2/abort
#限制的消息大小
maxMessageSize=65536
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
brokerRole=SLAVE
#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=ASYNC_FLUSH
#checkTransactionMessageEnable=false
#发消息线程池数量
#sendMessageThreadPoolNums=128
#拉消息线程池数量
#pullMessageThreadPoolNums=128

启动

分别启动 nameserver

nohup sh mqnamesrv -n "192.168.126.131:9876" &

nohup sh mqnamesrv -n "192.168.126.132:9876" &

启动broker

m1

nohup sh mqbroker -c /root/rocketMQ/rocketmq-all-4.4.0-bin-release/conf/2m-2s-sync/broker-a.properties &

s2

nohup sh mqbroker -c /root/rocketMQ/rocketmq-all-4.4.0-bin-release/conf/2m-2s-sync/broker-b-s.properties &

m2

nohup sh mqbroker -c /root/rocketMQ/rocketmq-all-4.4.0-bin-release/conf/2m-2s-sync/broker-b.properties &

s1

nohup sh mqbroker -c /root/rocketMQ/rocketmq-all-4.4.0-bin-release/conf/2m-2s-sync/broker-a-s.properties &

查看日志信息

# 查看nameServer日志
tail -500f ~/logs/rocketmqlogs/namesrv.log
# 查看broker日志
tail -500f ~/logs/rocketmqlogs/broker.log

集群监控平台搭建

需要自己对rocketmq-console进行编译打包运行。

D:\学习总结\微服务\资料-全面解剖RocketMQ和项目实战\资料\rocketmq源码\rocketmq-externals-master\rocketmq-console\src\main\resources。

rocketmq.config.namesrvAddr=192.168.126.131:9876;192.168.126.132:9876

进入pom所在目录，进行打包

mvn clean package -Dmaven.test.skip=true
java -jar rocketmq-console-ng-1.0.0.jar

4、消息发送

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

1、基本样例

1、消息发送

1、发送同步消息

这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。

/**
 * 发送同步消息
 */
public class SyncProducer {

    public static void main(String[] args) throws Exception {

        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.126.131:9876;192.168.126.132:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("base", "Tag1", ("Hello World" + i).getBytes());
            //5.发送消息
            SendResult result = producer.send(msg);
            //发送状态
            SendStatus status = result.getSendStatus();
            //消息id
            String msgId = result.getMsgId();
            //消息接收队列的id
            int queueId = result.getMessageQueue().getQueueId();

            System.out.printf("发送状态：%n%s，消息id：%s，队列id：%d\n",result,msgId,queueId);

            //线程睡1秒
            TimeUnit.SECONDS.sleep(1);
        }

        System.out.println("关闭producer");
        //6.关闭生产者producer
        producer.shutdown();
    }
}

2、发送异步消息

异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。

/**
 * 发送异步消息
 */
public class AsyncProducer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.126.131:9876;192.168.126.132:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("base", "Tag2", ("异步消息：" + i).getBytes());
            //5.发送异步消息
            producer.send(msg, new SendCallback() {
                /**
                 * 发送成功回调函数
                 * @param sendResult
                 */
                public void onSuccess(SendResult sendResult) {
                    System.out.println("发送结果：" + sendResult);
                }

                /**
                 * 发送失败回调函数
                 * @param e
                 */
                public void onException(Throwable e) {
                    System.out.println("发送异常：" + e);
                }
            });

            //线程睡1秒
            TimeUnit.SECONDS.sleep(1);
        }

        //6.关闭生产者producer
        producer.shutdown();
    }
}

3、单向发送消息

这种方式主要用在不特别关心发送结果的场景，例如日志发送。

/**
 * 发送单向消息
 */
public class OneWayProducer {

    public static void main(String[] args) throws Exception, MQBrokerException {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.126.131:9876;192.168.126.132:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 3; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("base", "Tag3", ("Hello World，单向消息" + i).getBytes());
            //5.发送单向消息
            producer.sendOneway(msg);

            //线程睡1秒
            TimeUnit.SECONDS.sleep(5);
        }

        //6.关闭生产者producer
        producer.shutdown();
    }
}

2、消费信息

负载均衡模式（默认）：多个消费者处理不同的消息

广播模式：多个消费者处理相同的消息

/**
 * 消息的接受者
 */
public class Consumer {

    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.126.131:9876;192.168.126.132:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("base", "Tag1");

        //设定消费模式：负载均衡（默认）|广播模式
        consumer.setMessageModel(MessageModel.BROADCASTING);

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接受消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    //System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));
                    System.out.println(new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();
    }
}

2、顺序消息

消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。

一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个OrderId获取到的肯定是同一个队列。

public class Producer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.126.131:9876;192.168.126.132:9876");
        //3.启动producer
        producer.start();
        //构建消息集合
        List<OrderStep> orderSteps = OrderStep.buildOrders();
        //发送消息
        for (int i = 0; i < orderSteps.size(); i++) {
            String body = orderSteps.get(i) + "";
            Message message = new Message("OrderTopic", "Order", "i" + i, body.getBytes());
            /**
             * 参数一：消息对象
             * 参数二：消息队列的选择器
             * 参数三：选择队列的业务标识（订单ID）
             */
            SendResult sendResult = producer.send(message, new MessageQueueSelector() {
                /**
                 *
                 * @param mqs：队列集合
                 * @param msg：消息对象
                 * @param arg：业务标识的参数
                 * @return
                 */
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    long orderId = (long) arg;
                    long index = orderId % mqs.size();
                    return mqs.get((int) index);
                }
            }, orderSteps.get(i).getOrderId());

            System.out.println("发送结果：" + sendResult);
        }
        producer.shutdown();
    }

}

public class Consumer {
    public static void main(String[] args) throws MQClientException {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.126.131:9876;192.168.126.132:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("OrderTopic", "*");

        //4.注册消息监听器
        consumer.registerMessageListener(new MessageListenerOrderly() {

            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("线程名称：【" + Thread.currentThread().getName() + "】:" + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });

        //5.启动消费者
        consumer.start();

        System.out.println("消费者启动");

    }
}

3、延时消息

比如电商里，提交了一个订单就可以发送一个延时消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存。

现在RocketMq并不支持任意时间的延时，需要设置几个固定的延时等级，从1s到2h分别对应着等级1到18 

// org/apache/rocketmq/store/config/MessageStoreConfig.java
private String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";
        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("DelayTopic", "Tag1", ("Hello World" + i).getBytes());
            //设定延迟时间
            msg.setDelayTimeLevel(2);
            //5.发送消息
            SendResult result = producer.send(msg);
            //发送状态
            SendStatus status = result.getSendStatus();

            System.out.println("发送结果:" + result);

            //线程睡1秒
            TimeUnit.SECONDS.sleep(1);
        }
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接受消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("消息ID：【" + msg.getMsgId() + "】,延迟时间：" + (System.currentTimeMillis() - msg.getStoreTimestamp()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

4、批量消息发送

批量发送消息能显著提高传递小消息的性能。限制是这些批量消息应该有相同的topic，相同的waitStoreMsgOK，而且不能是延时消息。此外，这一批消息的总大小<=4MB。

        List<Message> msgs = new ArrayList<Message>();
        //4.创建消息对象，指定主题Topic、Tag和消息体
        /**
         * 参数一：消息主题Topic
         * 参数二：消息Tag
         * 参数三：消息内容
         */
        Message msg1 = new Message("BatchTopic", "Tag1", ("Hello World" + 1).getBytes());
        Message msg2 = new Message("BatchTopic", "Tag1", ("Hello World" + 2).getBytes());
        Message msg3 = new Message("BatchTopic", "Tag1", ("Hello World" + 3).getBytes());

        msgs.add(msg1);
        msgs.add(msg2);
        msgs.add(msg3);

        //5.发送消息
        SendResult result = producer.send(msgs);

如果消息的总长度可能大于4MB时，这时候最好把消息进行分割

public class ListSplitter implements Iterator<List<Message>> {
   private final int SIZE_LIMIT = 1024 * 1024 * 4;
   private final List<Message> messages;
   private int currIndex;
   public ListSplitter(List<Message> messages) {
           this.messages = messages;
   }
    @Override 
    public boolean hasNext() {
       return currIndex < messages.size();
   }
   	@Override 
    public List<Message> next() {
       int nextIndex = currIndex;
       int totalSize = 0;
       for (; nextIndex < messages.size(); nextIndex++) {
           Message message = messages.get(nextIndex);
           int tmpSize = message.getTopic().length() + message.getBody().length;
           Map<String, String> properties = message.getProperties();
           for (Map.Entry<String, String> entry : properties.entrySet()) {
               tmpSize += entry.getKey().length() + entry.getValue().length();
           }
           tmpSize = tmpSize + 20; // 增加日志的开销20字节
           if (tmpSize > SIZE_LIMIT) {
               //单个消息超过了最大的限制
               //忽略,否则会阻塞分裂的进程
               if (nextIndex - currIndex == 0) {
                  //假如下一个子列表没有元素,则添加这个子列表然后退出循环,否则只是退出循环
                  nextIndex++;
               }
               break;
           }
           if (tmpSize + totalSize > SIZE_LIMIT) {
               break;
           } else {
               totalSize += tmpSize;
           }

       }
       List<Message> subList = messages.subList(currIndex, nextIndex);
       currIndex = nextIndex;
       return subList;
   }
}
//把大的消息分裂成若干个小的消息
ListSplitter splitter = new ListSplitter(messages);
while (splitter.hasNext()) {
  try {
      List<Message>  listItem = splitter.next();
      producer.send(listItem);
  } catch (Exception e) {
      e.printStackTrace();
      //处理error
  }
}

5、过滤消息

在大多数情况下，TAG是一个简单而有用的设计，其可以来选择您想要的消息。例如：

consumer.subscribe("TOPIC", "TAGA || TAGB || TAGC");

可以使用SQL表达式筛选消息

RocketMQ只定义了一些基本语法来支持这个特性。你也可以很容易地扩展它。

  • 数值比较，比如：>，>=，<，<=，BETWEEN，=；

  • 字符比较，比如：=，<>，IN；

  • IS NULL 或者 IS NOT NULL；

  • 逻辑符号 AND，OR，NOT；

常量支持类型为：

  • 数值，比如：123，3.1415；

  • 字符，比如：'abc'，必须用单引号包裹起来；

  • NULL，特殊的常量

  • 布尔值，TRUE 或 FALSE

            Message msg = new Message("FilterSQLTopic", "Tag1", ("Hello World" + i).getBytes());
            //通过`putUserProperty`来设置消息的属性
            msg.putUserProperty("i", String.valueOf(i));
consumer.subscribe("FilterSQLTopic", MessageSelector.bySql("i>5"));

6、事物消息

正常事务消息的发送及提交、事务消息的补偿流程。

（1）事务消息发送及提交

(1) 发送消息（half消息）。

(2) 服务端响应消息写入结果。

(3) 根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）。

(4) 根据本地事务状态执行Commit或者Rollback（Commit操作生成消息索引，消息对消费者可见）

（2）事务补偿

(1) 对没有Commit/Rollback的事务消息（pending状态的消息），从服务端发起一次“回查”

(2) Producer收到回查消息，检查回查消息对应的本地事务的状态

(3) 根据本地事务状态，重新Commit或者Rollback

其中，补偿阶段用于解决消息Commit或者Rollback发生超时或者失败的情况。

（3）事务消息状态

事务消息共有三种状态，提交状态、回滚状态、中间状态：

  • TransactionStatus.CommitTransaction: 提交事务，它允许消费者消费此消息。

  • TransactionStatus.RollbackTransaction: 回滚事务，它代表该消息将被删除，不允许被消费。

  • TransactionStatus.Unknown: 中间状态，它代表需要检查消息队列来确定状态。

/**
 * 发送同步消息
 */
public class Producer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        TransactionMQProducer producer = new TransactionMQProducer("group5");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.126.131:9876;192.168.126.132:9876");

        //添加事务监听器
        producer.setTransactionListener(new TransactionListener() {
            /**
             * 在该方法中执行本地事务
             * @param msg
             * @param arg
             * @return
             */
            @Override
            public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
                if (StringUtils.equals("TAGA", msg.getTags())) {
                    //提交
                    return LocalTransactionState.COMMIT_MESSAGE;
                } else if (StringUtils.equals("TAGB", msg.getTags())) {
                    //回滚
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                } else if (StringUtils.equals("TAGC", msg.getTags())) {
                    //不做处理
                    return LocalTransactionState.UNKNOW;
                }
                return LocalTransactionState.UNKNOW;
            }

            /**
             * 该方法时MQ进行消息事务状态回查——对于不做处理的消息做具体处理
             * @param msg
             * @return
             */
            @Override
            public LocalTransactionState checkLocalTransaction(MessageExt msg) {
                System.out.println("消息的Tag:" + msg.getTags());
                return LocalTransactionState.COMMIT_MESSAGE;
            }
        });

        //3.启动producer
        producer.start();

        String[] tags = {"TAGA", "TAGB", "TAGC"};

        for (int i = 0; i < 3; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("TransactionTopic", tags[i], ("Hello World" + i).getBytes());
            //5.发送消息
            SendResult result = producer.sendMessageInTransaction(msg, null);
            //发送状态
            SendStatus status = result.getSendStatus();

            System.out.println("发送结果:" + result);

            //线程睡1秒
            TimeUnit.SECONDS.sleep(2);
        }

        //不用关闭生产者producer
        //producer.shutdown();
    }
}

 使用限制

  1. 事务消息不支持延时消息和批量消息。

  2. 为了避免单个消息被检查太多次而导致半队列消息累积，我们默认将单个消息的检查次数限制为 15 次，但是用户可以通过 Broker 配置文件的 transactionCheckMax参数来修改此限制。如果已经检查某条消息超过 N 次的话（ N = transactionCheckMax ） 则 Broker 将丢弃此消息，并在默认情况下同时打印错误日志。用户可以通过重写 AbstractTransactionCheckListener 类来修改这个行为。

  3. 事务消息将在 Broker 配置文件中的参数 transactionMsgTimeout 这样的特定时间长度之后被检查。当发送事务消息时，用户还可以通过设置用户属性 CHECK_IMMUNITY_TIME_IN_SECONDS 来改变这个限制，该参数优先于 transactionMsgTimeout 参数。

  4. 事务性消息可能不止一次被检查或消费。

  5. 提交给用户的目标主题消息可能会失败，目前这依日志的记录而定。它的高可用性通过 RocketMQ 本身的高可用性机制来保证，如果希望确保事务消息不丢失、并且事务完整性得到保证，建议使用同步的双重写入机制。

  6. 事务消息的生产者 ID 不能与其他类型消息的生产者 ID 共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者 ID 查询到消费者。

5、springboot整合

生产者

    <dependency>
        <groupId>org.apache.rocketmq</groupId>
        <artifactId>rocketmq-spring-boot-starter</artifactId>
        <version>${rocketmq-spring-boot-starter-version}</version>
    </dependency>
# application.properties
rocketmq.name-server=192.168.126.131:9876;192.168.126.132:9876
rocketmq.producer.group=my-group
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {MQSpringBootApplication.class})
public class ProducerTest {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @Test
    public void test1(){
        rocketMQTemplate.convertAndSend("springboot-mq","hello springboot rocketmq");
    }
}

消费者：依赖、配置一致

@Slf4j
@Component
@RocketMQMessageListener(topic = "springboot-mq",consumerGroup = "springboot-mq-consumer-1")
public class Consumer implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        log.info("Receive message："+message);
    }
}
但盼风雨来 能留你在此
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RocketMQ Schema——让消息成为流动的结构化数据
ApacheRocketMQ的博客
12-20 377
RocketMQ Schema 提供了对消息的数据结构托管服务，同时为原生客户端提供了较为丰富的序列化/反序列化 SDK ，补齐了 RocketMQ 在数据治理和业务上下游解耦方面的短板，让数据成为流动的结构化数据，那么快来了解下实现原理吧~
Kafka vs RocketMQ—— Topic数量对单机性能的影响1
08-03
测试结果显示，无论Topic数量如何，Kafka和RocketMQ都能保持发送端和消费端的TPS（每秒事务数）基本持平，确保消息不积压。然而，随着Topic数量的增加，Kafka的吞吐量下降明显，降幅达到98.37%，而RocketMQ的吞吐量...
RocketMQ 入门 —— 基于 Spring Boot 使用 RocketMQ
苏木力格的博客
04-20 677
1. 前言 2. Spring 中的消息框架 2.1 Spring Messaging 2.2 Spring Cloud Stream 3. spring-boot-starter 的实现 3.1 spring-boot-starter 的实现步骤 3.2 消息发送端实现 3.3. 消息消费端实现 4. 使用示例 4.1 RocketMQ 服务端的准备 4.2. 编译 rocketmq-spring-boot-starter 4.3. 编写客户端代码 5. 参考文档 上世纪 90 年代.
RocketMQ使用（1）：介绍与启动
最新发布
游王子的博客
05-22 784
消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题。实现高性能，高可用，可伸缩和最终一致性架构。使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ等。RocketMQ是阿里研发的一个队列模型的消息中间件，后开源给apache基金会成为了apache的顶级开源项目，具有高性能、高可靠、高实时、分布式特点。
RocketMQ学习——RocketMQ基本概念和系统架构
https://juejin.cn/user/4248168663101239/posts
07-23 246
RocketMQ系统架构一. Producer二. Consumer三. Name Server①. 功能介绍②. 路由注册③. 路由剔除④. 路由发现⑤. 客户端NameServer选择策略四. Broker①. 功能介绍②. 模块构成③. 集群部署五. 工作流程①. 具体流程②. Topic的创建模式③. 读/写队列 一. Producer 二. Consumer 三. Name Server ①. 功能介绍 ②. 路由注册 ③. 路由剔除 ④. 路由发现 ⑤. 客户端NameServer选择策略 四.
三分钟白话RocketMQ系列—— 核心概念
xuxian的博客
07-31 636
RocketMQ是一个开源的分布式消息中间件。它是一种低延迟、高可用、高可靠、高并发的消息队列系统，用于在分布式系统中进行异步通信。
RocketMQ —— 如何使用
Genius only means hard-working all one's life.
03-28 513
RocketMQ —— 官方示例 将官方示例全部做一遍 Simple Example 简单示例 Order Example Broadcasting Example Schedule Example Batch Example Filter Example Logappender Example OpenMessaging Example Transaction Example ...
RocketMQ 入门 —— 原理与实践
weixin_42073629的博客
06-06 176
这篇文章写成距今(201808)已经两年半了，其中的内容我已经不能保证是否已经过时，由于当前的业务中也没有在使用RocketMQ，因此很少有时间再去刨代码，很多实践方面的问题也不能很好的为大家解决。因此，建议大家权当入门文章看看，实践中遇到问题的话，在本机跑一跑代码且调试一下，或者去社区逛逛，有可能对你解决问题的帮助会大一些。当然简单的问题，我会尽力和大家交流，谢谢大家。 分布式消息系统作为实现分布式系统可扩展、可伸缩性的关键组件，需要具有高吞吐量、高可用等特点。而谈到消息系统的设计，就回避不了两个问.
RocketMQ分析——高并发读写
Huangy远
01-20 600
RocketMQ高并发读写 Rocket的高并发读写的原因可以从3个方面进行分析： 生产者负载均衡 生产者发送消息有负载均衡。生产者发送消息时，会自动轮询当前所有可发送的broker，一条消息发送成功，下次换另外一个broker发送，以达到消息平均落到所有的broker上。 消费者负载均衡 同一个group的所有消费者平均消费该Topic的所有队列。 Broker 服务端的高并发读写主要利用Lin...
探秘RocketMQ源码——Series1：Producer视角看事务消息
阿里云云栖号
05-07 860
简介：探秘RocketMQ源码——Series1：Producer视角看事务消息 1. 前言 Apache RocketMQ作为广为人知的开源消息中间件，诞生于阿里巴巴，于2016年捐赠给了Apache。从RocketMQ 4.0到如今最新的v4.7.1，不论是在阿里巴巴内部还是外部社区，都赢得了广泛的关注和好评。 出于兴趣和工作的需要，近期本人对RocketMQ 4.7.1的部分代码进行了研读，其间产生了很多困惑，也收获了更多的启发。 本文将站在发送方视角，通过阅读RocketM...
Springboot集成RocketMQ——简单使用
tang_seven的博客
08-25 2835
Springboot集成RocketMQ，进行简单使用
rocketmq使用.zip
02-21
总结来说，“rocketmq使用.zip”这个压缩包包含了关于RocketMQ的基本使用和核心特性——事务消息的资料，对于理解并运用RocketMQ在分布式系统中的事务处理非常有帮助。通过学习和实践，你可以构建出更健壮、高效的...
rocketmq-4.7.0.zip
04-04
1. **消息模型**：RocketMQ支持两种基本的消息模型，分别是点对点（Point-to-Point）和发布/订阅（Publish/Subscribe）。点对点模型保证每个消息只被一个消费者消费，而发布/订阅模型则允许多个订阅者接收相同的消息...
LG机构RocketMQ视频源码资料课件
12-21
本课程的PDF资料可能涵盖了这些知识点的讲解，包括RocketMQ的工作原理、配置使用、异常处理、性能调优等方面，是学习和掌握RocketMQ的宝贵资源。通过学习这些内容，开发者可以更好地运用RocketMQ解决实际项目中的...
rocketmq-release-4.8.0.zip
09-01
1. **消息模型**：RocketMQ支持两种基本的消息模型——发布/订阅（Publish/Subscribe）和点对点（Point-to-Point）。发布/订阅模型中，生产者发送消息到主题，多个消费者可以订阅同一主题并接收消息；点对点模型中，...
SpringBoot——原理
weixin_56697114的博客
08-13 1631
其实不管是springboot程序还是spring程序，启动过程本质上都是在做容器的初始化，并将对应的bean初始化出来放入容器。在spring环境中，每个bean的初始化都要开发者自己添加设置，但是切换成springboot程序后，自动配置功能的添加帮助开发者提前预设了很多bean的初始化过程，加上各种各样的参数设置，使得整体初始化过程显得略微复杂，但是核心本质还是在做一件事，初始化容器。...
应用配置中心——Apollo
weixin_56697114的博客
10-12 1522
目录 1、简介 2、使用Apollo 1、启动 2、创建项目 建集群 建名称空间 新增配置 创建一个新的项目 3、微服务集成Apollo客户端 1、简介 Apollo （阿波罗）是携程框架部门研发的分布式配置中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并且具备规范的权限、流程治理等特性，适用于微服务配置管理场景。 服务端基于Spring Boot和Spring Cloud开发，打包后可以直接运行，不需要额外安装Tomcat等应用容器。 ...
Zookeeper
weixin_56697114的博客
07-24 685
1、Zookeeper 概念 Zookeeper 是 Apache Hadoop 项目下的一个子项目，是一个树形目录服务。 Zookeeper 翻译过来就是 动物园管理员，他是用来管 Hadoop（大象）、Hive(蜜蜂)、Pig(小 猪)的管理员。简称zk Zookeeper 是一个分布式的、开源的分布式应用程序的协调服务。 Zookeeper 提供的主要功能包括： 配置管理 分布式锁 集群管理 2、Zookeeper命令操作 1、Zookeeper 数据模型 ZooK...
阿里云RocketMQ使用与排查指南
RocketMQ是一款由阿里云基于Apache RocketMQ构建的分布式消息中间件，设计目标是实现低延迟、高并发、高可用和高可靠性的消息传递。它主要为分布式应用系统提供异步解耦和流量削峰填谷的功能，特别适合处理互联网...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值