文章目录
导入MQ客户端依赖
- rocketmq-client 版本和 rocketmq 版本一致
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-client</artifactId>
<version>4.9.3</version>
</dependency>
步骤分析
消息发送者
- 创建消息生产者producer,并制定生产者组名
- 指定Nameserver地址
- 启动producer
- 创建消息对象,指定主题Topic、Tag和消息体
- 发送消息
- 关闭生产者producer
消息消费者
- 创建消费者Consumer,制定消费者组名
- 指定Nameserver地址
- 订阅主题Topic和Tag
- 设置回调函数,处理消息
- 启动消费者consumer
基本样例
1. 消息发送
1)发送同步消息
这种可靠性同步地发送方式使用的比较广泛,比如:重要的消息通知,短信通知。
public class SynProducer {
public static void main(String[] args) throws Exception {
//1. 创建消息生产者producer,并制定生产者组名
DefaultMQProducer producer = new DefaultMQProducer("group1");
//2. 指定Nameserver地址
producer.setNamesrvAddr("192.168.144.133:9876;192.168.144.134:9876");
//3. 启动producer
producer.start();
//4. 创建消息对象,指定主题Topic、Tag和消息体
for (int i = 0; i < 10; i++) {
/**
* 参数一: Topic
* 参数二: Tag
* 参数三: 消息内容
*/
Message msg = new Message("base", "tag1", ("Hello World " + i).getBytes());
//5. 发送消息
SendResult result = producer.send(msg);
System.out.println(result);
TimeUnit.SECONDS.sleep(1);
}
//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.144.133:9876;192.168.144.134:9876");
//3. 启动producer
producer.start();
//4. 创建消息对象,指定主题Topic、Tag和消息体
for (int i = 0; i < 10; i++) {
Message msg = new Message("base", "tag2", ("Hello World " + i).getBytes());
//5. 发送异步消息 SendCallback是接收异步返回结果的回调接口
producer.send(msg, new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
System.out.println("发送成功,结果: " + sendResult);
}
@Override
public void onException(Throwable throwable) {
System.out.println("发送异常: " + throwable);
}
});
TimeUnit.SECONDS.sleep(1);
}
//6. 关闭生产者producer
producer.shutdown();
}
}
3)单向发送消息
这种方式主要用在不特别关心发送结果的场景,例如日志发送。
public class OnewayProducer {
public static void main(String[] args) throws Exception {
//1. 创建消息生产者producer,并制定生产者组名
DefaultMQProducer producer = new DefaultMQProducer("group1");
//2. 指定Nameserver地址
producer.setNamesrvAddr("192.168.144.133:9876;192.168.144.134:9876");
//3. 启动producer
producer.start();
//4. 创建消息对象,指定主题Topic、Tag和消息体
for (int i = 0; i < 10; i++) {
Message msg = new Message("base", "tag3", ("Hello World " + i).getBytes());
//5. 发送异步消息 SendCallback是接收异步返回结果的回调接口
producer.sendOneway(msg);
TimeUnit.SECONDS.sleep(1);
}
//6. 关闭生产者producer
producer.shutdown();
}
}
2. 消费消息
消费模式:
- 负载均衡模式:消费者采用负载均衡方式消费消息,多个消费者共同消费队列消息,每个消费者处理的消息不同。(默认模式)
- 广播模式:消费者采用广播的方式消费消息,每个消费者消费的消息都是相同的。
public class Consumer {
public static void main(String[] args) throws MQClientException {
//1.创建消费者Consumer,制定消费者组名
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
//2.指定Nameserver地址
consumer.setNamesrvAddr("192.168.25.135:9876;192.168.25.138:9876");
//3.订阅主题Topic和Tag
consumer.subscribe("OrderTopic", "*");
//4. 设置回调函数,处理消息
// MessageListenerOrderly对于一个队列的消息用一个线程去处理
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();
}
}
顺序消息
消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格地保证消息有序,可以分为:
- 分区有序
- 全局有序
顺序消费的原理解析:
- 在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列);而消费消息的时候从多个queue上拉取消息,这种情况发送和消费是不能保证顺序。
- 但是如果控制发送的顺序消息只依次发送到同一个queue中,消费的时候只从这个queue上依次拉取,则就保证了顺序。
- 当发送和消费参与的queue只有一个,则是全局有序;如果多个queue参与,则为分区有序,即相对每个queue,消息都是有序的。
下面用订单进行分区有序的示例。一个订单的顺序流程是:创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中,消费时,同一个OrderId获取到的肯定是同一个队列。
1. 顺序消息生产
public class Producer {
public static void main(String[] args) throws Exception {
//1.创建消息生产者producer,并制定生产者组名
DefaultMQProducer producer = new DefaultMQProducer("orderly");
//2.指定Nameserver地址
producer.setNamesrvAddr("192.168.144.133:9876;192.168.144.134:9876");
//3.启动producer
producer.start();
//构建消息集合
List<OrderStep> orderSteps = OrderStep.buildOrders();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
for (int i = 0; i < orderSteps.size(); i++) {
//4. 创建消息对象
Date date = new Date();
String dateStr = sdf.format(date);
// 加个时间前缀
String body = dateStr + orderSteps.get(i) + "";
Message message = new Message("OrderTopic", "Order", "KEY" + i, body.getBytes());
/**
* 参数一:消息对象
* 参数二:消息队列的选择器
* 参数三:选择队列的业务标识(订单ID)
*/
//5. 发送消息
SendResult result = producer.send(message, new MessageQueueSelector() {
/**
*
* @param mqs:topic下的队列集合
* @param msg:消息对象 message ==> Message msg
* @param arg:选择队列的业务标识(订单ID) orderSteps.get(i).getOrderId() ==> Object 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());
//MessageQueueSelector 直接用 SelectMessageQueueByHash
//SendResult result = producer.send(message, new SelectMessageQueueByHash(), orderSteps.get(i).getOrderId());
System.out.println("发送结果:" + result);
TimeUnit.SECONDS.sleep(1);
}
//6. 关闭生产者producer
producer.shutdown();
}
}
2. 顺序消费消息
public class Consumer {
public static void main(String[] args) throws MQClientException {
//1.创建消费者Consumer,制定消费者组名
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("orderly");
//2.指定Nameserver地址
consumer.setNamesrvAddr("192.168.144.133:9876;192.168.144.134:9876");
/**
* 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费
* 如果非第一次启动,那么按照上次消费的位置继续消费
*/
consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
//3.订阅主题Topic和Tag
consumer.subscribe("OrderTopic", "Order");
//4. 设置回调函数,处理消息
// MessageListenerOrderly对于一个队列的消息用一个线程去处理
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();
}
}
线程名称:【ConsumeMessageThread_orderly_1】:2022-04-28 15:47:42OrderStep{orderId=1065, desc='创建'}
线程名称:【ConsumeMessageThread_orderly_1】:2022-04-28 15:47:45OrderStep{orderId=1065, desc='付款'}
线程名称:【ConsumeMessageThread_orderly_1】:2022-04-28 15:47:47OrderStep{orderId=1065, desc='完成'}
线程名称:【ConsumeMessageThread_orderly_2】:2022-04-28 15:47:44OrderStep{orderId=7235, desc='创建'}
线程名称:【ConsumeMessageThread_orderly_2】:2022-04-28 15:47:46OrderStep{orderId=7235, desc='付款'}
线程名称:【ConsumeMessageThread_orderly_2】:2022-04-28 15:47:49OrderStep{orderId=7235, desc='完成'}
线程名称:【ConsumeMessageThread_orderly_3】:2022-04-28 15:47:40OrderStep{orderId=1039, desc='创建'}
线程名称:【ConsumeMessageThread_orderly_3】:2022-04-28 15:47:43OrderStep{orderId=1039, desc='付款'}
线程名称:【ConsumeMessageThread_orderly_3】:2022-04-28 15:47:48OrderStep{orderId=1039, desc='推送'}
线程名称:【ConsumeMessageThread_orderly_3】:2022-04-28 15:47:50OrderStep{orderId=1039, desc='完成'}
延时消息
比如电商里,提交了一个订单就可以发送一个延时消息,1h后去检查这个订单的状态,如果还是未付款就取消订单释放库存。
1. 使用限制
// 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";
- 现在RocketMq并不支持任意时间的延时,需要设置几个固定的延时等级,从1s到2h分别对应着等级1到18
- 使用
setDelayTimeLevel(int level);
设置延时等级,level 从 0 开始
2. 消费消息
public class Consumer {
public static void main(String[] args) throws Exception {
//1.创建消费者Consumer,制定消费者组名
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("delay");
//2.指定Nameserver地址
consumer.setNamesrvAddr("192.168.144.133:9876;192.168.144.134:9876");
//3.订阅主题Topic和Tag
consumer.subscribe("DelayTopic", "*");
//4.设置回调函数,处理消息
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;
}
});
//5.启动消费者consumer
consumer.start();
}
}
3. 发送延时消息
public class Producer {
public static void main(String[] args) throws InterruptedException, RemotingException, MQClientException, MQBrokerException {
//1.创建消息生产者producer,并制定生产者组名
DefaultMQProducer producer = new DefaultMQProducer("delay");
//2.指定Nameserver地址
producer.setNamesrvAddr("192.168.144.133:9876;192.168.144.134:9876");
//3.启动producer
producer.start();
for (int i = 0; i < 10; i++) {
//4.创建消息对象
Message msg = new Message("DelayTopic", "Tag1", ("Hello World" + i).getBytes());
// 设置延时等级2,这个消息将在10s之后发送(现在只支持固定的几个时间,详看delayTimeLevel)
msg.setDelayTimeLevel(2);
//5.发送消息
SendResult result = producer.send(msg);
System.out.println("发送结果:" + result);
//线程睡1秒
TimeUnit.SECONDS.sleep(1);
}
//6.关闭生产者producer
producer.shutdown();
}
}
###4.3.3 验证
您将会看到消息的消费比存储时间晚10秒
批量消息
- 批量发送消息能显著提高传递小消息的性能。
- 但是同一批次的消息应该有相同的topic,相同的waitStoreMsgOK,而且不能是延时消息。
- 此外,这一批消息的总大小不应超过1MB(旧版本,查到的起码4.4之前是要求4MB)。
提示:
- waitStoreMsgOK: 消息发送时是否等消息存储完成后再返回。
发送批量消息
String topic = "BatchTest";
List<Message> messages = new ArrayList<>();
messages.add(new Message(topic, "TagA", "OrderID001", "Hello world 0".getBytes()));
messages.add(new Message(topic, "TagA", "OrderID002", "Hello world 1".getBytes()));
messages.add(new Message(topic, "TagA", "OrderID003", "Hello world 2".getBytes()));
try {
producer.send(messages);
} catch (Exception e) {
e.printStackTrace();
//处理error
}
如果消息的总长度可能大于1MB时,这时候最好把消息进行分割
public class ListSplitter implements Iterator<List<Message>> {
private final int SIZE_LIMIT = 1024 * 1024;
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; //for log overhead
if (tmpSize > SIZE_LIMIT) {
//it is unexpected that single message exceeds the SIZE_LIMIT
//here just let it go, otherwise it will block the splitting process
if (nextIndex - currIndex == 0) {
//if the next sublist has no element, add this one and then break, otherwise just break
nextIndex++;
}
break;
}
if (tmpSize + totalSize > SIZE_LIMIT) {
break;
} else {
totalSize += tmpSize;
}
}
List<Message> subList = messages.subList(currIndex, nextIndex);
currIndex = nextIndex;
return subList;
}
}
//then you could split the large list into small ones:
ListSplitter splitter = new ListSplitter(messages);
while (splitter.hasNext()) {
try {
List<Message> listItem = splitter.next();
producer.send(listItem);
} catch (Exception e) {
e.printStackTrace();
//handle the error
}
}
过滤消息
在大多数情况下,TAG是一个简单而有用的设计,其可以来选择您想要的消息。例如:
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("CID_EXAMPLE");
consumer.subscribe("TOPIC", "TAGA || TAGB || TAGC");
消费者将接收包含TAGA或TAGB或TAGC的消息,但是限制是一个消息只能有一个标签,这对于复杂的场景可能不起作用。在这种情况下,可以在消息中设置一些属性,再使用SQL表达式通过筛选属性来筛选消息。
SQL特性可以通过发送消息时的属性来进行计算。在RocketMQ定义的语法下,可以实现一些简单的逻辑。下面是一个例子:
------------
| message |
|----------| a > 5 AND b = 'abc'
| a = 10 | --------------------> Gotten
| b = 'abc'|
| c = true |
------------
------------
| message |
|----------| a > 5 AND b = 'abc'
| a = 1 | --------------------> Missed
| b = 'abc'|
| c = true |
------------
1. SQL基本语法
RocketMQ只定义了一些基本语法来支持这个特性。你也可以很容易地扩展它。
- 数值比较,比如:>,>=,<,<=,BETWEEN,=;
- 字符比较,比如:=,<>,IN;
- IS NULL 或者 IS NOT NULL;
- 逻辑符号 AND,OR,NOT;
常量支持类型为:
- 数值,比如:123,3.1415;
- 字符,比如:‘abc’,必须用单引号包裹起来;
- NULL,特殊的常量
- 布尔值,TRUE 或 FALSE
只有使用push模式的消费者才能用使用SQL92标准的sql语句,接口如下:
public void subscribe(finalString topic, final MessageSelector messageSelector)
但是要使用基于标准的sql92模式过滤消息,必须找到RocketMQ的安装目录的 conf 下的对应配置文件去修改配置,然后停止broker服务,再重启broker服务,我这里搭建的是双主双从集群,修改的是2m-2s-async下的所有配置文件:
#是否支持根据属性过滤 如果使用基于标准的sql92模式过滤消息则改参数必须设置为true
enablePropertyFilter=true
2. 消息生产者
发送消息时,你能通过putUserProperty
来设置消息的属性
DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
producer.start();
Message msg = new Message("TopicTest",
tag,
("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET)
);
// 设置一些属性
msg.putUserProperty("a", String.valueOf(i));
SendResult sendResult = producer.send(msg);
producer.shutdown();
3. 消息消费者
用MessageSelector.bySql来使用sql筛选消息
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_4");
// 只有订阅的消息有这个属性a, a >=0 and a <= 3
consumer.subscribe("TopicTest", MessageSelector.bySql("a between 0 and 3");
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
consumer.start();
事务消息
事务消息是一个两阶段的提交消息实现,可以确保分布式系统的最终一致性。事务性消息确保本地事务的执行和消息的发送的原子性。
1. 流程分析
事务消息分为两个流程:正常事务消息的发送及提交、事务消息的补偿流程。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NvdUlriU-1651156795905)(imgs/消息发送/事务消息.png)]
1)事务消息发送及提交
- Producer 发送Half消息(暂时无法投递的消息,此时事务消息对消费者不可见)。
- MQ服务端响应消息写入结果。
- 根据发送结果执行本地事务(如果上一步写入失败,此时 Half 消息对业务不可见,本地逻辑不执行)。
- 根据本地事务状态执行Commit或者Rollback(Commit操作生成消息索引,消息对消费者可见)
2)事务补偿
- 对没有 Commit / Rollback 的事务消息(pending状态的消息),从服务端发起一次“回查”
- Producer 收到回查消息,回查消息对应的本地事务的状态
- 根据本地事务状态,重新Commit或者Rollback
其中,补偿阶段用于解决消息 Commit 或者 Rollback 发生超时或者失败的情况。
3)事务消息状态
事务消息共有三种状态,提交状态、回滚状态、中间状态:
- TransactionStatus.CommitTransaction: 提交事务,它允许消费者消费此消息。
- TransactionStatus.RollbackTransaction: 回滚事务,它代表该消息将被删除,不允许被消费。
- TransactionStatus.Unknown: 中间状态,它代表需要检查消息队列来确定状态。
2. 发送事务消息
创建事务性生产者
- 使用
TransactionMQProducer
类创建生产者,并指定只有事务消息才能使用的唯一的ProducerGroup
。
实现事务的监听接口
- 当发送半消息成功时,我们使用
executeLocalTransaction
方法来执行本地事务。执行本地事务后,需要根据执行结果对消息队列进行回复。回传的事务状态请参考前一节。 checkLocalTranscation
方法用于检查本地事务状态,并回应消息队列的检查请求。它也是返回前一节中提到的三个事务状态之一。可以设置自定义线程池来处理这些回查请求。
public class Producer {
public static void main(String[] args) throws Exception {
//1.创建消息生产者producer,并制定生产者组名
TransactionMQProducer producer = new TransactionMQProducer("transaction");
//2.指定Nameserver地址
producer.setNamesrvAddr("192.168.144.133:9876;192.168.144.134:9876");
//自定义线程池处理回查请求
ExecutorService executorService = new ThreadPoolExecutor(2, 5, 100, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2000), new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r);
thread.setName("client-transaction-msg-check-thread");
return thread;
}
});
//添加事务监听器
producer.setTransactionListener(new TransactionListener() {
/**
* 执行本地事务,对应流程3
* @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 Producer回查本地事务状态,对应流程6
* @param msg: 事务消息状态为 UNKNOW 的消息
* @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.创建消息对象
Message msg = new Message("TransactionTopic", tags[i], ("Hello World" + i).getBytes());
//5.发送消息
/**
* 第二个参数是上面 TransactionListener 的 executeLocalTransaction执行本地事务函数中所需要的参数
*/
SendResult result = producer.sendMessageInTransaction(msg, null);
//发送状态
SendStatus status = result.getSendStatus();
System.out.println("发送结果:" + result);
//线程睡1秒
TimeUnit.SECONDS.sleep(1);
}
//6.关闭生产者producer
//producer.shutdown();
}
}
Producer:
发送结果:SendResult [sendStatus=SEND_OK, msgId=7F00000146C818B4AAC28FAEE9EE0000, offsetMsgId=null, messageQueue=MessageQueue [topic=TransactionTopic, brokerName=broker-b, queueId=3], queueOffset=1]
发送结果:SendResult [sendStatus=SEND_OK, msgId=7F00000146C818B4AAC28FAEEDF00001, offsetMsgId=null, messageQueue=MessageQueue [topic=TransactionTopic, brokerName=broker-a, queueId=0], queueOffset=3]
发送结果:SendResult [sendStatus=SEND_OK, msgId=7F00000146C818B4AAC28FAEF1E70002, offsetMsgId=null, messageQueue=MessageQueue [topic=TransactionTopic, brokerName=broker-a, queueId=1], queueOffset=4]
消息的Tag:TAGC
Cpnsumer:
consumeThread=ConsumeMessageThread_transaction_1,Hello World0
consumeThread=ConsumeMessageThread_transaction_2,Hello World2
3. 使用限制
- 事务消息不支持延时消息和批量消息。
- 为了避免单个消息被检查太多次而导致半队列消息累积,我们默认将单个消息的检查次数限制为 15 次,但是用户可以通过 Broker 配置文件的
transactionCheckMax
参数来修改此限制。如果已经检查某条消息超过规定的 次数的话,则 Broker 将丢弃此消息,并默认同时打印错误日志。用户可以通过重写AbstractTransactionCheckListener
类来修改这个行为。 - 事务消息将在 Broker 配置文件中的参数 transactionMsgTimeout 规定的特定时间之后被检查。当发送事务消息时,用户还可以通过设置用户属性
CHECK_IMMUNITY_TIME_IN_SECONDS
来改变这个限制,该参数的优先级高于transactionMsgTimeout
参数。 - 事务性消息可能不止一次被检查或消费。
- 提交给用户的目标主题消息可能会失败。目前根据日志记录,高可用性通过 RocketMQ 本身的高可用性机制来保证,如果希望确保事务消息不丢失、并且事务完整性得到保证,建议使用同步双重写入机制。
- 事务消息的生产者 ID 不能与其他类型消息的生产者 ID 共享。与其他类型的消息不同,事务消息允许反向查询、MQ服务器能通过它们的生产者 ID 查询到消费者。