rocketmq-client实现简单消息发送

最新推荐文章于 2024-04-19 21:57:19 发布

HGW689

最新推荐文章于 2024-04-19 21:57:19 发布

阅读量916

点赞数

分类专栏：常用中间件【不会找不到工作】文章标签： java-rocketmq rocketmq java

本文链接：https://blog.csdn.net/m0_49183244/article/details/129046304

版权

常用中间件【不会找不到工作】专栏收录该内容

8 篇文章 1 订阅

订阅专栏

代码托管于gitee：easy-rocketmq

文章目录

一、前置工作

简单分析一下发送消息有哪些步骤：

消息发送者

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

消息消费者

创建消费者Consumer，指定消费者组名
指定NameServer地址
订阅主题Topic和Tag
设置回调函数，处理消息
启动消费者Consumer

首先创建一个SpringBoot项目并且导入依赖

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V3Ib7Qoh-1676450558521)(RocketMQ-RocketMQ消息发送样例.assets/image-20230102125245279.png)]

二、消息发送样例

1. 同步消息

核心代码：

/**
* 以同步方式发送消息。此方法仅在发送过程完全完成时返回。Warn:该方法具有内部重试机制，即内部实现将在声明失败前重试
* sretryTimesWhenSendFailed次数。因此，可能会有多个消息被传递给代理。应用程序开发人员需要解决潜在的复制问题。
* 参数：
*		- 要发送的消息。（org.apache.rocketmq.common.message->Message）
*/
public SendResult send(Message msg)

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

Demo

@Slf4j
@Service
public class BaseMsgProducerImpl implements BaseMsgProducer {

   @Value("${config.rocket-mq.name-server-addr}")
   private String nameSrvAddr;

   @Override
   public Boolean sendSyncMsg(String producerGroup, String topic, String tag, String context) {
      // 1. 创建消息生产者producer，并指定生产者组名
      DefaultMQProducer producer = new DefaultMQProducer(producerGroup);
      // 2. 指定NameServer地址
      producer.setNamesrvAddr(nameSrvAddr);
      // 3. 启动Producer
      try {
         producer.start();
      } catch (MQClientException e) {
         log.error("发送普通同步消息时，启动DefaultMQProducer失败，e:{}", e);
         e.printStackTrace();
      }
      // 4. 创建消息对象，指定主题Topic、Tag和消息体
      /**
       * 参数一：消息主题Topic
       * 参数二：消息Tag
       * 参数三：消息内容
       */
      Message msg = new Message(topic, tag, context.getBytes());
      // 5. 发送消息
      SendResult result = null;
      try {
         result = producer.send(msg);
      } catch (Exception e) {
         log.error("发送普通同步消息失败，e:{}", e);
         e.printStackTrace();
      }
      // 6. 关闭生产者 Producer
      producer.shutdown();
      // 发送状态
      SendStatus sendStatus = result.getSendStatus();
      if (sendStatus.equals(SendStatus.SEND_OK)) {
         return Boolean.TRUE;
      } else {
         return Boolean.FALSE;
      }
   }
   
}

2. 异步消息

核心代码：

/** 
* 向代理异步发送消息。该方法立即返回。在发送完成时，sendCallback将被执行。与send(Message)类似，内部实现在声明发送失败之前
* 可能会重试retryTimesWhenSendAsyncFailed次数，这可能会产生消息复制，应用程序开发人员将解决这个潜在的问题。
* 参数：
*		- 要发送的消息。（org.apache.rocketmq.common.message->Message）
*		- 在发送完成时执行的回调，成功或不成功。(org.apache.rocketmq.client.producer->SendCallback)
*/
public void send(Message msg, SendCallback sendCallback)

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

Demo

@Slf4j
@Service
public class BaseMsgProducerImpl implements BaseMsgProducer {

   @Value("${config.rocket-mq.name-server-addr}")
   private String nameSrvAddr;

   @Override
   public void sendAsyncMsg(String producerGroup, String topic, String tag, String context, SendCallback sendCallback) {
      // 1. 创建消息生产者producer，并指定生产者组名
      DefaultMQProducer producer = new DefaultMQProducer(producerGroup);
      // 2. 指定NameServer地址
      producer.setNamesrvAddr(nameSrvAddr);
      // 3. 启动Producer
      try {
         producer.start();
      } catch (MQClientException e) {
         log.error("发送异步消息时，启动DefaultMQProducer失败，e:{}", e);
         e.printStackTrace();
      }
      // 设置发送异步失败时的重试次数
      producer.setRetryTimesWhenSendAsyncFailed(3);
      // 4. 创建消息对象，指定主题Topic、Tag和消息体
      Message msg = new Message(topic, tag, context.getBytes());
      // 5. 发送消息
      try {
         producer.send(msg, sendCallback);
      } catch (Exception e) {
         log.error("发送异步消息失败，e:{}", e);
         e.printStackTrace();
      }
      // 6. 关闭生产者 Producer
      producer.shutdown();
   }

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lt61dhwn-1676450593543)(RocketMQ-RocketMQ消息发送样例.assets/image-20230102153455491.png)]

3. 单向消息

核心代码：

/**
* 与UDP类似，此方法在返回前不会等待代理的确认。显然，它具有最大的吞吐量，但也有消息丢失的可能性。
* 参数：
*		- 要发送的消息。（org.apache.rocketmq.common.message->Message）
*/
public void sendOneway(Message msg)

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

Demo

@Slf4j
@Service
public class BaseMsgProducerImpl implements BaseMsgProducer {

   @Value("${config.rocket-mq.name-server-addr}")
   private String nameSrvAddr;

   @Override
   public void sendOneWayMsg(String producerGroup, String topic, String tag, String context) {
      // 1. 创建消息生产者producer，并指定生产者组名
      DefaultMQProducer producer = new DefaultMQProducer(producerGroup);
      // 2. 指定NameServer地址
      producer.setNamesrvAddr(nameSrvAddr);
      // 3. 启动Producer
      try {
         producer.start();
      } catch (MQClientException e) {
         log.error("发送异步消息时，启动DefaultMQProducer失败，e:{}", e);
         e.printStackTrace();
      }
      // 设置发送异步失败时的重试次数
      producer.setRetryTimesWhenSendAsyncFailed(3);
      // 4. 创建消息对象，指定主题Topic、Tag和消息体
      Message msg = new Message(topic, tag, context.getBytes());
      // 5. 发送消息
      try {
         producer.sendOneway(msg);
         TimeUnit.SECONDS.sleep(1);
      } catch (Exception e) {
         log.error("发送异步消息失败，e:{}", e);
         e.printStackTrace();
      }
      producer.shutdown();
   }

}

负载均衡模式

消费者采用负载均衡方式消费消息，多个消费者共同消费队列消息，每个消费者处理的消息不同

@Slf4j
@Service
public class BaseMsgConsumerImpl implements BaseMsgConsumer {

   @Value("${config.rocket-mq.name-server-addr}")
   private String nameSrvAddr;

   @Override
   public void pushConsumerMsgByClustering(String consumerGroup, String topic, String tag,  MessageListener messageListener) {
      try {
         // 1. 创建消费者Consumer，指定消费者组名
         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(consumerGroup);
         // 2. 指定NameServer地址
         consumer.setNamesrvAddr(nameSrvAddr);
         // 3. 订阅主题Topic和Tag
         consumer.subscribe(topic, tag);
         //负载均衡模式消费
         consumer.setMessageModel(MessageModel.CLUSTERING);
         // 4. 设置回调函数，处理消息
         consumer.registerMessageListener(messageListener);
         // 5. 启动消费者Consumer
         consumer.start();
      } catch (MQClientException e) {
         log.error("消费消息失败，e:{}", e);
         e.printStackTrace();
      } 
   }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XZaZMgnG-1676450636672)(RocketMQ-RocketMQ消息发送样例.assets/image-20230102220309925.png)]

4. 顺序消息

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

顺序消费的原理解析，在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取，则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。

核心代码：

public SendResult send(Message msg, MessageQueueSelector selector, Object arg)

Demo

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

1、首先定义一个订单步骤的pojo，并编写一个方法返回订单集合。

/**
 * 订单的步骤
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
private static class OrderStep {
   private long orderId;
   private String desc;

   @Override
   public String toString() {
      return "OrderStep{" +
            "orderId=" + orderId +
            ", desc='" + desc + '\'' +
            '}';
   }
}
/**
 * 生成模拟订单数据
 */
private List<OrderStep> buildOrders() {
   List<OrderStep> orderList = new ArrayList<>();
   orderList.add(new OrderStep(100001L, "创建"));
   orderList.add(new OrderStep(100002L, "创建"));
   orderList.add(new OrderStep(100001L, "付款"));
   orderList.add(new OrderStep(100003L, "创建"));
   orderList.add(new OrderStep(100002L, "付款"));
   orderList.add(new OrderStep(100003L, "付款"));
   orderList.add(new OrderStep(100002L, "完成"));
   orderList.add(new OrderStep(100001L, "推送"));
   orderList.add(new OrderStep(100003L, "完成"));
   orderList.add(new OrderStep(100001L, "完成"));
   return orderList;
}

2、发送消息

通过订单id来选择队列，致使在队列中的消息顺序是我们期望的。如：1号队列：100001L的创建、付款、推送

public class OrderProducer {

   public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
      DefaultMQProducer mqProducer = new DefaultMQProducer("group1");
      mqProducer.setNamesrvAddr("124.222.223.222:9876;47.96.232.192:9876");
      mqProducer.start();
      // 订单列表
      List<OrderStep> orderList = new OrderProducer().buildOrders();

      for (int i = 0; i < orderList.size(); i++) {
         String body = orderList.get(i).toString();
         Message msg = new Message("orderTopic", "Order", "KEY" + i, body.getBytes());
         /**
          * Params:
          *  - 消息对象
          *  - 消息队列的选择器
          *  - 选择队列的业务标识（订单ID）
          */
         SendResult sendResult = mqProducer.send(msg, new MessageQueueSelector() {
            /**
             * 选择指定的队列发送消息
             * @param mqs 队列的集合
             * @param msg 消息对象
             * @param arg 业务标识的参数
             * @return
             */
            @Override
            public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
               long orderId = (long) arg;
               int index = (int) (orderId % mqs.size());
               return mqs.get(index);
            }
         }, orderList.get(i).getOrderId());
         System.out.println("发送结果：" + sendResult);
      }
      mqProducer.shutdown();
   }

消费消息

public class OrderConsumer {
   public static void main(String[] args) throws MQClientException {
      DefaultMQPushConsumer mqPushConsumer = new DefaultMQPushConsumer("group1");
      mqPushConsumer.setNamesrvAddr("124.222.223.222:9876;47.96.232.192:9876");
      mqPushConsumer.subscribe("orderTopic", "*");

      // 注册消息监听器
      mqPushConsumer.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;
         }
      });

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

即我们可以通过指定队列，达到发送顺序和接收顺序一致～

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wewQ6Q7L-1676450660949)(RocketMQ-RocketMQ消息发送样例.assets/image-20230114154148363.png)]

5. 延时消息

延时消息，见名之意～延迟的消息，这里不是生产者发送消息的延迟，是MQ内部动作阻塞消息，从而达到消费者消费消息的延迟。比如说，在电商当中点击提交之后就生成了一个订单，且锁定了库存。可关于这个订单是否付款是否取消订单我们在此时是不知道的，可以在提交订单的同时发送一个延迟消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存。

核心代码：

public void setDelayTimeLevel(int level);

// 如：设置延时等级,消息将在等级对应的事件后发送（如等级3，这个消息将在10s之后发送。想看）
Message msg = new Message("delayTopic", "DEALY", ("Hello,延迟队列" + i).getBytes());
msg.setDelayTimeLevel(3);
mqProducer.send(msg);

但是我们需要注意，在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";

Demo

public class ScheduledMessageProducer {

	public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
		DefaultMQProducer mqProducer = new DefaultMQProducer("group1");
		mqProducer.setNamesrvAddr("124.222.223.222:9876;47.96.232.192:9876");
		mqProducer.start();
		for (int i = 0; i < 10; i++) {
			Message msg = new Message("delayTopic", "DEALY", ("Hello,延迟队列" + i).getBytes());
			// 设置延时等级，消息将在等级对应的事件后发送（如等级3，这个消息将在10s之后发送。想看）
			msg.setDelayTimeLevel(3);
			mqProducer.send(msg);
		}
		mqProducer.shutdown();
	}

}

public class ScheduledMessageConsumer {

	public static void main(String[] args) throws MQClientException {
		DefaultMQPushConsumer mqPushConsumer = new DefaultMQPushConsumer("group1");
		mqPushConsumer.setNamesrvAddr("124.222.223.222:9876;47.96.232.192:9876");
		// 订阅主题Topic和标签Tag
		mqPushConsumer.subscribe("delayTopic","*");
		mqPushConsumer.registerMessageListener(new MessageListenerConcurrently() {
			@Override
			public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
				for (MessageExt message : msgs) {
					// Print approximate delay time period
					System.out.println("Receive message[msgId=" + message.getMsgId() + "] " + (System.currentTimeMillis() - message.getStoreTimestamp()) + "ms later");
				}
				return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
			}
		});
		mqPushConsumer.start();
	}

}

您将会看到消息的消费比存储时间晚10秒

6. 批量消息

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

消息体大小最大为 4MB, 一般建议发送的消息体在 4kb 之内 ( 性能最佳 )。
消息属性最大为 32kb，一般建议发送的消息属性在 1kb 之内 ( 性能最佳 )。

4MB 这个上限值不能修改，这个会影响全局性能。如果消息体的确很大，建议侧优化消息体的内容，避免发送大消息或者带有链接地址的消息，或者可以缩短或者分两条发送。

核心代码

public SendResult send(Collection<Message> msgs)

注意：批量消息共不超过4MB

Demo

public class BatchProducer {

    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        DefaultMQProducer mqProducer = new DefaultMQProducer("group1");
        mqProducer.setNamesrvAddr("124.222.223.222:9876;47.96.232.192:9876");
        mqProducer.start();
        // 消息不超过4MB
        String topic = "BatchTest";
        List<Message> messages = new ArrayList<>(3);
        messages.add(new Message(topic, "TagA","OrderId001", "Hello World 1".getBytes()));
        messages.add(new Message(topic, "TagA","OrderId002", "Hello World 2".getBytes()));
        messages.add(new Message(topic, "TagA","OrderId003", "Hello World 3".getBytes()));
        mqProducer.send(messages);
        mqProducer.shutdown();
    }
}

run起来，面板可见批量消息发送成功！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pAO9PjXt-1676450725403)(RocketMQ-RocketMQ消息发送样例.assets/image-20230214113111452.png)]

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

首先我们编写一个分割迭代器

package com.hgw.easyrocketmq.batch;

import org.apache.rocketmq.common.message.Message;

import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * Description: MQ消息列表分割迭代器
 * 因MQ批量消息的总大小不应超过4MB，故编写此分割迭代器。
 *
 * @author LinHuiBa-YanAn
 * @date 2023/2/14 13:43
 */
public class ListSplitter implements Iterator<List<Message>> {

    /**
     * 消息体大小-4kb
     */
    private final Integer MSG_SIZE_LIMIT = 1024 * 4;
    private final List<Message> messages;
    private int currIndex;

    public ListSplitter(List<Message> messages) {
        this.messages = messages;
    }

    /**
     * Returns true if the iteration has more elements. (In other words, returns true if next would return an element rather than throwing an exception.)
     *
     * @return true if the iteration has more elements
     */
    @Override
    public boolean hasNext() {
        return currIndex < messages.size();
    }

    /**
     * Returns the next element in the iteration.
     *
     * @return the next element in the iteration
     */
    @Override
    public List<Message> next() {
        int nextIndex = currIndex;
        int totalSize = 0;
        while (nextIndex < messages.size()) {
            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();
            }
            // 增加日志的开销20字节
            tmpSize = tmpSize + 20;
            if (tmpSize > MSG_SIZE_LIMIT) {
                //单个消息超过了最大的限制
                //忽略,否则会阻塞分裂的进程
                if (nextIndex - currIndex == 0) {
                    //假如下一个子列表没有元素,则添加这个子列表然后退出循环,否则只是退出循环
                    nextIndex++;
                }
                break;
            }
            if (tmpSize + totalSize > MSG_SIZE_LIMIT) {
                break;
            } else {
                totalSize += tmpSize;
            }
            nextIndex++;
        }
        List<Message> subList = messages.subList(currIndex, nextIndex);
        currIndex = nextIndex;
        return subList;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qXIs8UpC-1676450725404)(RocketMQ-RocketMQ消息发送样例.assets/image-20230214143919511.png)]

7. 过滤消息

7.1 通过tag过滤

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

DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("CID_EXAMPLE");
consumer.subscribe("TOPIC", "TAGA || TAGB || TAGC");

消费者将接收包含TAGA或TAGB或TAGC的消息。

7.2 通过属性过滤

通过tag可以实现消息过滤，但是限制是一个消息只能有一个标签，这对于复杂的场景可能不起作用。在这种情况下，可以使用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 |
------------

RocketMQ只定义了一些基本语法来支持这个特性（org.apache.rocketmq.common.filter.ExpressionType）。你也可以很容易地扩展它。

数值比较，比如：>，>=，<，<=，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)

我们可以通过org.apache.rocketmq.common.message.Message#putUserProperty方法给消息设置属性

putUserProperty(final String name, final String value)

Demo

我们来演示一个仅订阅消息中具有a属性且范围在 6,9之间且包含的消息演示

在这里插入图片描述

正常情况下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0PnxcgrB-1676450783401)(RocketMQ-RocketMQ消息发送样例.assets/image-20230215143833214.png)]

注意：

需在conf/broker.conf中添加以下配置，并制定broker.conf启动。否则会出现下图报错～

enablePropertyFilter=true

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cIo3AXkt-1676450783401)(RocketMQ-RocketMQ消息发送样例.assets/image-20230215142743189.png)]

修改方案：

修改broker.conf配置文件

[root@hgwalibabacloud rocketmq-all-4.9.0-bin-release]# pwd
/soft/RocketMQ/rocketmq-all-4.9.0-bin-release
[root@hgwalibabacloud rocketmq-all-4.9.0-bin-release]# vim conf/broker.conf

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TP15GP1P-1676450783402)(RocketMQ-RocketMQ消息发送样例.assets/image-20230215143328228.png)]

重启broker~

[root@hgwalibabacloud rocketmq-all-4.9.0-bin-release]# sh bin/mqshutdown broker
The mqbroker(12486) is running...
Send shutdown request to mqbroker(12486) OK
[root@hgwalibabacloud rocketmq-all-4.9.0-bin-release]# nohup bin/mqbroker -c conf/broker.conf > ../store/log/broker.log 2>&1 &
[4] 18604
[2]   退出 143              nohup bin/mqbroker -c conf/broker.conf > ../store/log/broker.log 2>&1

8. 事务消息

谈到事务大家再熟悉不过了，那么大家想想如何将本地事务和消息收发结合成一个原子操作呢？

流程分析

大致可以分为两个流程，正常事务消息的发送及提交 + 事务消息的补偿机制。大致方案如下图～

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KP7hH9gz-1676450952848)(RocketMQ-RocketMQ消息发送样例.assets/事务消息.png)]

1、事务消息发送及提交

发送消息（half消息）。
服务端响应消息写入结果。
根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）。
根据本地事务状态执行Commit或者Rollback（Commit操作生成消息索引，消息对消费者可见）

2、事务补偿

对没有Commit/Rollback的事务消息（pending状态的消息），从服务端发起一次“回查”
Producer收到回查消息，检查回查消息对应的本地事务的状态
根据本地事务状态，重新Commit或者Rollback

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

3、事务消息状态

事务消息一共有三种状态

TransactionStatus.Unknown: 中间状态，它代表需要检查消息队列来确定状态。
TransactionStatus.CommitTransaction: 提交事务，它允许消费者消费此消息。
TransactionStatus.RollbackTransaction: 回滚事务，它代表该消息将被删除，不允许被消费。

使用限制

事务消息不支持延时消息和批量消息。
为了避免单个消息被检查太多次而导致半队列消息累积，我们默认将单个消息的检查次数限制为 15 次，但是用户可以通过 Broker 配置文件的 transactionCheckMax参数来修改此限制。如果已经检查某条消息超过 N 次的话（ N = transactionCheckMax ）则 Broker 将丢弃此消息，并在默认情况下同时打印错误日志。用户可以通过重写 AbstractTransactionCheckListener 类来修改这个行为。
事务消息将在 Broker 配置文件中的参数 transactionMsgTimeout 这样的特定时间长度之后被检查。当发送事务消息时，用户还可以通过设置用户属性 CHECK_IMMUNITY_TIME_IN_SECONDS 来改变这个限制，该参数优先于 transactionMsgTimeout 参数。
事务性消息可能不止一次被检查或消费。
提交给用户的目标主题消息可能会失败，目前这依日志的记录而定。它的高可用性通过 RocketMQ 本身的高可用性机制来保证，如果希望确保事务消息不丢失、并且事务完整性得到保证，建议使用同步的双重写入机制。
事务消息的生产者 ID 不能与其他类型消息的生产者 ID 共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者 ID 查询到消费者。

public class TransactionProducer {
    public static void main(String[] args) throws MQClientException, InterruptedException {
        // 创建消息生产者
        TransactionMQProducer mqProducer = new TransactionMQProducer("group2");
        mqProducer.setNamesrvAddr("47.96.232.192:9876");
        // 编写监听器逻辑
        mqProducer.setTransactionListener(new TransactionListener() {
            @Override
            public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
                System.out.println("执行本地事务");
                if (StringUtils.equals("TagA", msg.getTags())) {
                    return LocalTransactionState.COMMIT_MESSAGE;
                } else if (StringUtils.equals("TagB", msg.getTags())) {
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                } else {
                    return LocalTransactionState.UNKNOW;
                }
            }
            @Override
            public LocalTransactionState checkLocalTransaction(MessageExt msg) {
                System.out.println("MQ检查消息Tag【" + msg.getTags() + "】的本地事务执行结果");
                return LocalTransactionState.COMMIT_MESSAGE;
            }
        });
        // 启动消息生产者
        mqProducer.start();
        String[] tags = {"TagA", "TagB", "TagC"};
        for (int i = 0; i < 3; i++) {
            Message msg = new Message("TransactionTopic", tags[i % tags.length], "KEY" + i, ("Hello，RocketMQ" + i).getBytes(StandardCharsets.UTF_8));
            TransactionSendResult sendResult = mqProducer.sendMessageInTransaction(msg, null);
            System.out.println(sendResult);
            TimeUnit.SECONDS.sleep(1);
        }
        mqProducer.shutdown();
    }
}