RocketMQ2.3.5+SpringBoot 3.2.11+ java17安装-集成-测试案例

RocketMQ 集成测试项目

可以直接下载源码

项目地址

这是一个基于 Spring Boot 3.2.11 和 RocketMQ 的测试项目，演示如何将 RocketMQ 消息队列集成到 Spring Boot 应用中。

技术栈

技术	版本	说明
Java	17	编程语言
Spring Boot	3.2.11	应用框架
RocketMQ	5.1.4	消息队列
Lombok	1.18.36	代码简化工具
Maven	3.9.1	构建工具

依赖版本

核心依赖

• Spring Boot: 3.2.11

  • spring-boot-starter-web: 3.2.11
  • spring-boot-starter-test: 3.2.11

• RocketMQ: 5.1.4

  • rocketmq-spring-boot-starter: 5.1.4

• 工具依赖

  • Lombok: 1.18.36

构建工具

• Maven Compiler Plugin: 3.11.0
• Spring Boot Maven Plugin: 3.2.11

环境准备

1. 安装 JDK17

yum install -y java-17-openjdk-devel
java -version

2. 安装 Maven 3.8.8

wget https://archive.apache.org/dist/maven/maven-3/3.8.8/binaries/apache-maven-3.8.8-bin.tar.gz
tar -zxvf apache-maven-3.8.8-bin.tar.gz
mv apache-maven-3.8.8 /usr/local/maven

# 配置环境变量
echo 'export M2_HOME=/usr/local/maven' >> /etc/profile
echo 'export PATH=$PATH:$M2_HOME/bin' >> /etc/profile
source /etc/profile

mvn -v

RocketMQ 安装部署

1. 下载并解压 RocketMQ 5.1.4

wget https://archive.apache.org/dist/rocketmq/5.1.4/rocketmq-all-5.1.4-bin-release.zip
unzip rocketmq-all-5.1.4-bin-release.zip
cd rocketmq-all-5.1.4-bin-release

2. 调整内存配置（适用于低配服务器）

sed -i 's/-Xms1g -Xmx2g/-Xms256m -Xmx256m/g' bin/runserver.sh
sed -i 's/-Xms1g -Xmx2g/-Xms256m -Xmx256m/g' bin/runbroker.sh

3. 启动 NameServer

nohup sh bin/mqnamesrv &

4. 启动 Broker

nohup sh mqbroker -n localhost:9876 -c ../conf/broker.conf &

5. 检查运行状态

ps -ef | grep broker
ps -ef | grep namesrv
jps  # 应能看到 NamesrvStartup 和 BrokerStartup

可视化控制台安装

1. 下载源码并修改配置

cd ~
git clone https://github.com/apache/rocketmq-dashboard.git
cd rocketmq-dashboard

编辑配置文件

vim src/main/resources/application.yml

修改配置：

server:
  port: 8088  # 自定义端口

保存退出：ESC → :wq

2. Maven 打包

mvn clean package -Dmaven.test.skip=true
cd target
nohup java -jar rocketmq-dashboard-1.0.0.jar &

项目集成

1. 添加依赖

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

2. 配置 RocketMQ

rocketmq:
  name-server: 192.168.35.83:9876
  producer:
    group: producer-consumer-group

3. 注意事项

• Topic 创建：2.3.5 版本不支持自动创建 Topic，必须通过控制台手动创建
• 手动创建优势 ：
  • 稳定性：不受消费者/生产者启动顺序影响
  • 可控性：可自定义队列数和权限
  • 安全性：避免自动创建带来的混乱
    
    

事务消息实现

1. 事务消息生产者

@Service
public class TransactionalMessageProducer {

    @Autowired
    private RocketMQTemplate rocketMqTemplate;

    public void sendTransactionMessage(String topic, String message) {
        TransactionSendResult sendResult = rocketMqTemplate.sendMessageInTransaction(
            topic, 
            MessageBuilder.withPayload(message).build(), 
            null
        );
        System.out.println("Transaction message sent: " + sendResult.getLocalTransactionState());
    }
}

2. 事务监听器实现

通过实现 RocketMQLocalTransactionListener 接口，定义事务的提交或回滚逻辑。

package top.hshkyl.sy.rocketmq;

import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

/**
 * @author peiwanlong
 * @Description
 * @since 2026/4/2 10:52
 **/
@Component
@RocketMQTransactionListener
public class TransactionListenerImpl implements RocketMQLocalTransactionListener {
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
        // 执行本地事务逻辑，根据业务情况返回事务的提交或回滚状态
        try {
            // 模拟本地事务处理逻辑
            System.out.println("Executing local transaction...");
            boolean success = performLocalTransaction();
            if (success) {
                return RocketMQLocalTransactionState.COMMIT;
            } else {
                return RocketMQLocalTransactionState.ROLLBACK;
            }
        } catch (Exception e) {
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }

    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        // 事务回查逻辑，确认本地事务的最终状态
        System.out.println("Checking local transaction...");

        // 根据本地事务的处理结果返回 COMMIT_MESSAGE 或 ROLLBACK_MESSAGE
        System.out.println("local transaction check success");
        return RocketMQLocalTransactionState.COMMIT;
    }

    private boolean performLocalTransaction() {
        // TODO 模拟本地事务处理文件上传OSS
        try {
            System.out.println("Upload files to OSS...");
            Thread.sleep(3000);
            System.out.println("File upload to OSS completed");
            return true;
        } catch (InterruptedException e) {
            System.out.println("Failed to upload file to OSS");
            return false;
        }
    }
}

3. 消费者示例

创建一个消费者，订阅并消费事务消息。 RocketMQListener 是一个接口类型，用于定义一个 RocketMQ

消息监听器，它指定接收的消息类型为 String。在 RocketMQ 中，消费者可以通过实现 RocketMQListener

接口来自动处理接收到的消息。

package top.hshkyl.sy.rocketmq;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Service;

/**
 * @author peiwanlong
 * @Description
 * @since 2026/4/2 10:53
 **/
@Service
@RocketMQMessageListener(topic = "transaction-topic", consumerGroup = "transaction-consumer-group")
public class TransactionalMessageConsumer implements RocketMQListener<String> {
    @Override
    public void onMessage(String message) {
        // 处理接收到的消息
        System.out.printf("Received message: %s%n", message);
    }

}

4. 发送事务消息

在服务中调用事务消息生产者：

package top.hshkyl.sy.rocketmq;

import jakarta.annotation.Resource;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author peiwanlong
 * @Description
 * @since 2026/4/2 10:55
 **/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/message/test")
public class MessageController {

    @Resource
    private TransactionalMessageProducer transactionalMessageProducer;

    @GetMapping("/sendTransactionMessage")
    public ResponseEntity<String> sendTransactionMessage(@RequestParam String message) {
        transactionalMessageProducer.sendTransactionMessage("transaction-topic", message);
        return ResponseEntity.ok("Transaction message sent: " + message);
    }


    /**
     * 测试方法
     */
    @GetMapping("/test")
    public ResponseEntity<String> test() {
        return ResponseEntity.ok("Test message");
    }
}

5. 简单测试