【RocketMQ】2、RocketMQ基本消息使用

1、基本依赖

• 导入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.关闭生产者producer

• 消息消费者步骤

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

2、基本消息

2.1、消息发送

2.1.1、发送同步消息

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

    @Test
    /**
     * 简单生产发送者
     */
    public void simpleMQProducer() throws Exception {
        // 1、创建生产者
        DefaultMQProducer producer = new DefaultMQProducer("SimpleMQProducer");
        // 2、设置NameServer地址
        producer.setNamesrvAddr(SERVER_ADDR);
        // 3、启动生产者
        producer.start();
        for (int i = 0; i < 100; i++) {
            // 4、创建消费者，指定topic、tag
            Message message = new Message(
                    "SimpleTopic",
                    "SimpleTag",
                    ("Simple message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 5、发送消息
            SendResult result = producer.send(message);
            System.out.println(result);
        }
        // 6、关闭生产者
        producer.shutdown();
    }

2.1.2、发送异步消息

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

    @Test
    /**
     * 异步MQ生产者
     */
    public void asynMQProducer() throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("AsynMQProducer");
        producer.setNamesrvAddr(SERVER_ADDR);
        producer.start();
        // 异步发送失败的重试次数（默认为2）
        producer.setRetryTimesWhenSendAsyncFailed(0);


        for (int i = 0; i < 100; i++) {
            Message message = new Message(
                    "AsynTopic",
                    "AsynTag",
                    ("Asyn message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 接收异步返回的回调
            producer.send(message, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    int index = asynIndex.addAndGet(1);
                    System.out.printf("异步 %d 回调: %s \n", index, sendResult);

                }

                @Override
                public void onException(Throwable e) {
                    asynIndex.addAndGet(1);
                }
            });
        }

        while (true) {
            if (asynIndex.get() == 100) {
                // 保证消息都处理完毕
                break;
            }
        }
        producer.shutdown();

    }

2.1.3、单向发送消息

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

    @Test
    /**
     * 单向消息发送者
     */
    public void oneWayMQProducer() throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("OneWayMQProducer");
        producer.setNamesrvAddr(SERVER_ADDR);
        producer.start();

        for (int i = 0; i < 100; i++) {
            Message message = new Message(
                    "OneWayTopic",
                    "OneWayTag",
                    ("OneWay message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));

            // 发送单向消息，没有返回结果
            producer.sendOneway(message);
        }
        producer.shutdown();
    }

2.2、消息消费

2.2.1、负载均衡模式

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

    @Test
    /**
     * 负载均衡消费消息
     */
    public void loadBalanceConsumer() throws Exception {
        // 1、创建消费者，并指定消费者组
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("LoadBalanceConsumer");
        // 2、指定namesrv地址
        consumer.setNamesrvAddr(SERVER_ADDR);
        // 3、订阅Topic、Tag
        consumer.subscribe("SimpleTopic", "*");
        // 4、负载均衡消费
        consumer.setMessageModel(MessageModel.CLUSTERING);
        // 5、注册回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                System.out.printf("%s 处理消息：%s \n", Thread.currentThread().getName(), msgs);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        // 6、启动消息
        consumer.start();
        System.out.println("消息启动");
        System.in.read();
    }

2.2.2、广播模式

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

    @Test
    /**
     * 广播方式消费者
     */
    public void broadCastMQConsumer() throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("BroadCastMQConsumer");
        consumer.setNamesrvAddr(SERVER_ADDR);
        consumer.subscribe("SimpleTopic", "*");

        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                System.out.printf("%s 消费消息：%s \n", Thread.currentThread().getName(), msgs);
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        consumer.start();
        System.out.println("消息启动");
        System.in.read();
    }

3、顺序消息

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

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

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

3.1、顺序消息生产

    @Test
    /**
     * 有序消息发送者
     */
    public void orderMQProducer() throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("OrderMQProducer");
        producer.setNamesrvAddr(SERVER_ADDR);
        producer.start();
        String[] tags = new String[]{"TagA", "TagB", "TagC"};
        // 模拟订单列表
        List<HashMap<String, String>> orderList = new ArrayList<HashMap<String, String>>() {
            {
                add(new HashMap<String, String>() {{
                    put("orderId", "10010");
                    put("desc", "创建");
                }});
                add(new HashMap<String, String>() {{
                    put("orderId", "10011");
                    put("desc", "创建");
                }});
                add(new HashMap<String, String>() {{
                    put("orderId", "10012");
                    put("desc", "创建");
                }});

                add(new HashMap<String, String>() {{
                    put("orderId", "10010");
                    put("desc", "付款");
                }});
                add(new HashMap<String, String>() {{
                    put("orderId", "10011");
                    put("desc", "付款");
                }});
                add(new HashMap<String, String>() {{
                    put("orderId", "10012");
                    put("desc", "付款");
                }});

                add(new HashMap<String, String>() {{
                    put("orderId", "10010");
                    put("desc", "推送");
                }});
                add(new HashMap<String, String>() {{
                    put("orderId", "10011");
                    put("desc", "推送");
                }});
                add(new HashMap<String, String>() {{
                    put("orderId", "10012");
                    put("desc", "推送");
                }});

                add(new HashMap<String, String>() {{
                    put("orderId", "10010");
                    put("desc", "完成");
                }});
                add(new HashMap<String, String>() {{
                    put("orderId", "10011");
                    put("desc", "完成");
                }});
                add(new HashMap<String, String>() {{
                    put("orderId", "10012");
                    put("desc", "完成");
                }});

            }
        };

        for (int i = 0; i < orderList.size(); i++) {
            String body = "Order message" + orderList.get(i);
            Message message = new Message(
                    "OrderTopic",
                    tags[i % tags.length],
                    body.getBytes(RemotingHelper.DEFAULT_CHARSET));
            SendResult result = producer.send(message, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    Long id = Long.valueOf(String.valueOf(arg));//根据id选择发送的queue
                    long index = id % mqs.size();
                    return mqs.get((int) index);

                }
            }, orderList.get(i).get("orderId"));

            System.out.printf("消息发送状态：%s,消息队列id：%s,消息内容：%s %n",
                    result.getSendStatus(),
                    result.getMessageQueue().getQueueId(),
                    body);
        }
        producer.shutdown();
    }

3.2、顺序消息消费

    @Test
    /**
     * 有序消息消费者
     */
    public void orderMQConsumer() throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("OrderMQConsumer");
        consumer.setNamesrvAddr(SERVER_ADDR);

        /**
         * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
         * 如果非第一次启动，那么按照上次消费的位置继续消费
         */

        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.subscribe("OrderTopic", "TagA || TagB || TagC");

        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                context.setAutoCommit(true);
                for (MessageExt msg : msgs) {
                    System.out.printf("当前线程：%s,当前消息队列id：%s，内容：%s %n", Thread.currentThread().getName(), msg.getQueueId(), new String(msg.getBody()));
                }

                return ConsumeOrderlyStatus.SUCCESS;
            }
        });

        consumer.start();
        System.out.println("消费者启动");
        System.in.read();

    }

4、延时消息

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

4.1、启动消息消费者

    @Test
    /**
     * 延时消息消费者
     */
    public void scheduleMQConsumer() throws Exception {
        // 1、创建消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ScheduleMQConsumer");
        // 2、设置NameServer地址
        consumer.setNamesrvAddr(SERVER_ADDR);
        // 3、指定订阅Topic、Tag
        consumer.subscribe("ScheduleTopic", "*");
        // 4、注册处理函数
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.printf("当前线程：%s,当前时间：%s，当前内容：%s %n",
                            Thread.currentThread().getName(),
                            new SimpleDateFormat("HH:mm:ss").format(new Date()),
                            new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        // 5、启动消费者
        consumer.start();
        System.out.println("消费者启动");
        System.in.read();
    }

4.2、发送延时消息

    @Test
    /**
     * 延时消息生产者
     */
    public void scheduleMQProducer() throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("ScheduleMQProducer");
        producer.setNamesrvAddr(SERVER_ADDR);
        producer.start();
        Message message = new Message(
                "ScheduleTopic",
                "ScheduleTag",
                ("生产时间:" + new SimpleDateFormat("HH:mm:ss").format(new Date())).getBytes(RemotingHelper.DEFAULT_CHARSET));
        // 设置延时等级10s
        // 默认如下：String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";
        message.setDelayTimeLevel(3);
        producer.send(message);
        System.out.println("发送消息");
        producer.shutdown();

    }

4.3、使用限制

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

5、批量消息

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

5.1、发送批量消息

    @Test
    /**
     * 批量消息生产者
     */
    public void batchMQProducer() throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("BatchMQProducer");
        producer.setNamesrvAddr(SERVER_ADDR);

        producer.start();

        List<Message> messageList = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            messageList.add(new Message(
                    "BatchTopic",
                    "BatchTag",
                    ("Batch message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET)));
        }

        /*进行消息拆解*/
        MessageSplit msgSplit = new MessageSplit(messageList);
        while (msgSplit.hasNext()) {
            producer.send(msgSplit.next());
        }
        producer.shutdown();
        System.out.println("批量消息发送成功");

    }

    @Test
    /**
     * 批量消息消费者
     */
    public void batchMQConsumer() throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("BatchMQConsumer");
        consumer.setNamesrvAddr(SERVER_ADDR);
        consumer.subscribe("BatchTopic", "*");

        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.printf("当前线程：%s，消息内容：%s %n",
                            Thread.currentThread().getName(),
                            new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        consumer.start();
        System.out.println("消费者启动成功");
        System.in.read();

    }

    public class MessageSplit implements Iterator {
        private final Integer limitSize = 1024;
        private Boolean isSplit = false;
        private List<Message> messageList;
        private Integer currentIndex = 0;

        public MessageSplit(List<Message> messageList) {
            this.messageList = messageList;
        }


        @Override
        public boolean hasNext() {

            return currentIndex < messageList.size();
        }

        @Override
        public List<Message> next() {
            Integer nextIndex = currentIndex;
            Integer totalSize = 0;
            for (; nextIndex < messageList.size(); nextIndex++) {
                Message message = messageList.get(nextIndex);
                AtomicInteger tempSize = new AtomicInteger(message.getTopic().length() + message.getBody().length);
                message.getProperties().entrySet().parallelStream().forEach(entry -> {
                    tempSize.addAndGet(entry.getKey().length());
                    tempSize.addAndGet(entry.getValue().length());
                });
                if (tempSize.get() > limitSize) {
                    //单个消息超过了最大的限制
                    //忽略,否则会阻塞分裂的进程
                    if (nextIndex - currentIndex == 0) {
                        //假如下一个子列表没有元素,则添加这个子列表然后退出循环,否则只是退出循环
                        nextIndex++;
                    }
                    break;
                }
                if ((totalSize = tempSize.get() + totalSize) > limitSize) {
                    break;
                }
            }
            List<Message> msgSublit = messageList.subList(currentIndex, nextIndex);
            currentIndex = nextIndex;
            return msgSublit;
        }
    }

6、过滤消息

在大多数情况我们可以使用Tag来选择想要的消息。

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

同事mq提供了一个基于sql语法的过滤机制。

6.1、过滤sql语法

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

只有push模式的消费者才能用使用SQL92标准的sql语句。

public void subscribe(finalString topic, final MessageSelector messageSelector)

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

常量支持类型为：

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

6.2、消息生产者

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

    @Test
    /**
     * 过滤消息生产者
     */
    public void filterMQProducer() throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("FilterMQProducer");
        producer.setNamesrvAddr(SERVER_ADDR);
        producer.start();

        for (int i = 0; i < 10; i++) {
            Message message = new Message(
                    "FilterTopic",
                    "FilterTag",
                    ("Filter message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            message.putUserProperty("index", String.valueOf(i));
            producer.send(message);
        }
        producer.shutdown();
        System.out.println("消息发送成功");
    }

6.3、消息消费者

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

    @Test
    /**
     * 过滤消息消费
     */
    public void filterMQConsumer() throws Exception {
        Consumer<String> mqConsumer = (tempSql) -> {
            // 1、创建消费者组
            DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("FilterMQConsumer" + indexTag.getAndAdd(1));
            try {
                // 2、设置NameServier服务器地址
                consumer.setNamesrvAddr(SERVER_ADDR);
                // 3、订阅设置过滤条件
                consumer.subscribe("FilterTopic", MessageSelector.bySql(tempSql));
                // 4、注册消息响应函数
                consumer.registerMessageListener(new MessageListenerConcurrently() {
                    @Override
                    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                        msgs.forEach(msg -> {
                            System.out.printf("规则：%s,当前线程：%s，消息内容：%s %n",
                                    tempSql,
                                    Thread.currentThread().getName(),
                                    new String(msg.getBody()));
                        });
                        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
                    }
                });
                // 5、启动消费者
                consumer.start();
            } catch (MQClientException e) {
                e.printStackTrace();
            }
        };
        mqConsumer.accept("index < 3");
        mqConsumer.accept("index between 3 and 5");
        mqConsumer.accept("index > 5");
        System.out.println("消费者启动成功");
        System.in.read();
    }

7、事务消息

7.1、流程分析

其中分为两个流程：正常事务消息的发送及提交、事务消息的补偿流程。

7.1.1、事务消息发送及提交

(1) 发送消息（half消息）。

(2) 服务端响应消息写入结果。

(3) 根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）。

(4) 根据本地事务状态执行Commit或者Rollback（Commit操作生成消息索引，消息对消费者可见）

7.1.2、事务补偿

(1) 对没有Commit/Rollback的事务消息（pending状态的消息），从服务端发起一次“回查”

(2) Producer收到回查消息，检查回查消息对应的本地事务的状态

(3) 根据本地事务状态，重新Commit或者Rollback

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

7.1.3、事务消息状态

事务消息共有三种状态，提交状态、回滚状态、中间状态：

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

7.2、创建事务性生产者, 实现事务监听接口

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

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

public class TranscationMQMessage {
    private static String SERVER_ADDR = "192.168.1.4:9876";

    @Test
    /**
     * 事务消息生产者
     */
    public void transcationMQProducer() throws Exception {
        // 1、创建事务生产者
        TransactionMQProducer producer = new TransactionMQProducer("TranscationMQProducer");
        producer.setNamesrvAddr(SERVER_ADDR);
        // 2、指定事务监听者
        producer.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;
            }
        });
        // 3、启动生产者
        producer.start();
        String[] tags = new String[]{"TagA", "TagB", "TagC"};
        for (int i = 0; i < 3; i++) {
            Message msg = new Message(
                    "TranscationTopic",
                    tags[i % tags.length],
                    ("Transcation message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            producer.sendMessageInTransaction(msg, null);
        }
        System.out.println("发送消息成功");
        System.in.read();

    }
}

7.3、使用限制

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

8、SpringBoot整合RocketMQ

8.1、添加相关依赖

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>${rocketmq-spring-boot-starter-version}</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.6</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

8.2、配置Application

rocketmq.name-server=192.168.137.1:9876
rocketmq.producer.group=unique_springboot_group

8.3、编写消息生产者&消息消费者

• 消息生产者 RocketMQTemplate封装了大量直接操作的消息api，同时可以通过getProucer和createTransactionMQProducer来使用消息生产者

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = {Application.class})
public class SpringBootMQDemo {
    @Autowired
    RocketMQTemplate rocketMQTemplate;

    @Test
    public void spbMQProdducer() throws Exception {
        for (int i = 0; i < 100; i++) {
            rocketMQTemplate.convertAndSend("SPBRocketMQ", "Hello SpringBoot MQ Message" + i);
            System.out.println("发送成功");
        }
        System.in.read();
    }
}

• 消息消费者

注解提供了大量针对消息的操作。

@Component
@RocketMQMessageListener(topic = "SPBRocketMQ", consumerGroup = "unique_springboot_consumer_gourp")
public class SpringBootMQConsumer implements RocketMQListener<String> {
    @Override
    public void onMessage(String s) {
        System.out.printf("当前线程%s,消息内容%s %n", Thread.currentThread().getName(), s);
    }
}