Springboot整合RocketMQ

使用之前，请确保已经安装好了rocketmq。

1.引入依赖

<!-- 2.1.1对应rocketmq版本为4.7.1， 2.2.0对应rocketmq版本为：4.8.0 -->
<dependency>
	<groupId>org.apache.rocketmq</groupId>
	<artifactId>rocketmq-spring-boot-starter</artifactId>
	<version>2.1.1</version>
</dependency>

2.加入配置

rocketmq:
  name-server: http://127.0.0.1:9876
  producer:
    group: sale-counter-group

3.封装工具类，如果发生失败，会进行重试，默认两次。

import com.yt.util.RocketMQProducer;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

/**
 * RocketMQ
 * @author tyg
 * @date 2021-03-24 16:28
 */
@Component
public class RocketMQConfig {

    @Resource
    private RocketMQTemplate mqTemplate;

    @PostConstruct
    public void init(){
        RocketMQProducer.mqTemplate = mqTemplate;
    }
}

import lombok.extern.log4j.Log4j2;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.messaging.support.MessageBuilder;

/**
 * RocketMQ发送端
 * @author tyg
 * @date 2021-03-24 14:52
 */
@Log4j2
public class RocketMQProducer {

    public static RocketMQTemplate mqTemplate;

    /**
     * 发送同步消息
     * @param topic 主题
     * @param body  消息
     * @author tyg
     * @date 2021-03-24 14:55
     * @return void
     */
    public static void send(String topic, String body){
        SendResult result = mqTemplate.syncSend(topic, MessageBuilder.withPayload(body).build());
        if (result.getSendStatus() != SendStatus.SEND_OK){
            // 可自行处理失败逻辑
            log.error("\n=======消息发送失败，topic：{}，数据：{}", topic, body);
        }
    }

    /**
     * 发送异步消息 在SendCallback中处理成功失败时的逻辑
     * @param topic     主题
     * @param body      消息
     * @param callback  异步通知消息
     * @author tyg
     * @date 2021-03-24 14:55
     * @return void
     */
    public static void sendAsync(String topic, String body, SendCallback callback){
        mqTemplate.asyncSend(topic, MessageBuilder.withPayload(body).build(), callback);
    }

    /**
     * 发送延时消息
     * 延时消息等级分为18个：1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
     * @param topic      主题
     * @param body       消息
     * @param delayLevel 延迟等级
     * @author tyg
     * @date 2021-03-24 14:55
     * @return void
     */
    public static void sendDelay(String topic, String body, Integer delayLevel){
        SendResult result = mqTemplate.syncSend(topic, MessageBuilder.withPayload(body).build(), delayLevel);
        if (result.getSendStatus() != SendStatus.SEND_OK){
            log.error("\n=======消息发送失败，topic：{}，延迟等级：{}，数据：{}", topic, delayLevel, body);
        }
    }

    /**
     * 发送带tag的消息，格式：topic:tag，示例：order_topic:myTag
     * @param topic 主题
     * @param tag   tag
     * @param body  消息
     * @author tyg
     * @date 2021-03-24 14:55
     * @return void
     */
    public static void sendTag(String topic, String tag, String body){
        SendResult result = mqTemplate.syncSend(String.format("%s:%s", topic, tag), MessageBuilder.withPayload(body).build());
        if (result.getSendStatus() != SendStatus.SEND_OK){
            log.error("\n=======消息发送失败，topic：{}，tag:{}，数据：{}", topic, tag, body);
        }
    }

    /**
     * 单向(Oneway)发送，不可靠，可能存在丢数据的风险，建议在一些日志收集时使用
     * 由于在 oneway 方式发送消息时没有请求应答处理，一旦出现消息发送失败，则会因为没有重试而导致数据丢失。若数据不可丢，建议选用可靠同步或可靠异步发送方式。
     * @param topic 主题
     * @param body  消息
     * @author tyg
     * @date 2021-03-24 14:55
     * @return void
     */
    public static void sendOneWay(String topic, String body){
        mqTemplate.sendOneWay(topic, MessageBuilder.withPayload(body).build());
    }
}

4.发送消息示例

import com.yt.constants.TopicConstant;
import com.yt.util.RocketMQProducer;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

/**
　* 消息测试
　* @author tyg
　* @date 2021-03-24 16:47
　*/
@SpringBootTest
class RocketMQTest {


    /**
     * 发送同步消息
     * @author tyg
     * @date 2021-03-25 11:57
     */
    @Test
    void send() {
        for (int i = 0; i < 100; i++) {
            RocketMQProducer.send("test_topic", i + "、这是我发的同步消息！");
        }
    }

    /**
     * 发送异步消息
     * @author tyg
     * @date 2021-03-25 11:57
     */
    @Test
    void sendAsync() {
        for (int i = 0; i < 100; i++) {
            RocketMQProducer.sendAsync("test_topic", i + "、这是我发的异步消息！", new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    // 处理成功逻辑
                }
                @Override
                public void onException(Throwable throwable) {
                    // 处理异常逻辑
                }
            });
        }
    }

    /**
     * 发送延迟同步消息
     * @author tyg
     * @date 2021-03-25 11:57
     */
    @Test
    void sendDelay() {
        for (int i = 0; i < 100; i++) {
            RocketMQProducer.sendDelay("test_topic", i + "、这是我发的延迟消息！", 2);
        }
    }

}

5.接收消息示例

注：请保证同一个应用下consumerGroup = "my_group"的值唯一。

import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * RocketMQ监听器，消费端
 * @author tyg
 * @date 2021-03-24 15:04
 */
@Slf4j
@Component
@RocketMQMessageListener(topic = "test_topic", consumerGroup = "my_group")
public class DemoRocketMQListener implements RocketMQListener<MessageExt> {

    @Override
    public void onMessage(MessageExt message) {
        byte[] body = message.getBody();
        String msg = new String(body);
        log.info("接收到消息：{}, 重试次数：{}", msg, message.getReconsumeTimes());
    }
}