微服务项目整合rocketMq

参考文章：https://blog.csdn.net/weixin_47615289/article/details/134772707

先安装rocketmq服务，安装教程：https://blog.csdn.net/yyongsheng/article/details/158694383

添加依赖（生产者和消费者他们的rocketmq依赖一样），请注意配置适合自己项目的版本

XML 复制代码

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

生产者的

bash 复制代码

# Tomcat
server:
  port: 10301

# Spring
spring: 
  application:
    # 应用名称
    name: mq-producer
  profiles:
    # 环境配置
    active: dev
  cloud:
    nacos:
      discovery:
        # 服务注册地址
        server-addr: 127.0.0.1:9849
      config:
        # 配置中心地址
        server-addr: 127.0.0.1:9849
        # 配置文件格式
        file-extension: yml
        # 共享配置
        shared-configs:
          - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
rocketmq:
  name-server: 192.168.94.130:9876
  producer:
    # 发送同一类消息的设置为同一个group，保证唯一
    group: springboot_producer_group
    # 发送消息超时时间，默认3000
    sendMessageTimeout: 10000
    # 发送消息失败重试次数，默认2
    retryTimesWhenSendFailed: 2
    # 异步消息重试此处，默认2
    retryTimesWhenSendAsyncFailed: 2
    # 消息最大长度，默认1024 * 1024 * 4(默认4M)
    maxMessageSize: 4096
    # 压缩消息阈值，默认4k(1024 * 4)
    compressMessageBodyThreshold: 4096
    # 是否在内部发送失败时重试另一个broker，默认false
    retryNextServer: false
#    stream:
#      bindings:
#        ## 新版本固定格式  函数名-{out/in}-{index}
#        demoChannel-out-0:
#          destination: stream-test-topic
#      rocketmq:
#        binder:
#          name-server: 192.168.94.130:9876

消费者的

bash 复制代码

# Tomcat
server:
  port: 10302

# Spring
spring: 
  application:
    # 应用名称
    name: mq-consumer
  profiles:
    # 环境配置
    active: dev
  cloud:
    nacos:
      discovery:
        # 服务注册地址
        server-addr: 127.0.0.1:9849
      config:
        # 配置中心地址
        server-addr: 127.0.0.1:9849
        # 配置文件格式
        file-extension: yml
        # 共享配置
        shared-configs:
          - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
rocketmq:
  consumer:
    group: springboot_consumer_group
    # 一次拉取消息最大值，注意是拉取消息的最大值而非消费最大值
    pull-batch-size: 10
  name-server: 192.168.94.130:9876

逻辑代码：

生产消息的代码

java 复制代码

package com.ruoyi.system.controller;

import com.ruoyi.common.core.utils.DateUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.MessageConst;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@Slf4j
@RestController
@RequestMapping("/mqpro")
public class SendMessageController {

    @Autowired
    private RocketMQTemplate rocketmqTemplate;

    @GetMapping("/test")
    public  String test() {
        Message<String> msg = MessageBuilder.withPayload("Hello,RocketMQ").build();

        rocketmqTemplate.send("eatfan", msg);
        return "haha";
    }

    @GetMapping("/test1")
    public  String test1() {
        // Topic: ORDER_TOPIC, Tag: CREATE
        rocketmqTemplate.syncSend("ORDER_TOPIC:CREATE", "Order created: 1001");
        log.info("test1发送时间：{}",DateUtils.getTime());
        return "haha";
    }

    @GetMapping("/test2")
    public  String test2() {
        // Topic: PAYMENT_TOPIC, Tag: SUCCESS
        rocketmqTemplate.asyncSend("ORDER_TOPIC:SUCCESS", "Payment success: 1001", new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                log.info("Message sent: {}", sendResult);
            }

            @Override
            public void onException(Throwable e) {
                log.error("Send failed", e);
            }
        });
        log.info("test2发送时间：{}",DateUtils.getTime());
        return "haha";
    }

    @GetMapping("/test3")
    public  String test3() {
        Map<String, Object> order = new HashMap<>();
        order.put("orderId", 1001L);
        order.put("userId", "user123");
        order.put("createTime", DateUtils.getTime());
        // Topic: ORDER_TOPIC, Tag: CREATE
        // 使用 convertAndSend 自动转 JSON
        rocketmqTemplate.convertAndSend("ORDER_TOPIC:CANCEL", order);
        log.info("test3发送时间：{}",DateUtils.getTime());
        return "haha";
    }

    @GetMapping("/test5")
    public  String test5() {
        Map<String, Object> order = new HashMap<>();
        order.put("orderId", 1001L);
        order.put("userId", "user123");
        order.put("createTime", DateUtils.getTime());

        Message<Map<String, Object>> message = MessageBuilder
                .withPayload(order)
                .setHeader(MessageConst.PROPERTY_KEYS, "order_1001") // 用于追踪
                .build();

        // 延迟等级（RocketMQ 5.x 支持任意延迟，但传统模式仅支持 18 级）
        rocketmqTemplate.syncSend("ORDER_TOPIC:TIMEOUT", message, 2000, 3); // 延迟等级 3（约 10s）
        log.info("test5发送时间：{}",DateUtils.getTime());
        return "haha";
    }
}

消费消息的代码

java 复制代码

package com.ruoyi.system.listener;

import com.ruoyi.common.core.utils.DateUtils;
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;

import java.nio.charset.StandardCharsets;

@Slf4j
@Component
@RocketMQMessageListener(
        topic = "ORDER_TOPIC",
        consumerGroup = "order-multi-tag-group",
        selectorExpression = "CREATE || SUCCESS || CANCEL || TIMEOUT"
)
public class OrderCancelConsumer implements RocketMQListener<MessageExt> {

    @Override
    public void onMessage(MessageExt messageExt) {
        String topic = messageExt.getTopic();
        String tag = messageExt.getTags(); // 获取 Tag
        String body = new String(messageExt.getBody(), StandardCharsets.UTF_8);

        log.info("Received message - Topic: {}, Tag: {}, Body: {}", topic, tag, body);

        // 根据 Tag 分发处理
        switch (tag) {
            case "CREATE":
                handleCreate(body);
                break;
            case "SUCCESS":
                handleSuccess(body);
                break;
            case "CANCEL":
                handleCancel(body);
                break;
            case "TIMEOUT":
                handleTimeout(body);
                break;
            default:
                log.warn("Unknown tag: {}", tag);
        }
    }

    private void handleCreate(String msg) {
        log.info("时间：{},处理订单创建消息：{}", DateUtils.getTime(), msg);
    }
    private void handleSuccess(String msg) {
        log.info("时间：{},处理订单成功消息：{}", DateUtils.getTime(), msg);
    }
    private void handleCancel(String msg) {
        log.info("时间：{},处理订单取消消息：{}", DateUtils.getTime(), msg);
    }
    private void handleTimeout(String msg) {
        log.info("时间：{},处理订单超时消息：{}", DateUtils.getTime(), msg);
    }

}

以上是一个简单实现，可自行定制化