rocketmq集成springboot测试案例

近段时间，项目中需要引入消息队列解决高并发问题。比对了几款mq产品，最终选择了rocketmq。rocketmq经受过阿里双十一考验的解决高并发问题的可靠消息中间件，详细介绍和安装这里就不
赘述了，请前往官网查看：rocketmq官网
项目使用的springboot，这里记录一下springboot整合rocketmq。

一、在pom文件中引入相关包

 <!-- springboot整合rocketmq -->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.6.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-common</artifactId>
            <version>4.8.0</version>
        </dependency>

二、在配置文件中加上rocketmq配置

# rockermq配置
rocketmq:
    name-server: 192.168.1.166:9876 # 访问地址
    # 生产者配置
    producer:
        isOnOff: on
        # 发送同一类消息的设置为同一个group，保证唯一
        group: mr-rocketmq-group
        groupName: mr-rocketmq-group
        # 服务地址
        namesrvAddr: ***:9876（地址用公网ip，否则会访问不到）
        # 消息最大长度 默认1024*4(4M)
        maxMessageSize: 4096
        # 发送消息超时时间,默认3000
        sendMsgTimeout: 3000
        # 发送消息失败重试次数，默认2
        retryTimesWhenSendFailed: 2

三、启动rocketmq，此时就能连上rocketmq了，然后根据业务需求在代码里加上消息生产者、消费者、borker、nameserver、监听等

这里给出一个工具类：

import lombok.extern.slf4j.Slf4j;
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.messaging.Message;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
/**
 * @Description: rocketmq工具类$
 * @Author: 
 * @Date: 2021-10-26$ $
 * @Param: $
 * @Return: $
 */
@Slf4j
@Service
public class RocketMqUtils {

    /**
     * rocketmq模板注入
     */
    @Autowired
    RocketMQTemplate rocketMQTemplate;

    @PostConstruct
    public void init() {
        log.info("---RocketMq助手初始化---");
    }

    /**
     * 发送异步消息
     *
     * @param topic   消息Topic
     * @param message 消息实体
     */
    public void asyncSend(Enum topic, Message<?> message) {
        asyncSend(topic.name(), message, getDefaultSendCallBack());
    }


    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     */
    public void asyncSend(Enum topic, Message<?> message, SendCallback sendCallback) {
        asyncSend(topic.name(), message, sendCallback);
    }

    /**
     * 发送异步消息
     *
     * @param topic   消息Topic
     * @param message 消息实体
     */
    public void asyncSend(String topic, Message<?> message) {
        rocketMQTemplate.asyncSend(topic, message, getDefaultSendCallBack());
    }

    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     */
    public void asyncSend(String topic, Message<?> message, SendCallback sendCallback) {
        rocketMQTemplate.asyncSend(topic, message, sendCallback);
    }

    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     * @param timeout      超时时间
     */
    public void asyncSend(String topic, Message<?> message, SendCallback sendCallback, long timeout) {
        rocketMQTemplate.asyncSend(topic, message, sendCallback, timeout);
    }

    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     * @param timeout      超时时间
     * @param delayLevel   延迟消息的级别
     */
    public void asyncSend(String topic, Message<?> message, SendCallback sendCallback, long timeout, int delayLevel) {
        rocketMQTemplate.asyncSend(topic, message, sendCallback, timeout, delayLevel);
    }

    /**
     * 发送顺序消息
     *
     * @param message
     * @param topic
     * @param hashKey
     */
    public void syncSendOrderly(Enum topic, Message<?> message, String hashKey) {
        syncSendOrderly(topic.name(), message, hashKey);
    }


    /**
     * 发送顺序消息
     *
     * @param message
     * @param topic
     * @param hashKey
     */
    public void syncSendOrderly(String topic, Message<?> message, String hashKey) {
        log.info("发送顺序消息，topic:" + topic + ",hashKey:" + hashKey);
        rocketMQTemplate.syncSendOrderly(topic, message, hashKey);
    }

    /**
     * 发送顺序消息
     *
     * @param message
     * @param topic
     * @param hashKey
     * @param timeout
     */
    public void syncSendOrderly(String topic, Message<?> message, String hashKey, long timeout) {
        log.info("发送顺序消息，topic:" + topic + ",hashKey:" + hashKey + ",timeout:" + timeout);
        rocketMQTemplate.syncSendOrderly(topic, message, hashKey, timeout);
    }

    /**
     * 默认CallBack函数
     *
     * @return
     */
    private SendCallback getDefaultSendCallBack() {
        return new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                log.info("---发送MQ成功---");
            }

            @Override
            public void onException(Throwable throwable) {
                log.error("---发送MQ失败---"+throwable.getMessage(), throwable.getMessage());
            }
        };
    }


    @PreDestroy
    public void destroy() {
        log.info("---RocketMq助手注销---");
    }
}

测试类：

import com.ruoyi.RuoYiApplication;
import com.ruoyi.common.utils.RocketMqUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @Description: rockermq测试类$
 * @Author: jzhang$
 * @Date: $ $
 * @Param: $
 * @Return: $
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = RuoYiApplication.class)
public class RockerMqTest {

    /**
     * rocketmq模板注入
     */
    @Autowired
    RocketMqUtils rocketMqUtils;

    @Test
    public void testProducter() {
        String test = "这是一条测试信息！";
        rocketMqUtils.asyncSend("PERSON_ADD", MessageBuilder.withPayload(test).build());
    }
}