04 消息发送样例

导入MQ客户端依赖

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

消息发送者步骤分析

1.创建消息生产者producer，并制定生产者组名
2.指定Nameserver地址
3.启动producer
4.创建消息对象，指定主题Topic、Tag和消息体
5.发送消息
6.关闭生产者produce

消息消费者步骤分析

1.创建消费者Consumer，制定消费者组名
2.指定Nameserver地址
3.订阅主题Topic和Tag
4.设置回调函数，处理消息
5.启动消费者consumer

官方文档

4.1、基本样例

4.1.1、消息发送

1）发送同步消息

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


package com.zj.base.producer;

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.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.concurrent.TimeUnit;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  14:50
 * 发送同步消息
 */
public class SynProducer {


    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {

//        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
//        2.指定Nameserver地址
        producer.setNamesrvAddr("47.98.144.17:9876;49.235.221.86:9876");
//        3.启动producer
        producer.start();
//        4.创建消息对象，指定主题Topic、Tag和消息体
        for(int i=0;i<10;i++){

            /**
             * 参数一：消息主题topic
             * 参数二：消息tag
             * 参数三：消息内容
             */
            Message message = new Message("base","Tag1",("Hello wold"+(i)).getBytes());
            //     5、发送消息(SendResult是broker会送给客户端的数据)
            SendResult result = producer.send(message);
            //发送状态
            SendStatus sendStatus =result.getSendStatus();
            //消息ID
            String msgId = result.getMsgId();
            //消息队列
            int queueId = result.getMessageQueue().getQueueId();
            System.out.println("发送装药"+result+"，消息ID"+msgId+",队列"+queueId);
//            TimeUnit.SECONDS.sleep(1);//线程睡1s
        }
//
//        6.关闭生产者producer
         producer.shutdown();


    }

}

2）发送异步消息

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

package com.zj.base.producer;

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.io.UnsupportedEncodingException;
import java.util.concurrent.TimeUnit;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  15:45
 * 异步消息  通常用在对响应时间敏感的业务场景，
 *         即发送端不能容忍长时间的等待Broker的响应
 */
public class AsyncProducer {

    public static void main(String[] args) throws MQClientException, UnsupportedEncodingException, RemotingException, InterruptedException {

        // 实例化消息生产者Producer
        DefaultMQProducer producer = new DefaultMQProducer("group1");

        //设置NameServer的地址
        producer.setNamesrvAddr("47.98.144.17:9876;49.235.221.86:9876");

        //启动producer实例
        producer.start();
        producer.setRetryTimesWhenSendAsyncFailed(0);

        for(int i=0;i<100;i++){

            final  int index = i;
            //创建消息，并指定Topic，Tag和消息体
            Message msg = new Message("TopicTest",
                                            "TagA",
                                             "OrderID188",
                                             "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET)
            );

            //SendCallback接受异步返回结果的回调
            producer.send(msg, new SendCallback() {

                //发送成功回调函数
                public void onSuccess(SendResult sendResult) {
//                    System.out.printf("%-10d OK %s %n",index,sendResult.getMsgId());
                    System.out.println("发送结果:"+sendResult);
                }

                //发送失败回调函数
                public void onException(Throwable throwable) {
//                    System.out.printf("%-10d Exception %s %n",index,throwable);
                    System.out.println("发送异常"+throwable);
                }
            });

            TimeUnit.SECONDS.sleep(1);

        }
        producer.shutdown();

    }

}

3）单向发送消息

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

package com.zj.base.producer;

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.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.concurrent.TimeUnit;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  16:21
 * 发送单向消息
 *
 */
public class OneWayProducer {

    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
        //        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
//        2.指定Nameserver地址
        producer.setNamesrvAddr("47.98.144.17:9876;49.235.221.86:9876");
//        3.启动producer
        producer.start();
//        4.创建消息对象，指定主题Topic、Tag和消息体
        for(int i=0;i<10;i++){

            /**
             * 参数一：消息主题topic
             * 参数二：消息tag
             * 参数三：消息内容
             */
            Message message = new Message("base","Tag3",("Hello wold，单向消息"+(i)).getBytes());
            //     5、发送单向消息
           producer.sendOneway(message);

            TimeUnit.SECONDS.sleep(1);//线程睡1s
        }
//
//        6.关闭生产者producer
        producer.shutdown();

    }

}

4.1.2 消费消息

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

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

package com.zj.base.consumer;

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.Message;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  16:30
 * 消息的接受者
 */
public class Consumer {


    public static void main(String[] args) throws MQClientException {
//        1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");

//        2.指定Nameserver地址
        consumer.setNamesrvAddr("47.98.144.17:9876;49.235.221.86:9876");
//        3.订阅主题Topic和Tag
        consumer.subscribe("base","Tag1");

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

//        4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            //接受消息内容的方法
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
               for(MessageExt msg:list){
                   System.out.println(new String(msg.getBody()));
               }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
//        5.启动消费者consumer
        consumer.start();
        System.out.println("消费者启动");


    }


}

4.2、顺序消息

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

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

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

4.2.1 顺序消息生产

package com.zj.order;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  16:56
 */
public class OrderStep {

    private long orderId;
    private String desc;

    public long getOrderId() {
        return orderId;
    }

    public void setOrderId(long orderId) {
        this.orderId = orderId;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "OrderStep{" +
                "orderId=" + orderId +
                ", desc='" + desc + '\'' +
                '}';
    }


    /**
     * 生成模拟订单数据
     */
    public static List<OrderStep> buildOrders() {
        List<OrderStep> orderList = new ArrayList<OrderStep>();


        //1039：创建 付款  推送  完成
        //1065 创建  付款
        //7235 创建  付款
        OrderStep orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("推送");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        return orderList;
    }
}


package com.zj.order;

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;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  16:59
 */
public class Producer {

    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {

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

        //获取订单
        List<OrderStep> orderSteps = OrderStep.buildOrders();

        //发送消息:同一个订单的ID发送到同一个队列中
        for(int i=0;i<orderSteps.size();i++){
            String body = orderSteps.get(i)+"";
            //构建消息对象
            Message msg = new Message("OrderTopic","Order","i"+i,body.getBytes());
            //参数1消息对象
            // 参数2：消息队列的选择器
            //参数3：选择队列的业务标志（订单ID)

               SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
                    /**
                     *
                     * @param list  队列集合
                     * @param message 消息对象
                     * @param o  参数，业务参数
                     * @return
                     *让同一个订单id在一个队列中，当然队列中还有其他订单id的消息
                     * 只要是订单ID一样则选择的消息队列是一样的
                     */
                    public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                        long orderId = (Long)o;
                        long index = orderId%list.size();
                        return list.get((int)index);
                    }
                },orderSteps.get(i).getOrderId());
            System.out.println("fas结果"+sendResult);
        }

        producer.shutdown();

    }
}

4.2.2 顺序消费消息


package com.zj.order;

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 org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  17:19
 */
public class Consumer {

    public static void main(String[] args) throws MQClientException {
//        1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");

//        2.指定Nameserver地址
        consumer.setNamesrvAddr("47.98.144.17:9876;49.235.221.86:9876");
//        3.订阅主题Topic和Tag
        consumer.subscribe("OrderTopic","*");

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

//        4.设置回调函数，处理消息 注册消息监听器
        consumer.registerMessageListener(new MessageListenerOrderly() {

            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
               for(MessageExt msg:list){

                   System.out.println(Thread.currentThread().getName()+"消费消息"+new String(msg.getBody()));
               }

                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
//        5.启动消费者consumer
        consumer.start();
        System.out.println("消费者启动");


    }

}

4.3、消息延时

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

4.3.1、启动消息消费者


package com.zj.delay;

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.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  17:28
 */
public class Producer {

    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {

//        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
//        2.指定Nameserver地址
        producer.setNamesrvAddr("47.98.144.17:9876;49.235.221.86:9876");
//        3.启动producer
        producer.start();
//        4.创建消息对象，指定主题Topic、Tag和消息体
        for(int i=0;i<10;i++){

            /**
             * 参数一：消息主题topic
             * 参数二：消息tag
             * 参数三：消息内容
             */
            Message message = new Message("DelayTopic","Tag1",("Hello wold"+(i)).getBytes());
            message.setDelayTimeLevel(2);//设置延迟时间
            //     5、发送消息(SendResult是broker会送给客户端的数据)
            SendResult result = producer.send(message);
            //发送状态
            SendStatus sendStatus =result.getSendStatus();
            //消息ID
            String msgId = result.getMsgId();
            //消息队列
            int queueId = result.getMessageQueue().getQueueId();
            System.out.println("发送装药"+result+"，消息ID"+msgId+",队列"+queueId);
//            TimeUnit.SECONDS.sleep(1);//线程睡1s
        }
//
//        6.关闭生产者producer
        producer.shutdown();


    }

}

4.3.2、发送延时消息

package com.zj.delay;

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 org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  17:28
 */
public class Consumer {

    public static void main(String[] args) throws MQClientException {
//        1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");

//        2.指定Nameserver地址
        consumer.setNamesrvAddr("47.98.144.17:9876;49.235.221.86:9876");
//        3.订阅主题Topic和Tag
        consumer.subscribe("DelayTopic","Tag1");

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

//        4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            //接受消息内容的方法
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for(MessageExt msg:list){
                    System.out.println("消息Id"+msg.getMsgId()+"延迟时间"+(System.currentTimeMillis()-msg.getStoreTimestamp()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
//        5.启动消费者consumer
        consumer.start();
        System.out.println("消费者秋冬");


    }

}

4.3.4、使用限制

// 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

4.4、批量信息

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

4.4.1 发送批量消息


package com.zj.batch;

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.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  17:35
 */
public class Producer {
    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {

//        1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
//        2.指定Nameserver地址
        producer.setNamesrvAddr("47.98.144.17:9876;49.235.221.86:9876");
//        3.启动producer
        producer.start();
//        4.创建消息对象，指定主题Topic、Tag和消息体
        List<Message> msgs = new ArrayList<Message>();

            /**
             * 参数一：消息主题topic
             * 参数二：消息tag
             * 参数三：消息内容
             */
            Message msg1 = new Message("BatchTopic","Tag1",("Hello wold1").getBytes());
            Message msg2 = new Message("BatchTopic","Tag1",("Hello wold2").getBytes());
            Message msg3 = new Message("BatchTopic","Tag1",("Hello wold3").getBytes());
            Message msg4 = new Message("BatchTopic","Tag1",("Hello wold4").getBytes());

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

            //     5、发送消息(SendResult是broker会送给客户端的数据)
            SendResult result = producer.send(msgs);
            //发送状态
            SendStatus sendStatus =result.getSendStatus();
            //消息ID
            String msgId = result.getMsgId();
            //消息队列
            int queueId = result.getMessageQueue().getQueueId();
            System.out.println("发送装药"+result+"，消息ID"+msgId+",队列"+queueId);
//            TimeUnit.SECONDS.sleep(1);//线程睡1s

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


    }

}

4.4.2、接受信息


package com.zj.batch;

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 org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/5/17 0017  17:35
 */
public class Consumer {
    public static void main(String[] args) throws MQClientException {
//        1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");

//        2.指定Nameserver地址
        consumer.setNamesrvAddr("47.98.144.17:9876;49.235.221.86:9876");
//        3.订阅主题Topic和Tag
        consumer.subscribe("BatchTopic","Tag1");

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

//        4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            //接受消息内容的方法
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for(MessageExt msg:list){
                    System.out.println(new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
//        5.启动消费者consumer
        consumer.start();
        System.out.println("消费者启动");


    }

}

4.5、过滤消息

在大多数情况下，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 |
------------

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语句，接口如下：

public void subscribe(finalString topic, final MessageSelector messageSelector)

4.5.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();

4.5.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();

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

4.6.1 发送事务消息

1) 创建事务性生产者

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

public class Producer {
    public static void main(String[] args) throws MQClientException, InterruptedException {
        //创建事务监听器
        TransactionListener transactionListener = new TransactionListenerImpl();
        //创建消息生产者
        TransactionMQProducer producer = new TransactionMQProducer("group6");
        producer.setNamesrvAddr("192.168.25.135:9876;192.168.25.138:9876");
        //生产者这是监听器
        producer.setTransactionListener(transactionListener);
        //启动消息生产者
        producer.start();
        String[] tags = new String[]{"TagA", "TagB", "TagC"};
        for (int i = 0; i < 3; i++) {
            try {
                Message msg = new Message("TransactionTopic", tags[i % tags.length], "KEY" + i,
                        ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
                SendResult sendResult = producer.sendMessageInTransaction(msg, null);
                System.out.printf("%s%n", sendResult);
                TimeUnit.SECONDS.sleep(1);
            } catch (MQClientException | UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        //producer.shutdown();
    }
}

2）实现事务的监听接口

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

public class TransactionListenerImpl implements 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;
    }
}

4.6.2 使用限制

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

04 消息发送样例

文章目录

4.1、基本样例

4.1.1、消息发送

1）发送同步消息

2）发送异步消息

3）单向发送消息

4.1.2 消费消息

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

4.2、顺序消息

4.2.1 顺序消息生产

4.2.2 顺序消费消息

4.3、消息延时

4.3.1、启动消息消费者

4.3.2、发送延时消息

4.3.4、使用限制

4.4、批量信息

4.4.1 发送批量消息

4.4.2、接受信息

4.5、过滤消息

4.5.1 SQL基本语法

4.5.2 消息生产者

4.5.3 消息消费者

4.6 事务消息

1）事务消息发送及提交

2）事务补偿

3）事务消息状态

4.6.1 发送事务消息

1) 创建事务性生产者

2）实现事务的监听接口

4.6.2 使用限制

公众号5月C#/.NET热文一览

流量削峯技術

查詢優化技術之多級緩存（數據庫）

交易性能優化技術之緩存庫存

代理模式(Spring AOP）

原子類包分析實現

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

04 消息发送样例

文章目录

4.1、基本样例

4.1.1、消息发送

1）发送同步消息

2）发送异步消息

3）单向发送消息

4.1.2 消费消息

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

4.2、顺序消息

4.2.1 顺序消息生产

4.2.2 顺序消费消息

4.3、消息延时

4.3.1、 启动消息消费者

4.3.2、发送延时消息

4.3.4、使用限制

4.4、批量信息

4.4.1 发送批量消息

4.4.2、接受信息

4.5、过滤消息

4.5.1 SQL基本语法

4.5.2 消息生产者

4.5.3 消息消费者

4.6 事务消息

1）事务消息发送及提交

2）事务补偿

3）事务消息状态

4.6.1 发送事务消息

1) 创建事务性生产者

2）实现事务的监听接口

4.6.2 使用限制

4.3.1、启动消息消费者