RocketMQ 三种发消息的方式

本文主要 使用 RocketMQ-Spring 封装提供的 RocketMQTemplate ，实现三种(同步、异步、oneway)发送消息的方式。Producer在进行消息发送时可以是阻塞的，也可以是非阻塞的。具体对应到发送方式一共有三种，分别是同步、异步和单向的（ONEWAY）

异步：

rocketMQTemplate.asyncSend(TOPIC, message, callback);
该方法是非阻塞的，发送结果将由一个回调函数callback进行回调。它与同步发送消息的区别是它在发送消息时多传递了一个SendCallback对象，该方法一调用立马返回，而不需要等待Broker的响应返回。消息发送成功或失败后将回调SendCallback对象的对应方法。

同步：

rocketMQTemplate.syncSend(TOPIC, message); 
该方法底层调用的是 producer.send()方法，是阻塞的，producer 一定要等到Broker进行了响应后才会返回，才能继续往下执行。如果超时，或者失败了，会触发两次默认的重试。

oneway：

rocketMQTemplate.sendOneWay(TOPIC, message);它的发送是通过调用sendOneway()发送的。它的发送是单向的，即它不需要等待Broker的响应，只管发送即可，而不论发送成功与失败。通常应用于一些消息不是那么重要，可丢失的场景。

1、引入pom.xml 依赖

        
        
            org.apache.rocketmq
            rocketmq-spring-boot-starter
            2.1.1
        

2、应用配置文件  application.yaml 

# rocketmq 配置项，对应 RocketMQProperties 配置类
rocketmq:
  name-server: 127.0.0.1:9876 # RocketMQ Namesrv
  # Producer 配置项
  producer:
    group: koala-dev-event-centre-group # 生产者分组
    send-message-timeout: 3000 # 发送消息超时时间，单位：毫秒。默认为 3000 。
    compress-message-body-threshold: 4096 # 消息压缩阀值，当消息体的大小超过该阀值后，进行消息压缩。默认为 4 * 1024B
    max-message-size: 4194304 # 消息体的最大允许大小。。默认为 4 * 1024 * 1024B
    retry-times-when-send-failed: 2 # 同步发送消息时，失败重试次数。默认为 2 次。
    retry-times-when-send-async-failed: 2 # 异步发送消息时，失败重试次数。默认为 2 次。
    retry-next-server: false # 发送消息给 Broker 时，如果发送失败，是否重试另外一台 Broker 。默认为 false
    access-key: # Access Key ，可阅读 https://github.com/apache/rocketmq/blob/master/docs/cn/acl/user_guide.md 文档
    secret-key: # Secret Key
    enable-msg-trace: true # 是否开启消息轨迹功能。默认为 true 开启。可阅读 https://github.com/apache/rocketmq/blob/master/docs/cn/msg_trace/user_guide.md 文档
    customized-trace-topic: RMQ_SYS_TRACE_TOPIC # 自定义消息轨迹的 Topic 。默认为 RMQ_SYS_TRACE_TOPIC 。
  # Consumer 配置项
  consumer:
    listeners: # 配置某个消费分组，是否监听指定 Topic 。结构为 Map<消费者分组, > 。默认情况下，不配置表示监听。
      erbadagang-consumer-group:
        topic1: false # 关闭 test-consumer-group 对 topic1 的监听消费

RocketMQ-Spring RocketMQAutoConfiguration 自动化配置类，实现 RocketMQ 的自动配置，创建相应的 Producer 和 Consumer 。

3、message

创建一个消息类

package com.example.demo.mq.message;

public class Demo01Message {

    public static final String TOPIC = "koala-dev-event-centre";

    /**
     * 编号
     */
    private Integer id;

    public Demo01Message setId(Integer id) {
        this.id = id;
        return this;
    }

    public Integer getId() {
        return id;
    }

    @Override
    public String toString() {
        return "Demo01Message{" +
                "id=" + id +
                '}';
    }

}

4、Producer

使用 RocketMQ-Spring 封装提供的 RocketMQTemplate ，实现三种(同步、异步、oneway)发送消息的方式

package com.example.demo.mq.producer;

import com.example.demo.mq.message.Demo01Message;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 使用 RocketMQ-Spring 封装提供的 RocketMQTemplate ，实现三种(同步、异步、oneway)发送消息的方式
 */
@Component
public class Demo01Producer {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    public SendResult syncSend(Integer id) {
        // 创建 Demo01Message 消息
        Demo01Message message = new Demo01Message();
        message.setId(id);
        // 同步发送消息
        return rocketMQTemplate.syncSend(Demo01Message.TOPIC, message);
    }

    public void asyncSend(Integer id, SendCallback callback) {
        // 创建 Demo01Message 消息
        Demo01Message message = new Demo01Message();
        message.setId(id);
        // 异步发送消息
        rocketMQTemplate.asyncSend(Demo01Message.TOPIC, message, callback);
    }

    public void onewaySend(Integer id) {
        // 创建 Demo01Message 消息
        Demo01Message message = new Demo01Message();
        message.setId(id);
        // oneway 发送消息
        rocketMQTemplate.sendOneWay(Demo01Message.TOPIC, message);
    }

}

三个方法，对应三个 RocketMQ 发送消息的方式，分别调用 RocketMQTemplate 提供的 #syncSend(...) 和 #asyncSend(...) 以及 #sendOneWay(...) 方法。

5、Consumer

实现 Rocket-Spring 定义的 RocketMQListener 接口，消费消息

package com.example.demo.mq.consumer;


import com.example.demo.mq.message.Demo01Message;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;



@Component
@RocketMQMessageListener(
        topic = Demo01Message.TOPIC,
        consumerGroup = "koala-dev-event-centre-group"
)
public class Demo01Consumer implements RocketMQListener {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public void onMessage(Demo01Message message) {
        logger.info("[onMessage][线程编号:{} 消息内容：{}]", Thread.currentThread().getId(), message);
    }
}

一般情况下，最好一个消费者分组，仅消费一个 Topic，且一个group，消费一个 tag。因为同一个消费组，设置不同的 tag，会导致消息订阅失败，后启动的消费者，会覆盖先启动的消费者的 tag。 可以参考： 源码分析RocketMQ同一个消费组设置不同tag，消息订阅失败问题

6、TestCase

package com.example.demo.mqTest;


import com.example.demo.mq.producer.Demo01Producer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.concurrent.CountDownLatch;

@RunWith(SpringRunner.class)
@SpringBootTest
public class Demo01ProducerTest {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private Demo01Producer producer;

    @Test
    public void testSyncSend() throws InterruptedException {
        int id = (int) (System.currentTimeMillis() / 1000);
        SendResult result = producer.syncSend(id);
        logger.info("[testSyncSend][发送编号：[{}] 发送结果：[{}]]", id, result);

        // 阻塞等待，保证消费
        new CountDownLatch(1).await();
    }

    @Test
    public void testASyncSend() throws InterruptedException {
        int id = (int) (System.currentTimeMillis() / 1000);
        producer.asyncSend(id, new SendCallback() {

            @Override
            public void onSuccess(SendResult result) {
                logger.info("[testASyncSend][发送编号：[{}] 发送成功，结果为：[{}]]", id, result);
            }

            @Override
            public void onException(Throwable e) {
                logger.info("[testASyncSend][发送编号：[{}] 发送异常]]", id, e);
            }

        });

        // 阻塞等待，保证消费
        new CountDownLatch(1).await();
    }

    @Test
    public void testOnewaySend() throws InterruptedException {
        int id = (int) (System.currentTimeMillis() / 1000);
        producer.onewaySend(id);
        logger.info("[testOnewaySend][发送编号：[{}] 发送完成]", id);

        // 阻塞等待，保证消费
        new CountDownLatch(1).await();
    }

}

 

以上。