SpringBoot整合RocketMQ极速实战教程

一、前期准备

1.1 环境依赖

• SpringBoot 2.x / 3.x（本文代码全兼容）
• RocketMQ 服务端（4.x/5.x/7.x 均可）
• ma ven/gradle 项目

1.2 核心依赖引入（Ma ven）

Apache 官方提供的 SpringBoot Starter 已经帮我们处理好了版本适配，直接引入即可，不用再操心版本冲突的问题。

    org.apache.rocketmq
    rocketmq-spring-boot-starter
    2.2.3

二、全局配置文件（application.yml）

配置服务地址、生产组、消费组，后续所有功能统一复用该配置。

# RocketMQ 配置
rocketmq:
  # NameServer 集群地址
  name-server: 127.0.0.1:9876
  # 生产者配置
  producer:
    # 生产者组名
    group: demo-producer-group
    # 消息发送超时时间
    send-message-timeout: 3000
    # 最大重试次数
    retry-times-when-send-failed: 2
  # 消费者默认配置
  consumer:
    group: demo-consumer-group

三、SpringBoot 集成 RocketMQ 核心原理

在动手写各种消息之前，先花点时间把底层的集成原理搞明白。自动装配怎么玩、核心组件有哪些、通信链路长什么样——把这些吃透了，以后遇到组件失效、连接失败、消息发送异常的问题，排查起来才不慌。

3.1 自动装配原理（核心）

RocketMQ 官方提供的 rocketmq-spring-boot-starter 完全遵循 SpringBoot 的自动装配机制，开发者根本不需要手动去 new 生产者和消费者实例，框架启动时自动就把这些 Bean 托管了。

• 配置加载：项目一启动，框架就会自动读取 application.yml 里 rocketmq 相关的全局配置，包括 NameServer 地址、生产/消费组、超时时间、甚至 AK/SK 权限信息。
• Bean自动注册：Starter 内置的自动配置类会初始化 RocketMQTemplate 模板类，并交给 Spring 容器管理。开发者直接用 @Autowired 注入就能用。
• 消费者动态注册：凡是加了 @RocketMQMessageListener 注解的消费者类，Spring 在启动时会自动扫描到，然后根据注解里的参数创建相应的消费者实例、订阅对应的 Topic、绑定消费组和消费模式。
• 资源自动销毁：项目关闭时，Spring 容器会优雅地销毁所有生产者和消费者实例，避免连接残留和消息堆积。

3.2 核心集成组件说明

• RocketMQTemplate：这是整合后的核心操作模板，封装了原生 API 的所有发送能力——同步、异步、单向、有序、批量、事务消息，全都在这里。生产者只用跟它打交道，不用再碰底层那些复杂的原生 API。
• @RocketMQMessageListener：消费者的核心注解，承载了所有消费配置。Topic、消费组、集群/广播模式、消息过滤表达式、并发消费数……全都可以在注解里配好，实现零配置快速订阅。
• RocketMQLocalTransactionListener：事务消息专用的监听接口，框架会自动注册这个监听器，开发者只需要实现本地事务的执行和事务状态回查两个方法。

3.3 完整通信执行流程

• 启动初始化：SpringBoot 项目启动，自动装配加载 RocketMQ 配置，初始化 RocketMQTemplate 和消费者实例。
• 路由拉取：生产者和消费者自动连接 NameServer，定时拉取 Topic 对应的 Broker 路由信息，缓存在本地。
• 消息投递：业务代码调用 RocketMQTemplate 的方法发送消息，框架会基于负载均衡策略选一个最优的 Broker 节点投递。
• 消息存储：Broker 收到消息后持久化到磁盘，然后向生产者返回投递结果。
• 消息消费：消费者主动拉取对应 Topic 的消息，执行业务逻辑，框架自动维护消费位点和失败重试机制。

3.4 SpringBoot集成优势

• 极简开发：告别原生代码里写一堆创建实例、绑定配置的繁琐操作，注解加配置文件就能快速搞定。
• 容器托管：所有 MQ 组件都交给 Spring 容器统一管理，生命周期可控，启停优雅。
• 能力全覆盖：普通、延迟、顺序、批量、事务消息，所有高级特性都被封装好了。
• 高容错性：框架内置了发送重试、异常捕获、位点维护、自动重连等机制，开发时容错成本大大降低。

四、基础消息实战：普通生产与消费

三、基础消息实战：普通生产与消费

3.1 普通消息实现原理

原理说明：普通消息是 RocketMQ 最基础的消息模型，采用“生产者主动推送、消费者主动拉取”的模式。生产者通过 NameServer 拿到 Broker 路由信息，基于负载均衡选一个 Broker 投递消息，Broker 收到后持久化到磁盘；消费者定时去拉取消息，业务处理成功就自动提交消费位点，处理失败就触发重试，保证至少一次投递。支持同步、异步、单向三种发送模式，适合不同吞吐量和可靠性需求的场景。

3.2 普通消息生产者

三种发送模式覆盖绝大多数业务场景，直接看代码：

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.stereotype.Component;
@Component
public class MqProducer {
    @Autowired
    private RocketMQTemplate rocketMqTemplate;
    // 定义全局Topic
    private static final String TOPIC = "demo-normal-topic";
    /**
     * 同步发送消息（可靠，适合核心业务）
     */
    public void sendSyncMsg(String msg) {
        SendResult sendResult = rocketMqTemplate.syncSend(TOPIC, msg);
        System.out.println("同步发送结果：" + sendResult.getSendStatus());
    }
    /**
     * 异步发送消息（高吞吐，适合非核心业务）
     */
    public void sendAsyncMsg(String msg) {
        rocketMqTemplate.asyncSend(TOPIC, msg, new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                System.out.println("异步发送成功");
            }
            @Override
            public void onException(Throwable e) {
                System.err.println("异步发送失败：" + e.getMessage());
            }
        });
    }
    /**
     * 单向发送（极致高性能，无需响应）
     */
    public void sendOneWayMsg(String msg) {
        rocketMqTemplate.sendOneWay(TOPIC, msg);
    }
}

3.3 普通消息消费者

默认使用集群消费模式，消费者之间自动负载均衡，处理异常会自动重试。

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;
@Component
@RocketMQMessageListener(
        topic = "demo-normal-topic",
        consumerGroup = "demo-consumer-group"
)
public class NormalMsgConsumer implements RocketMQListener {
    @Override
    public void onMessage(String message) {
        // 执行业务逻辑
        System.out.println("收到普通消息：" + message);
        // 异常自动进入重试队列，无需手动处理
        // int a = 1 / 0;
    }
}

五、广播消息实战

实现原理：广播消息的核心是“消费组级别的全量投递”。集群消费是组内分摊消息，而广播消费会让 Broker 把同一条消息推送给当前消费组内所有在线消费者实例，每个实例独立消费、独立维护位点。为了避免集群异常时刷屏，广播消费关闭了重试机制，消息消费失败不会进入重试队列。它特别适合全服务缓存刷新、全局配置更新这类需要全员同步的场景。

import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;
@Component
@RocketMQMessageListener(
        topic = "demo-broadcast-topic",
        consumerGroup = "demo-broadcast-group",
        consumeMode = ConsumeMode.BROADCASTING // 开启广播消费
)
public class BroadcastConsumer implements RocketMQListener {
    @Override
    public void onMessage(String message) {
        System.out.println("广播消费消息：" + message);
    }
}

注意：广播消费不支持重试，适合全局缓存刷新、配置更新场景。

六、顺序消息实战（分区有序）

实现原理：RocketMQ 的顺序消息只支持分区有序（局部有序），不支持全局有序。思路是这样的：Topic 会被拆成多个消息队列，生产者通过自定义业务 Key 哈希取模，把同一业务维度（比如同一订单、同一用户）的消息固定投递到同一个 MessageQueue；消费者这边，单个队列采用单线程消费，严格保证队列内消息先进先出，从而实现业务时序一致。不同队列之间的消息可以并行消费，有序性和吞吐量就都兼顾了。

5.1 有序消息生产者原理与代码

public void sendOrderMsg(String bizKey, String msg) {
    // bizKey相同 → 固定发送同一队列 → 保证顺序
    rocketMqTemplate.syncSendOrderly("demo-order-topic", msg, bizKey);
}

5.2 有序消息消费者原理与代码

import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;
@Component
@RocketMQMessageListener(
        topic = "demo-order-topic",
        consumerGroup = "demo-order-group",
        messageModel = MessageModel.CLUSTERING
)
public class OrderMsgConsumer implements RocketMQListener {
    @Override
    public void onMessage(String message) {
        System.out.println("顺序消费：" + message);
    }
}

七、延迟消息实战

实现原理：延迟消息的核心是“系统队列中转延时机制”。生产者发送消息时指定一个延迟等级，Broker 收到后不会立即存入目标 Topic 队列，而是转入内置的 SCHEDULE_TOPIC_XXXX 延迟队列。Broker 后台有定时线程一直扫描这个延迟队列，倒计时结束后，再把消息重新路由到用户指定的普通 Topic 队列，消费者这时才能正常拉取。需要注意的是，RocketMQ 不支持自定义任意延迟时间，只能使用官方预设的 18 个固定延迟等级，这么做是为了保证服务性能稳定。

/**
 * 发送延迟消息
 * 延迟等级：1~18级 → 1s、5s、10s、30s、1m、2m、3m、4m、5m、6m、7m、8m、9m、10m、20m、30m、1h、2h
 */
public void sendDelayMsg(String msg) {
    // 3级延迟 = 10秒后消费
    rocketMqTemplate.syncSend("demo-delay-topic", msg, 3);
}

八、批量消息实战

实现原理：批量消息的核心是“合并网络 IO、减少请求次数”。把多条同 Topic、同配置的消息打包成一个列表，只用一次网络请求就全部提交到 Broker，Broker 一次性持久化存储。这样做能大幅降低频繁建立网络连接、握手带来的性能开销，在高吞吐场景下效果尤其明显。批量消息是一个整体事务——要么全部成功存储，要么全部失败，不支持部分成功。

import org.apache.rocketmq.common.message.Message;
import ja va.util.ArrayList;
import ja va.util.List;
public void sendBatchMsg() {
    List messageList = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        Message message = new Message("demo-batch-topic", ("批量消息" + i).getBytes());
        messageList.add(message);
    }
    // 批量发送
    rocketMqTemplate.syncSend(messageList);
}

注意：单批次总大小不要超过 4MB，整批要么全成功要么全失败。

九、消息过滤实战（Tag过滤）

实现原理：消息过滤采用“服务端预过滤机制”，避免无效消息拉取浪费网络资源。Tag 过滤是最轻量级的方案：生产者在发送消息时绑定一个业务标签，Broker 存储时把 Tag 关联上；消费者在订阅时指定 Tag 表达式，Broker 在服务端直接匹配过滤，只把符合条件的消息推送给消费者，几乎不带来额外性能损耗。如果业务更复杂，也可以用 SQL 过滤，基于消息的自定义属性做多条件筛选。

8.1 Tag过滤实现原理与代码

// 发送订单消息，tag = ORDER
public void sendTagMsg() {
    rocketMqTemplate.syncSend("demo-tag-topic:ORDER", "订单创建消息");
}

8.2 消费者订阅指定Tag

@RocketMQMessageListener(
        topic = "demo-tag-topic",
        consumerGroup = "demo-tag-group",
        selectorExpression = "ORDER||PAY" // 只消费ORDER、PAY标签消息
)
@Component
public class TagFilterConsumer implements RocketMQListener{
    @Override
    public void onMessage(String s) {
        System.out.println("过滤消费消息：" + s);
    }
}

十、事务消息实战（核心重点）

实现原理：事务消息基于“两阶段提交+超时回查机制”，专门解决本地数据库事务与消息发送之间的分布式一致性问题。第一阶段：发送一条半消息（预提交），消息持久化了但对消费者不可见；第二阶段：执行本地事务，根据事务结果提交或回滚这条消息。如果生产者在执行过程中宕机了或者网络超时了，Broker 会提供定时回查兜底，主动去校验本地事务的状态，彻底杜绝消息悬挂和数据不一致。

它能让本地事务和消息发送做到最终一致性。

9.1 事务消息完整代码实现

import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
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.stereotype.Component;
@Component
@RocketMQTransactionListener
public class TransactionMsgListener implements RocketMQLocalTransactionListener {
    @Autowired
    private RocketMQTemplate rocketMqTemplate;
    private static final String TRANS_TOPIC = "demo-trans-topic";
    // 发送事务消息入口
    public void sendTransMsg(String content) {
        Message message = MessageBuilder.withPayload(content).build();
        rocketMqTemplate.sendMessageInTransaction(TRANS_TOPIC, message, content);
    }
    // 执行本地事务
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object arg) {
        try {
            // 模拟本地数据库事务
            System.out.println("执行本地事务：" + arg);
            // 成功则提交消息
            return RocketMQLocalTransactionState.COMMIT;
        } catch (Exception e) {
            // 异常回滚消息
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }
    // 事务回查
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message message) {
        // 查询数据库事务状态，此处模拟成功
        return RocketMQLocalTransactionState.COMMIT;
    }
}