springboot封装RocketMQ5.1.2代码

海岛日记

已于 2024-03-26 12:24:12 修改

阅读量643

点赞数 27

分类专栏： Java 文章标签： spring boot java 后端 rocketmq

于 2024-03-24 10:42:56 首次发布

本文链接：https://blog.csdn.net/qq_40704513/article/details/136983163

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

springboot客户端依赖

            <dependency>
                <groupId>org.apache.rocketmq</groupId>
                <artifactId>rocketmq-spring-boot-starter</artifactId>
                <version>2.2.3</version>
            </dependency>

服务端部署

版本rocketmq-all-5.1.2-bin-release

生产者接口

import org.apache.rocketmq.client.producer.SendResult;

/**
 * 消息队列生产者
 */
public interface IMQProducer<T> {
    /**
     * 异步发送消息 如果要发送指定TAG,topic参数格式TOPIC:TAG
     *
     * @param topic      消息主题
     * @param msg        消息
     * @param delayLevel 延迟级别
     */
    void asyncSend(String topic, T msg, int delayLevel);

    /**
     * 同步发送消息 如果要发送指定TAG,topic参数格式TOPIC:TAG
     *
     * @param topic      消息主题
     * @param msg        消息
     * @param delayLevel 延迟级别
     */
    SendResult syncSend(String topic, T msg, int delayLevel);

    /**
     * 同步发送消息 如果要发送指定TAG,topic参数格式TOPIC:TAG
     *
     * @param topic      消息主题
     * @param msg        消息
     */
    SendResult syncSend(String topic, T msg);

    /**
     * 定时投递消息 如果要发送指定TAG,topic参数格式TOPIC:TAG
     *
     * @param topic    消息主题
     * @param msg      消息
     * @param pushTime 消息投递时间(13位时间戳)
     */
    SendResult syncSendDeliverTimeMills(String topic, T msg, long pushTime);

    /**
     * 有序发送消息
     * @param topic 消息主题
     * @param msg   消息
     * @param hashKey  分区键
     * @return 发送结果
     */
    SendResult syncSendOrderly(String topic, T msg, String hashKey);

}

生产者实现类

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.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * 消息生产者
 */
@Service
@Slf4j
public class RocketMQProducer<T> implements IMQProducer<T> {
    /**
     * 日志签名
     */
    private final String LOG_SIGN = "生产者消息";

    @Resource
    private RocketMQTemplate rocketMQTemplate;


    /**
     * 异步发送消息 如果要发送指定TAG,topic参数格式TOPIC:TAG
     *
     * @param topic      消息主题
     * @param msg        消息
     * @param delayLevel 延迟级别
     */
    @Override
    public void asyncSend(String topic, T msg, int delayLevel) {
        try {
            Message<T> message = MessageBuilder.withPayload(msg)
                    .build();
            rocketMQTemplate.asyncSend(topic, message, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    log.info("【{}】【{}】发送成功, 状态码【{}】", LOG_SIGN, message, sendResult.getSendStatus());
                }

                @Override
                public void onException(Throwable throwable) {
                    log.warn("【{}】【{}】发送异常", LOG_SIGN, message, throwable);
                }
            }, 10000, delayLevel);
        } catch (Exception e) {
            log.error("【{}】【{}】发送异常", LOG_SIGN, msg, e);
        }
    }

    /**
     * 同步发送消息 如果要发送指定TAG,topic参数格式TOPIC:TAG
     *
     * @param topic      消息主题
     * @param msg        消息
     * @param delayLevel 延迟级别
     */
    @Override
    public SendResult syncSend(String topic, T msg, int delayLevel) {
        try {
            Message<T> message = MessageBuilder.withPayload(msg)
                    .build();
            SendResult sendResult = rocketMQTemplate.syncSend(topic, message, 10000, delayLevel);
            log.info("【{}】【{}】发送结果 状态码【{}】 MsgId【{}】", LOG_SIGN, msg, sendResult.getSendStatus(), sendResult.getMsgId());
            return sendResult;
        } catch (Exception e) {
            log.error("【{}】【{}】发送异常", LOG_SIGN, msg, e);
        }
        return null;
    }

    /**
     * 同步发送消息 如果要发送指定TAG,topic参数格式TOPIC:TAG
     *
     * @param topic 消息主题
     * @param msg   消息
     */
    @Override
    public SendResult syncSend(String topic, T msg) {
        try {
            Message<T> message = MessageBuilder.withPayload(msg)
                    .build();
            SendResult sendResult = rocketMQTemplate.syncSend(topic, message, 10000);
            log.info("【{}】【{}】发送结果 状态码【{}】 MsgId【{}】", LOG_SIGN, msg, sendResult.getSendStatus(), sendResult.getMsgId());
            return sendResult;
        } catch (Exception e) {
            log.error("【{}】【{}】发送异常", LOG_SIGN, msg, e);
        }
        return null;
    }


    /**
     * 定时投递消息 如果要发送指定TAG,topic参数格式TOPIC:TAG
     *
     * @param topic    消息主题
     * @param msg      消息
     * @param pushTime 消息投递时间(13位时间戳)
     */
    @Override
    public SendResult syncSendDeliverTimeMills(String topic, T msg, long pushTime) {
        try {
            Message<T> message = MessageBuilder.withPayload(msg)
                    .build();
            SendResult sendResult = rocketMQTemplate.syncSendDeliverTimeMills(topic, message, pushTime);
            log.info("【{}】【{}】发送定时消息结果 状态码【{}】 MsgId【{}】", LOG_SIGN, msg, sendResult.getSendStatus(), sendResult.getMsgId());
            return sendResult;
        } catch (Exception e) {
            log.error("【{}】【{}】发送定时消息异常", LOG_SIGN, msg, e);
        }
        return null;
    }

    /**
     * 有序发送消息
     *
     * @param topic   消息主题
     * @param msg     消息
     * @param hashKey 分区键
     * @return 发送结果
     */
    @Override
    public SendResult syncSendOrderly(String topic, T msg, String hashKey) {
        try {
            Message<T> message = MessageBuilder.withPayload(msg)
                    .build();
            SendResult sendResult = rocketMQTemplate.syncSendOrderly(topic, message, hashKey);
            log.info("【{}】【{}】发送结果 状态码【{}】 MsgId【{}】", LOG_SIGN, msg, sendResult.getSendStatus(), sendResult.getMsgId());
            return sendResult;
        } catch (Exception e) {
            log.error("【{}】【{}】发送异常", LOG_SIGN, msg, e);
        }
        return null;
    }

}

无序消费者

import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;

@Slf4j
@Profile("dev")
@Service
@RocketMQMessageListener(consumeThreadMax = 8, consumeThreadNumber = 8, topic = RocketMQTopicConstant.CS_TIME_TOPIC, consumerGroup = RocketMQConsumerGroupConstant.CS_TIME_CONSUMER_GROUP)
public class TestTimeConsumer implements RocketMQListener<String> {


    @Override
    public void onMessage(String msg) {
        try {
            log.info("接收到测试延迟消息：【{}】", msg);
        } catch (Exception e) {
            log.error("测试消息异常", e);
        }

    }

}

有序消费者

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

import java.nio.charset.StandardCharsets;
import java.util.Date;

/**
 * 有序消费
 */
@Slf4j
@Profile("dev")
@Service
@RocketMQMessageListener(consumeThreadMax = 1, consumeThreadNumber = 1, consumeMode = ConsumeMode.ORDERLY, topic = RocketMQTopicConstant.CS_ORDERLY_TOPIC, consumerGroup = RocketMQConsumerGroupConstant.CS_ORDERLY_CONSUMER_GROUP)
public class TestOrderlyConsumer implements RocketMQListener<MessageExt> {

    @Override
    public void onMessage(MessageExt messageExt) {
        int queueId = messageExt.getQueueId();
        String messageBody = new String(messageExt.getBody(), StandardCharsets.UTF_8);
        log.info(new Date().toLocaleString() + " 接收到消息【{}】 线程【{}】 队列【{}】", messageBody, Thread.currentThread().getName(), queueId);
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

注意事项

根据不同的Tag消费
1.生产者 topic + ":" + tag(tag不过滤的话只需要topic)
2.消费者 selectorExpression = "tag1||tag2"
3.消费同一个topic的不同Tag,消费者组名需要不一致
4.集群(多个jar包)消费同一个topic,消费者组名要一致
5.集群消费同一个topic+同一个tag,消费者组名要一致
6.集群消费同一个topic+不同的tag,消费者组名不一致
7.不消费原因点击这里查看
RocketMQ5.0定时发送消息注意事项
1 所有相关机器时间、时区保持同步,否则定时投递消息会立即消费
2 时间是13位时间戳