RocketMQ 工程准备、同步消息、延时消息、顺序消息、事务消息生产消费代码示例说明

T_BUG袁

已于 2024-01-18 15:16:58 修改

阅读量1.5k

点赞数 37

文章标签： rocketmq

于 2024-01-18 15:14:06 首次发布

本文链接：https://blog.csdn.net/weixin_58186846/article/details/135674410

版权

2 消费者--延时级别对应的时间过后才能接收到消息

一工程准备

首先:启动rocketmq以及管理界面

# 进入 rocketmq 目录
cd /usr/local/rocketmq/
 
# rocketmq 目录下启动 name server
nohup sh bin/mqnamesrv &
 
 
#rocketmq 目录下 启动 broker, 连接name server: localhost:9876
nohup sh bin/mqbroker -n localhost:9876 &
 
#jps查看,如果broker没启动,就使用下面这个命令启动broker
nohup sh bin/mqbroker -n localhost:9876 -c conf/broker.conf &
 
# cd ~/ 再运行管理界面
nohup java -jar rocketmq-console-ng-1.0.1.jar --server.port=8080 --rocketmq.config.namesrvAddr=localhost:9876 &

第一步:新建空工程

第二步:配置maven,fend confing,Java companies ,创建maven工程

第三步:pom.xml文件添加rocketmq依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>cn.tedu</groupId>
    <artifactId>rocketmq-api</artifactId>
    <version>1.0-SNAPSHOT</version>
 
    <dependencies>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.7.1</version>
        </dependency>
 
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-store</artifactId>
            <version>4.7.1</version>
        </dependency>
 
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    
</project>

二同步消息

同步消息发送要保证强一致性，发到master的消息向slave复制后，才会向生产者发送反馈信息。

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

1 生产者

package m1;
 
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.util.Scanner;
 
//消息生产者
public class Producer {
    public static void main(String[] args) throws MQClientException, MQBrokerException, RemotingException, InterruptedException {
        // 创建生产者对象
        DefaultMQProducer p = new DefaultMQProducer("prod-group1");
        // 设置 name server
        p.setNamesrvAddr("192.168.64.141:9876");
        // 启动生产者,连接消息服务器
        p.start();
        // 创建消息封装对象 Message(Topic,Tag,消息)
        //发送
        while (true) {
            System.out.println("输入消息");
            String s = new Scanner(System.in).nextLine();
            //Topic--相当于是一级分类,Tag--相当于是二级分类,s--消息以数组的形式发送
            Message msg = new Message("Topic1", "TagA", s.getBytes());
            //服务器的反馈信息
            SendResult r = p.send(msg);
            System.out.println(r);
        }
 
    }
}

启动并发送消息测试
rocketmq服务器:
其中:时间与北京时间提前8小时时差

2 消费者

消费者的要点：

1. push 和 pull

消费者有两种模式：push 和 pull。

push 模式由服务器主动向消费者发送消息；pull 模式由消费者主动向服务器请求消息。

在消费者处理能力有限时，为了减轻消费者的压力，可以采用pull模式。多数情况下都采用 pull 模式。

2. NameServer

消费者需要向 NameServer 询问 Topic 的路由信息。

3. Topic

从指定的Topic接收消息。Topic相当于是一级分类。

4. Tag

Topic 相当于是一级分类，Tag 相当于是2级分类。

多个 Tag 可以这样写： TagA || TagB || TagC
不指定 Tag，或者说接收所有的 Tag，可以写星号： *

package m1;
 
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.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;
 
import java.util.List;
 
//消息消费者
public class Consumer {
    public static void main(String[] args) throws MQClientException {
        // 创建消费者对象
        DefaultMQPushConsumer c =
                new DefaultMQPushConsumer("cons-group1");//Push直接推送给消费者,Pull要等消费者需要是拉取消息
        // 设置 name server 注册中心
        c.setNamesrvAddr("192.168.64.141:9876");
        // 设置从哪里订阅消息
        //tag标签: * -- 星号表示所有标签 ,TagA --只接收TagA
        c.subscribe("Topic1","TagA || TagB || TagC");
        // 设置消息监听器
        // Concurrently -- 会启动多个线程并行处理消息,不能保证按顺序依次处理
        c.setMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt ext : msgs) {
                    String s = new String(ext.getBody());
                    System.out.println("收到: "+s);
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消息发送成功
               // return ConsumeConcurrentlyStatus.RECONSUME_LATER;//稍后重新消费
 
            }
        });
        // 启动
        c.start();
    }
}

5. 启动消费者接收生产者消息:

消费者多线程并行处理消息,无序接收消息

三延时消息

消息发送到 Rocketmq 服务器后，延迟一定时间再向消费者进行投递。

延时消息的使用场景：

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

生产者发送消息时，对消息进行延时设置：

msg.setDelayTimeLevel(3);

其中 3 代表级别而不是一个具体的时间值，级别和延时时长对应关系是在 MessageStoreConfig 类种进行定义的：

this.messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";

对应关系表：

1 生产者--设置延时级别

package m1;
 
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.util.Scanner;
 
//消息生产者
public class Producer {
    public static void main(String[] args) throws MQClientException, MQBrokerException, RemotingException, InterruptedException {
        // 创建生产者对象
        DefaultMQProducer p = new DefaultMQProducer("prod-group1");
        // 设置 name server
        p.setNamesrvAddr("192.168.64.141:9876");
        // 启动生产者,连接消息服务器
        p.start();
        // 创建消息封装对象 Message(Topic,Tag,消息)
        //发送
        while (true) {
            System.out.print("输入消息:");
            String s = new Scanner(System.in).nextLine();
            //Topic--相当于是一级分类,Tag--相当于是二级分类,s--消息以数组的形式发送
            Message msg = new Message("Topic1", "TagA", s.getBytes());
            //设置延时级别
            msg.setDelayTimeLevel(3);//设置延时级别3--延时10秒
            //服务器的反馈信息
            SendResult r = p.send(msg);
            System.out.println(r);
        }
 
    }
}

2 消费者--延时级别对应的时间过后才能接收到消息

package m1;
 
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.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;
 
import java.util.List;
 
//消息消费者
public class Consumer {
    public static void main(String[] args) throws MQClientException {
        // 创建消费者对象
        DefaultMQPushConsumer c =
                new DefaultMQPushConsumer("cons-group1");//Push直接推送给消费者,Pull要等消费者需要是拉取消息
        // 设置 name server 注册中心
        c.setNamesrvAddr("192.168.64.141:9876");
        // 设置从哪里订阅消息
        //tag标签: * -- 星号表示所有标签 ,TagA --只接收TagA
        c.subscribe("Topic1","TagA || TagB || TagC");
        // 设置消息监听器
        // Concurrently -- 会启动多个线程并行处理消息,不能保证按顺序依次处理
        c.setMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt ext : msgs) {
                    String s = new String(ext.getBody());
                    System.out.println("收到: "+s);
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消息发送成功
               // return ConsumeConcurrentlyStatus.RECONSUME_LATER;//稍后重新消费
 
            }
        });
        // 启动
        c.start();
    }
}

启动生产者,消费者进行测试:

消息生产者发送消息,设置延时级别对应的时间过后消费者自动收到消息

注意:如果设置稍后重新消费,接收消息失败时,服务器会按照延时级别慢慢提升而反复发送消息的时间间隔也拉长,直到18个级别都结束,就不会再发送消息,总共4个小时多;如果还没接收,该消息会被放入死信消息队列,需要其他方法处理,比如可以人工后台手动调整消息生产者和消费者一致的状态.、

四顺序消息

上图演示了 Rocketmq 顺序消息的基本原理：

同一组有序的消息序列，会被发送到同一个队列，按照 FIFO 的方式进行处理
一个队列只允许一个消费者线程接收消息，这样就保证消息按顺序被接收

下面以订单为例：

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

1 生产者

package m2;
 
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.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.remoting.exception.RemotingException;
 
import java.util.List;
 
//顺序消息生产者
public class Producer {
    static String[] msgs = {
            "15103111039,创建",
            "15103111065,创建",
            "15103111039,付款",
            "15103117235,创建",
            "15103111065,付款",
            "15103117235,付款",
            "15103111065,完成",
            "15103111039,推送",
            "15103117235,完成",
            "15103111039,完成"
    };
 
    public static void main(String[] args) throws MQClientException, MQBrokerException, RemotingException, InterruptedException {
        // 创建生产者对象
        DefaultMQProducer p = new DefaultMQProducer("prod-group2");
        // 设置 name server
        p.setNamesrvAddr("192.168.64.141:9876");
        // 启动生产者,连接消息服务器
        p.start();
        // 遍历数组发送消息
        for (String s : msgs) {
            // s -- "15103111039,完成"
            Long orderId = Long.valueOf(s.split(",")[0]);//取出订单的id
            Message msg = new Message("Topic2", s.getBytes());
            //p.send(消息, 队列选择器是匿名内部类, 选择依据是订单id);
            SendResult r =
                    p.send(msg, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message message, Object arg) {
                    Long orderId = (Long) arg;
                    //订单id对队列数量取余, 相同订单id得到相同的队列索引
                    int index = (int) (orderId % mqs.size());
                    return mqs.get(index);
                }
            }, orderId);
            System.out.println(r);
        }
 
 
    }
}

启动后:

2 消费者

package m2;
 
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.*;
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 MQClientException {
        // 创建消费者对象
        DefaultMQPushConsumer c =
                new DefaultMQPushConsumer("cons-group2");//Push直接推送给消费者,Pull要等消费者需要是拉取消息
        // 设置 name server 注册中心
        c.setNamesrvAddr("192.168.64.141:9876");
        // 设置从哪里订阅消息
        //tag标签: * -- 星号表示所有标签
        c.subscribe("Topic2","*");
        // 设置消息监听器
        // Concurrently -- 会启动多个线程并行处理消息,不能保证按顺序依次处理
        // Orderly -- 单个线程
        c.setMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext consumeOrderlyContext) {
                for (MessageExt ext : msgs){
                    String s = new String(ext.getBody());
                    System.out.println("收到: " +s);
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        // 启动
        c.start();
    }
}

启动生产者和消费者进行测试:

服务器:

五事务消息

RocketMQ 提供了可靠性消息，也叫事务消息。

事务消息的原理

下面来看 RocketMQ 的事务消息是如何来发送“可靠消息”的，只需要以下三步：

发送半消息（半消息不会发送给消费者）
执行本地事务
提交消息

完成事务消息发送后，消费者就可以以正常的方式来消费数据。

RocketMQ 的自动重发机制在绝大多数情况下，都可以保证消息被正确消费。

假如消息最终消费失败了，还可以由人工处理进行托底。

上面分析的是正常情况下的执行流程。下面再来看两种错误情况：

事务执行失败时回滚消息
服务器无法得知消息状态时，需要主动回查消息状态

回滚:

消息回查:

1 生产者

package m3;
 
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.LocalTransactionState;
import org.apache.rocketmq.client.producer.TransactionListener;
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.common.message.MessageExt;
 
import java.util.Scanner;
 
public class Producer {
    public static void main(String[] args) throws MQClientException {
        // 创建事务消息生产者
        TransactionMQProducer p =
                new TransactionMQProducer("prod-group3");
        // 设置 name server
        p.setNamesrvAddr("192.168.64.141:9876");
        // 设置事务消息监听器
         //1. 执行本地事务(调用*service.执行业务方法())
         //2. 处理rocketmq的事务回查
        p.setTransactionListener(new TransactionListener() {
            //执行本地事务
            @Override
            public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
                System.out.println("执行本地业务, 参数: "+arg);
                if (Math.random()<0.5){
                    System.out.println("本地事务执行成功");
                    return LocalTransactionState.COMMIT_MESSAGE;// 提交消息并通知服务器,消息可以进行投递
 
                }else {
                    System.out.println("本地事务执行失败");
                    return LocalTransactionState.ROLLBACK_MESSAGE;// 失败时,回滚消息,撤回消息
 
                }
                //return LocalTransactionState.UNKNOW; //未知,当前方法中,一般不会有此情况,
            }
 
            @Override
            public LocalTransactionState checkLocalTransaction(MessageExt msg) {
                return null;
            }
        });
        // 启动
        p.start();
        // 发送事务消息,触发事务消息监听器
        while (true) {
            System.out.println("输入消息: ");
            String s = new Scanner(System.in).nextLine();
            Message msg = new Message("Topic3", s.getBytes());//Tag标签可加可不加,此处省略
            //p.sendMessageInTransaction(msg,arg(业务数据参数));
            TransactionSendResult r = p.sendMessageInTransaction(msg, "业务数据参数");
            System.out.println("---事务消息结果: "+ r);
        }
    }
}

单独启动生产者并发送消息进行测试:

模拟网络不稳定, 不能向服务器提交或回滚消息

package m3;
 
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.LocalTransactionState;
import org.apache.rocketmq.client.producer.TransactionListener;
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.common.message.MessageExt;
 
import java.util.Scanner;
 
public class Producer {
    public static void main(String[] args) throws MQClientException {
        // 创建事务消息生产者
        TransactionMQProducer p =
                new TransactionMQProducer("prod-group3");
        // 设置 name server
        p.setNamesrvAddr("192.168.64.141:9876");
        // 设置事务消息监听器
         //1. 执行本地事务(调用*service.执行业务方法())
         //2. 处理rocketmq的事务回查
        p.setTransactionListener(new TransactionListener() {
            //执行本地事务
            @Override
            public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
                /*模拟网络不稳定, 不能向服务器提交或回滚消息*/
                if (Math.random() < 1) {
                    System.out.println("网络中断,无法向服务器提交或回滚");
                    return LocalTransactionState.UNKNOW;
                }
                System.out.println("执行本地业务, 参数: "+arg);
                if (Math.random()<0.5){
                    System.out.println("本地事务执行成功");
                    return LocalTransactionState.COMMIT_MESSAGE;// 提交消息并通知服务器,消息可以进行投递
 
                }else {
                    System.out.println("本地事务执行失败");
                    return LocalTransactionState.ROLLBACK_MESSAGE;// 失败时,回滚消息,撤回消息
 
                }
                //return LocalTransactionState.UNKNOW; //未知,当前方法中,一般不会有此情况,
            }
            //事务回查方法
            @Override
            public LocalTransactionState checkLocalTransaction(MessageExt msg) {
                System.out.println("rocketmq 服务器正在回查事务状态");
                /*上面本地事务还没有执行结束
                * 无法获取事务状态
                * */
                return LocalTransactionState.UNKNOW; //返回未知,会一直回查下去
            }
        });
        // 启动
        p.start();
        // 发送事务消息,触发事务消息监听器
        while (true) {
            System.out.println("输入消息: ");
            String s = new Scanner(System.in).nextLine();
            Message msg = new Message("Topic3", s.getBytes());//Tag标签可加可不加,此处省略
            //p.sendMessageInTransaction(msg,arg(业务数据参数));
            TransactionSendResult r = p.sendMessageInTransaction(msg, "业务数据参数");
            System.out.println("---事务消息结果: "+ r);
        }
    }
}

启动测试消息回查方法

参考自：https://blog.csdn.net/weixin_58580280/article/details/120456422

T_BUG袁

关注

37
点赞
踩
33

收藏

觉得还不错? 一键收藏
打赏
0
评论
RocketMQ 工程准备、同步消息、延时消息、顺序消息、事务消息生产消费代码示例说明

如果设置稍后重新消费,接收消息失败时,服务器会按照延时级别慢慢提升而反复发送消息的时间间隔也拉长,直到18个级别都结束,就不会再发送消息,总共4个小时多;比如电商里，提交了一个订单就可以发送一个延时消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存。同步消息发送要保证强一致性，发到master的消息向slave复制后，才会向生产者发送反馈信息。这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。消息生产者发送消息,设置延时级别对应的时间过后消费者自动收到消息。
复制链接

扫一扫