• 导入MQ客户端依赖
  1. <dependency>
  2.     <groupId>org.apache.rocketmq</groupId>
  3.     <artifactId>rocketmq-client</artifactId>
  4.     <version>4.4.0</version>
  5. </dependency>
  • 消息发送者步骤分析
  1. 1.创建消息生产者producer，并制定生产者组名
  2. 2.指定Nameserver地址
  3. 3.启动producer
  4. 4.创建消息对象，指定主题Topic、Tag和消息体
  5. 5.发送消息
  6. 6.关闭生产者producer
  • 消息消费者步骤分析
  1. 1.创建消费者Consumer，制定消费者组名
  2. 2.指定Nameserver地址
  3. 3.订阅主题Topic和Tag
  4. 4.设置回调函数，处理消息
  5. 5.启动消费者consumer

4.1 基本样例

4.1.1 消息发送

1）发送同步消息

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

  1. public class SyncProducer {
  2.     public static void main(String[] args) throws Exception {
  3.         // 实例化消息生产者Producer
  4.         DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
  5.         // 设置NameServer的地址
  6.         producer.setNamesrvAddr("localhost:9876");
  7.         // 启动Producer实例
  8.         producer.start();
  9.         for (int i = 0; i < 100; i++) {
  10.             // 创建消息，并指定Topic，Tag和消息体
  11.             Message msg = new Message("TopicTest" /* Topic */,
  12.             "TagA" /* Tag */,
  13.             ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
  14.             );
  15.             // 发送消息到一个Broker
  16.             SendResult sendResult = producer.send(msg);
  17.             // 通过sendResult返回消息是否成功送达
  18.             System.out.printf("%s%n", sendResult);
  19.         }
  20.         // 如果不再发送消息，关闭Producer实例。
  21.         producer.shutdown();
  22.     }
  23. }

2）发送异步消息

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

  1. public class AsyncProducer {
  2.     public static void main(String[] args) throws Exception {
  3.         // 实例化消息生产者Producer
  4.         DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
  5.         // 设置NameServer的地址
  6.         producer.setNamesrvAddr("localhost:9876");
  7.         // 启动Producer实例
  8.         producer.start();
  9.         producer.setRetryTimesWhenSendAsyncFailed(0);
  10.         for (int i = 0; i < 100; i++) {
  11.                 final int index = i;
  12.                 // 创建消息，并指定Topic，Tag和消息体
  13.                 Message msg = new Message("TopicTest",
  14.                     "TagA",
  15.                     "OrderID188",
  16.                     "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
  17.                 // SendCallback接收异步返回结果的回调
  18.                 producer.send(msg, new SendCallback() {
  19.                     @Override
  20.                     public void onSuccess(SendResult sendResult) {
  21.                         System.out.printf("%-10d OK %s %n", index,
  22.                             sendResult.getMsgId());
  23.                     }
  24.                     @Override
  25.                     public void onException(Throwable e) {
  26.                         System.out.printf("%-10d Exception %s %n", index, e);
  27.                         e.printStackTrace();
  28.                     }
  29.                 });
  30.         }
  31.         // 如果不再发送消息，关闭Producer实例。
  32.         producer.shutdown();
  33.     }
  34. }

3）单向发送消息

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

  1. public class OnewayProducer {
  2.     public static void main(String[] args) throws Exception{
  3.         // 实例化消息生产者Producer
  4.         DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
  5.         // 设置NameServer的地址
  6.         producer.setNamesrvAddr("localhost:9876");
  7.         // 启动Producer实例
  8.         producer.start();
  9.         for (int i = 0; i < 100; i++) {
  10.             // 创建消息，并指定Topic，Tag和消息体
  11.             Message msg = new Message("TopicTest" /* Topic */,
  12.                 "TagA" /* Tag */,
  13.                 ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
  14.             );
  15.             // 发送单向消息，没有任何返回结果
  16.             producer.sendOneway(msg);
  18.         }
  19.         // 如果不再发送消息，关闭Producer实例。
  20.         producer.shutdown();
  21.     }
  22. }

4.1.2 消费消息

1）负载均衡模式(默认)

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

  1. public static void main(String[] args) throws Exception {
  2.     // 实例化消息生产者,指定组名
  3.     DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
  4.     // 指定Namesrv地址信息.
  5.     consumer.setNamesrvAddr("localhost:9876");
  6.     // 订阅Topic
  7.     consumer.subscribe("Test", "*");
  8.     //负载均衡模式消费
  9.     consumer.setMessageModel(MessageModel.CLUSTERING);
  10.     // 注册回调函数，处理消息
  11.     consumer.registerMessageListener(new MessageListenerConcurrently() {
  12.         @Override
  13.         public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
  14.                                                         ConsumeConcurrentlyContext context) {
  15.             System.out.printf("%s Receive New Messages: %s %n", 
  16.                               Thread.currentThread().getName(), msgs);
  17.             return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
  18.         }
  19.     });
  20.     //启动消息者
  21.     consumer.start();
  22.     System.out.printf("Consumer Started.%n");
  23. }

2）广播模式

消费者采用广播的方式消费消息，每个消费者消费的消息都是相同的

  1. public static void main(String[] args) throws Exception {
  2.     // 实例化消息生产者,指定组名
  3.     DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
  4.     // 指定Namesrv地址信息.
  5.     consumer.setNamesrvAddr("localhost:9876");
  6.     // 订阅Topic
  7.     consumer.subscribe("Test", "*");
  8.     //广播模式消费
  9.     consumer.setMessageModel(MessageModel.BROADCASTING);
  10.     // 注册回调函数，处理消息
  11.     consumer.registerMessageListener(new MessageListenerConcurrently() {
  12.         @Override
  13.         public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
  14.                                                         ConsumeConcurrentlyContext context) {
  15.             System.out.printf("%s Receive New Messages: %s %n", 
  16.                               Thread.currentThread().getName(), msgs);
  17.             return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
  18.         }
  19.     });
  20.     //启动消息者
  21.     consumer.start();
  22.     System.out.printf("Consumer Started.%n");
  23. }

4.2 顺序消息

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

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

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

4.2.1 顺序消息生产

  1. /**
  2. * Producer，发送顺序消息
  3. */
  4. public class Producer {
  6.    public static void main(String[] args) throws Exception {
  7.        DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
  9.        producer.setNamesrvAddr("127.0.0.1:9876");
  11.        producer.start();
  13.        String[] tags = new String[]{"TagA", "TagC", "TagD"};
  15.        // 订单列表
  16.        List<OrderStep> orderList = new Producer().buildOrders();
  18.        Date date = new Date();
  19.        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  20.        String dateStr = sdf.format(date);
  21.        for (int i = 0; i < 10; i++) {
  22.            // 加个时间前缀
  23.            String body = dateStr + " Hello RocketMQ " + orderList.get(i);
  24.            Message msg = new Message("TopicTest", tags[i % tags.length], "KEY" + i, body.getBytes());
  26.            SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
  27.                @Override
  28.                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
  29.                    Long id = (Long) arg;  //根据订单id选择发送queue
  30.                    long index = id % mqs.size();
  31.                    return mqs.get((int) index);
  32.                }
  33.            }, orderList.get(i).getOrderId());//订单id
  35.            System.out.println(String.format("SendResult status:%s, queueId:%d, body:%s",
  36.                sendResult.getSendStatus(),
  37.                sendResult.getMessageQueue().getQueueId(),
  38.                body));
  39.        }
  41.        producer.shutdown();
  42.    }
  44.    /**
  45.     * 订单的步骤
  46.     */
  47.    private static class OrderStep {
  48.        private long orderId;
  49.        private String desc;
  51.        public long getOrderId() {
  52.            return orderId;
  53.        }
  55.        public void setOrderId(long orderId) {
  56.            this.orderId = orderId;
  57.        }
  59.        public String getDesc() {
  60.            return desc;
  61.        }
  63.        public void setDesc(String desc) {
  64.            this.desc = desc;
  65.        }
  67.        @Override
  68.        public String toString() {
  69.            return "OrderStep{" +
  70.                "orderId=" + orderId +
  71.                ", desc='" + desc + '\'' +
  72.                '}';
  73.        }
  74.    }
  76.    /**
  77.     * 生成模拟订单数据
  78.     */
  79.    private List<OrderStep> buildOrders() {
  80.        List<OrderStep> orderList = new ArrayList<OrderStep>();
  82.        OrderStep orderDemo = new OrderStep();
  83.        orderDemo.setOrderId(15103111039L);
  84.        orderDemo.setDesc("创建");
  85.        orderList.add(orderDemo);
  87.        orderDemo = new OrderStep();
  88.        orderDemo.setOrderId(15103111065L);
  89.        orderDemo.setDesc("创建");
  90.        orderList.add(orderDemo);
  92.        orderDemo = new OrderStep();
  93.        orderDemo.setOrderId(15103111039L);
  94.        orderDemo.setDesc("付款");
  95.        orderList.add(orderDemo);
  97.        orderDemo = new OrderStep();
  98.        orderDemo.setOrderId(15103117235L);
  99.        orderDemo.setDesc("创建");
  100.        orderList.add(orderDemo);
  102.        orderDemo = new OrderStep();
  103.        orderDemo.setOrderId(15103111065L);
  104.        orderDemo.setDesc("付款");
  105.        orderList.add(orderDemo);
  107.        orderDemo = new OrderStep();
  108.        orderDemo.setOrderId(15103117235L);
  109.        orderDemo.setDesc("付款");
  110.        orderList.add(orderDemo);
  112.        orderDemo = new OrderStep();
  113.        orderDemo.setOrderId(15103111065L);
  114.        orderDemo.setDesc("完成");
  115.        orderList.add(orderDemo);
  117.        orderDemo = new OrderStep();
  118.        orderDemo.setOrderId(15103111039L);
  119.        orderDemo.setDesc("推送");
  120.        orderList.add(orderDemo);
  122.        orderDemo = new OrderStep();
  123.        orderDemo.setOrderId(15103117235L);
  124.        orderDemo.setDesc("完成");
  125.        orderList.add(orderDemo);
  127.        orderDemo = new OrderStep();
  128.        orderDemo.setOrderId(15103111039L);
  129.        orderDemo.setDesc("完成");
  130.        orderList.add(orderDemo);
  132.        return orderList;
  133.    }
  134. }

4.2.2 顺序消费消息

  1. /**
  2. * 顺序消息消费，带事务方式（应用可控制Offset什么时候提交）
  3. */
  4. public class ConsumerInOrder {
  6.    public static void main(String[] args) throws Exception {
  7.        DefaultMQPushConsumer consumer = new 
  8.            DefaultMQPushConsumer("please_rename_unique_group_name_3");
  9.        consumer.setNamesrvAddr("127.0.0.1:9876");
  10.        /**
  11.         * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
  12.         * 如果非第一次启动，那么按照上次消费的位置继续消费
  13.         */
  14.        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
  16.        consumer.subscribe("TopicTest", "TagA || TagC || TagD");
  18.        consumer.registerMessageListener(new MessageListenerOrderly() {
  20.            Random random = new Random();
  22.            @Override
  23.            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
  24.                context.setAutoCommit(true);
  25.                for (MessageExt msg : msgs) {
  26.                    // 可以看到每个queue有唯一的consume线程来消费, 订单对每个queue(分区)有序
  27.                    System.out.println("consumeThread=" + Thread.currentThread().getName() + "queueId=" + msg.getQueueId() + ", content:" + new String(msg.getBody()));
  28.                }
  30.                try {
  31.                    //模拟业务逻辑处理中...
  32.                    TimeUnit.SECONDS.sleep(random.nextInt(10));
  33.                } catch (Exception e) {
  34.                    e.printStackTrace();
  35.                }
  36.                return ConsumeOrderlyStatus.SUCCESS;
  37.            }
  38.        });
  40.        consumer.start();
  42.        System.out.println("Consumer Started.");
  43.    }
  44. }

4.3 延时消息

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

4.3.1 启动消息消费者

  1. public class ScheduledMessageConsumer {
  2.    public static void main(String[] args) throws Exception {
  3.       // 实例化消费者
  4.       DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ExampleConsumer");
  5.       // 订阅Topics
  6.       consumer.subscribe("TestTopic", "*");
  7.       // 注册消息监听者
  8.       consumer.registerMessageListener(new MessageListenerConcurrently() {
  9.           @Override
  10.           public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> messages, ConsumeConcurrentlyContext context) {
  11.               for (MessageExt message : messages) {
  12.                   // Print approximate delay time period
  13.                   System.out.println("Receive message[msgId=" + message.getMsgId() + "] " + (System.currentTimeMillis() - message.getStoreTimestamp()) + "ms later");
  14.               }
  15.               return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
  16.           }
  17.       });
  18.       // 启动消费者
  19.       consumer.start();
  20.   }
  21. }

4.3.2 发送延时消息

  1. public class ScheduledMessageProducer {
  2.    public static void main(String[] args) throws Exception {
  3.       // 实例化一个生产者来产生延时消息
  4.       DefaultMQProducer producer = new DefaultMQProducer("ExampleProducerGroup");
  5.       // 启动生产者
  6.       producer.start();
  7.       int totalMessagesToSend = 100;
  8.       for (int i = 0; i < totalMessagesToSend; i++) {
  9.           Message message = new Message("TestTopic", ("Hello scheduled message " + i).getBytes());
  10.           // 设置延时等级3,这个消息将在10s之后发送(现在只支持固定的几个时间,详看delayTimeLevel)
  11.           message.setDelayTimeLevel(3);
  12.           // 发送消息
  13.           producer.send(message);
  14.       }
  15.        // 关闭生产者
  16.       producer.shutdown();
  17.   }
  18. }

4.3.3 验证

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

4.3.4 使用限制

  1. // org/apache/rocketmq/store/config/MessageStoreConfig.java
  2. 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

4.4 批量消息

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

4.4.1 发送批量消息

如果您每次只发送不超过4MB的消息，则很容易使用批处理，样例如下：

  1. String topic = "BatchTest";
  2. List<Message> messages = new ArrayList<>();
  3. messages.add(new Message(topic, "TagA", "OrderID001", "Hello world 0".getBytes()));
  4. messages.add(new Message(topic, "TagA", "OrderID002", "Hello world 1".getBytes()));
  5. messages.add(new Message(topic, "TagA", "OrderID003", "Hello world 2".getBytes()));
  6. try {
  7.    producer.send(messages);
  8. } catch (Exception e) {
  9.    e.printStackTrace();
  10.    //处理error
  11. }

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

  1. public class ListSplitter implements Iterator<List<Message>> {
  2.    private final int SIZE_LIMIT = 1024 * 1024 * 4;
  3.    private final List<Message> messages;
  4.    private int currIndex;
  5.    public ListSplitter(List<Message> messages) {
  6.            this.messages = messages;
  7.    }
  8.     @Override 
  9.     public boolean hasNext() {
  10.        return currIndex < messages.size();
  11.    }
  12.        @Override 
  13.     public List<Message> next() {
  14.        int nextIndex = currIndex;
  15.        int totalSize = 0;
  16.        for (; nextIndex < messages.size(); nextIndex++) {
  17.            Message message = messages.get(nextIndex);
  18.            int tmpSize = message.getTopic().length() + message.getBody().length;
  19.            Map<String, String> properties = message.getProperties();
  20.            for (Map.Entry<String, String> entry : properties.entrySet()) {
  21.                tmpSize += entry.getKey().length() + entry.getValue().length();
  22.            }
  23.            tmpSize = tmpSize + 20; // 增加日志的开销20字节
  24.            if (tmpSize > SIZE_LIMIT) {
  25.                //单个消息超过了最大的限制
  26.                //忽略,否则会阻塞分裂的进程
  27.                if (nextIndex - currIndex == 0) {
  28.                   //假如下一个子列表没有元素,则添加这个子列表然后退出循环,否则只是退出循环
  29.                   nextIndex++;
  30.                }
  31.                break;
  32.            }
  33.            if (tmpSize + totalSize > SIZE_LIMIT) {
  34.                break;
  35.            } else {
  36.                totalSize += tmpSize;
  37.            }
  39.        }
  40.        List<Message> subList = messages.subList(currIndex, nextIndex);
  41.        currIndex = nextIndex;
  42.        return subList;
  43.    }
  44. }
  45. //把大的消息分裂成若干个小的消息
  46. ListSplitter splitter = new ListSplitter(messages);
  47. while (splitter.hasNext()) {
  48.   try {
  49.       List<Message>  listItem = splitter.next();
  50.       producer.send(listItem);
  51.   } catch (Exception e) {
  52.       e.printStackTrace();
  53.       //处理error
  54.   }
  55. }

4.5 过滤消息

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

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

消费者将接收包含TAGA或TAGB或TAGC的消息。但是限制是一个消息只能有一个标签，这对于复杂的场景可能不起作用。在这种情况下，可以使用SQL表达式筛选消息。SQL特性可以通过发送消息时的属性来进行计算。在RocketMQ定义的语法下，可以实现一些简单的逻辑。下面是一个例子：

  1. ------------
  2. | message  |
  3. |----------|  a > 5 AND b = 'abc'
  4. | a = 10   |  --------------------> Gotten
  5. | b = 'abc'|
  6. | c = true |
  7. ------------
  8. ------------
  9. | message  |
  10. |----------|   a > 5 AND b = 'abc'
  11. | a = 1    |  --------------------> Missed
  12. | b = 'abc'|
  13. | c = true |
  14. ------------

4.5.1 SQL基本语法

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

  • 数值比较，比如：>，>=，<，<=，BETWEEN，=；
  • 字符比较，比如：=，<>，IN；
  • IS NULL 或者 IS NOT NULL；
  • 逻辑符号 AND，OR，NOT；

常量支持类型为：

  • 数值，比如：123，3.1415；
  • 字符，比如：‘abc’，必须用单引号包裹起来；
  • NULL，特殊的常量
  • 布尔值，TRUE 或 FALSE

只有使用push模式的消费者才能用使用SQL92标准的sql语句，接口如下：

  1. public void subscribe(finalString topic, final MessageSelector messageSelector)

4.5.2 消息生产者

发送消息时，你能通过putUserProperty来设置消息的属性

  1. DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
  2. producer.start();
  3. Message msg = new Message("TopicTest",
  4.    tag,
  5.    ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET)
  6. );
  7. // 设置一些属性
  8. msg.putUserProperty("a", String.valueOf(i));
  9. SendResult sendResult = producer.send(msg);
  11. producer.shutdown();

4.5.3 消息消费者

用MessageSelector.bySql来使用sql筛选消息

  1. DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_4");
  2. // 只有订阅的消息有这个属性a, a >=0 and a <= 3
  3. consumer.subscribe("TopicTest", MessageSelector.bySql("a between 0 and 3");
  4. consumer.registerMessageListener(new MessageListenerConcurrently() {
  5.    @Override
  6.    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
  7.        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
  8.    }
  9. });
  10. consumer.start();

4.6 事务消息

4.6.1 流程分析

image.png

上图说明了事务消息的大致方案，其中分为两个流程：正常事务消息的发送及提交、事务消息的补偿流程。

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: 中间状态，它代表需要检查消息队列来确定状态。

4.6.1 发送事务消息

1) 创建事务性生产者

使用 TransactionMQProducer类创建生产者，并指定唯一的 ProducerGroup，就可以设置自定义线程池来处理这些检查请求。执行本地事务后、需要根据执行结果对消息队列进行回复。回传的事务状态在请参考前一节。

  1. public class Producer {
  2.     public static void main(String[] args) throws MQClientException, InterruptedException {
  3.         //创建事务监听器
  4.         TransactionListener transactionListener = new TransactionListenerImpl();
  5.         //创建消息生产者
  6.         TransactionMQProducer producer = new TransactionMQProducer("group6");
  7.         producer.setNamesrvAddr("192.168.25.135:9876;192.168.25.138:9876");
  8.         //生产者这是监听器
  9.         producer.setTransactionListener(transactionListener);
  10.         //启动消息生产者
  11.         producer.start();
  12.         String[] tags = new String[]{"TagA", "TagB", "TagC"};
  13.         for (int i = 0; i < 3; i++) {
  14.             try {
  15.                 Message msg = new Message("TransactionTopic", tags[i % tags.length], "KEY" + i,
  16.                         ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
  17.                 SendResult sendResult = producer.sendMessageInTransaction(msg, null);
  18.                 System.out.printf("%s%n", sendResult);
  19.                 TimeUnit.SECONDS.sleep(1);
  20.             } catch (MQClientException | UnsupportedEncodingException e) {
  21.                 e.printStackTrace();
  22.             }
  23.         }
  24.         //producer.shutdown();
  25.     }
  26. }

2）实现事务的监听接口

当发送半消息成功时，我们使用 executeLocalTransaction 方法来执行本地事务。它返回前一节中提到的三个事务状态之一。checkLocalTranscation 方法用于检查本地事务状态，并回应消息队列的检查请求。它也是返回前一节中提到的三个事务状态之一。

  1. public class TransactionListenerImpl implements TransactionListener {
  3.     @Override
  4.     public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
  5.         System.out.println("执行本地事务");
  6.         if (StringUtils.equals("TagA", msg.getTags())) {
  7.             return LocalTransactionState.COMMIT_MESSAGE;
  8.         } else if (StringUtils.equals("TagB", msg.getTags())) {
  9.             return LocalTransactionState.ROLLBACK_MESSAGE;
  10.         } else {
  11.             return LocalTransactionState.UNKNOW;
  12.         }
  14.     }
  16.     @Override
  17.     public LocalTransactionState checkLocalTransaction(MessageExt msg) {
  18.         System.out.println("MQ检查消息Tag【"+msg.getTags()+"】的本地事务执行结果");
  19.         return LocalTransactionState.COMMIT_MESSAGE;
  20.     }
  21. }

4.6.2 使用限制

  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 查询到消费者。