RocketMQ（补档）

快乐吃手手 : )

已于 2025-03-17 23:01:49 修改

阅读量1.1k

点赞数 26

文章标签： rocketmq

于 2025-03-16 00:30:56 首次发布

本文链接：https://blog.youkuaiyun.com/klcss/article/details/146287623

版权

RocketMQ 是一个分布式消息中间件，具有高吞吐量、低延迟、可靠性高等特点。它广泛应用于大规模分布式系统中，用于解耦服务之间的直接调用、异步处理、流量削峰等场景。

关键组件

Name Server: 提供轻量级的服务发现和路由管理功能。每个 Name Server 实例都可以独立运行，相互之间没有通信。

Broker: 负责消息存储、接收来自 Producer 的消息以及处理 Consumer 的订阅请求。分为 Master 和 Slave，Master 节点负责写操作，Slave 节点用于备份数据和支持读扩展。

Producer: 发送消息到 Broker。Producer 在发送消息前会从 Name Server 获取路由信息，找到合适的 Broker 进行消息发送。

Consumer: 从 Broker 订阅并消费消息。Consumer 也会先从 Name Server 获取路由信息，然后连接到对应的 Broker 进行消息消费。

Topic、GroupName 和 Tag

在 Apache RocketMQ 中，Topic、GroupName 和 Tag 是用于管理和组织消息传递的关键概念，各自承担着不同的角色：

Topic

定义：Topic 是消息的一级分类方法。每个消息都必须指定一个 Topic，类似于消息的主题或者类别。

作用：生产者将消息发送到特定的 Topic，消费者则订阅自己感兴趣的 Topic 来接收消息。这样可以实现消息的发布/订阅模式，使得消息的生产和消费解耦。

GroupName

生产者 Group 是用于标识一组生产者实例的名称。同一个生产者 Group 中的生产者实例共享相同的配置和状态。如果不指定生产者组，大多数版本的RocketMQ 会使用默认的组名（如 DEFAULT_PRODUCER）。

（1）标识生产者身份

生产者 Group 是 RocketMQ 中唯一标识一组生产者实例的名称。

通过生产者 Group，RocketMQ 可以管理和监控生产者的状态。

（2）事务消息支持

如果使用 RocketMQ 的事务消息功能，生产者 Group 是必须的。

RocketMQ 会根据生产者 Group 来回查事务状态（即检查本地事务是否执行成功）。

（3）消息重试

生产者 Group 与消息的重试机制相关。如果消息发送失败，RocketMQ 会根据生产者 Group 的配置进行重试。

（4）监控和管理

在 RocketMQ 控制台或监控系统中，生产者 Group 用于区分不同的生产者实例，方便运维和监控。

消费者 Group 是用于标识一组消费者实例的名称。同一个消费者 Group 中的消费者实例共享相同的订阅配置和消费进度。

（1）标识消费者身份

消费者 Group 是 RocketMQ 中唯一标识一组消费者实例的名称。

通过消费者 Group，RocketMQ 可以管理和监控消费者的状态。

（2）消费模式

消费者 Group 决定了消息的消费模式：

集群模式（CLUSTERING）：同一个消费者 Group 中的多个消费者实例共同消费消息，每条消息只会被一个消费者实例消费。

广播模式（BROADCASTING）：同一个消费者 Group 中的每个消费者实例都会消费所有的消息。

（3）消费进度管理

RocketMQ 会为每个消费者 Group 维护消费进度（Offset），确保消息不会被重复消费或丢失。

（4）监控和管理

在 RocketMQ 控制台或监控系统中，消费者 Group 用于区分不同的消费者实例，方便运维和监控。

Tag

定义：Tag 是附加在消息上的二级分类标签，允许对 Topic 下的消息做进一步细分。

作用：消费者可以根据需要订阅 Topic 下带有特定 Tag 的消息。这提供了一种更细粒度的消息过滤机制，使得消费者能够更加精确地控制它们想要接收的消息类型。

Rocket MQ初始化

1.安装并启动RocketMQ

本地部署 RocketMQ | RocketMQ

2.引入依赖

在每个微服务的pom.xml加入依赖

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

MQ生产者初始化

1.配置文件

server:
  port: 8080
 
rocketmq:
  name-server: 127.0.0.1:9876
  producer:
    group: demo_producer_group_V3
    max-message-size: 4194304 # 4MB
    send-message-timeout: 2000
    retry-times-when-send-failed: 1
    retry-times-when-send-async-failed: 1

2.配置类(RocketMQ 生产者的 Spring Bean)

@Getter
@Setter
@ToString
@Configuration
@ConfigurationProperties(prefix = "rocketmq.producer")
public class MQProducerConfigure {
    private String group; // 生产者的group
    private String nameServer; // 与配置文件中的 name-server 匹配
    private int maxMessageSize = 4194304; // 默认值 4MB
    private int sendMessageTimeout = 3000; // 默认值 3秒
    private int retryTimesWhenSendFailed = 2; // 默认值 2次
    private int retryTimesWhenSendAsyncFailed = 2; // 默认值 2次

    @Bean
    public DefaultMQProducer defaultProducer() throws MQClientException {
        DefaultMQProducer producer = new DefaultMQProducer(group);
        producer.setNamesrvAddr(nameServer);
        producer.setMaxMessageSize(maxMessageSize);
        producer.setSendMsgTimeout(sendMessageTimeout);
        producer.setRetryTimesWhenSendFailed(retryTimesWhenSendFailed);
        producer.setRetryTimesWhenSendAsyncFailed(retryTimesWhenSendAsyncFailed);
        producer.start();
        return producer;
    }
}

如果你的项目需要需要不同的生产者组来处理不同的业务逻辑，可以配置多个 DefaultMQProducer Bean，用：@Bean("producer1")，每个 Bean 使用不同的 group。

//发送配置类追加Bean
@Bean("producer2")
public DefaultMQProducer producer2() throws MQClientException {
    DefaultMQProducer producer = new DefaultMQProducer("ProducerGroup2")；
    //......
    producer.start();
    return producer;
}


//MQ发送类使用@Qualifier区分Bean
@Autowired
@Qualifier("producer2")
private DefaultMQProducer producer2;
//发送逻辑

MQ消费者初始化

1.配置文件

server:
  port: 8081

rocketmq:
  consumer:
    group-name: your_consumer_group
    namesrv-addr: 127.0.0.1:9876
    topic: TestTopic
    tag: TestTag
    consume-message-batch-max-size: 10

2.配置类

配置类目前的设计是针对 topics 的配置格式相同的 topics 进行订阅的，如果你需要支持多个不同的 topic和group，可以采用在配置类里面为每个编写单独的配置Bean。

被@Bean注解标注的消费者方法会在Spring容器初始化期间被执行，而其中关键是.start()方法启动了消费者进程，使得接下来的流程将进入消息消费的循环中。

RocketMQ 支持两种消费模式：

集群模式（CLUSTERING）默认模式。

        同一个消费者组（Consumer Group）中的多个消费者共同消费同一个 Topic 的消息。

        每条消息只会被消费者组中的一个消费者消费。

        适合负载均衡场景。

广播模式（BROADCASTING）

        同一个消费者组中的每个消费者都会消费所有的消息。

        每条消息会被消费者组中的每个消费者消费一次。

        适合消息需要广播到所有消费者的场景。



设置：

        consumer.setMessageModel(MessageModel.CLUSTERING); // 集群模式
        consumer.setMessageModel(MessageModel.BROADCASTING); // 广播模式

@Getter
@Setter
@ToString
@Configuration
@ConfigurationProperties(prefix = "rocketmq.consumer")
public class MQConsumerOneConfigure {
    private String groupName;
    private String namesrvAddr;
    private String topic;
    private String tag;
    private Integer consumeMessageBatchMaxSize = 1; // 默认每次消费一条消息

    @Autowired
    private MessageListenerConcurrently consumeMsgListenerProcessor;

    @Bean
    public DefaultMQPushConsumer defaultConsumer() throws MQClientException {
        // 创建消费者实例
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(groupName);
        consumer.setNamesrvAddr(namesrvAddr);
        consumer.setConsumeThreadMin(5);
        consumer.setConsumeThreadMax(20);
        consumer.setConsumeMessageBatchMaxSize(consumeMessageBatchMaxSize);
        consumer.registerMessageListener(consumeMsgListenerProcessor);
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
        // 订阅主题并启动消费者
        try {
            //void subscribe(String topic, String tag);
            consumer.subscribe(topic,tag);
            consumer.start();
        } catch (MQClientException e) {
            throw new RuntimeException("Failed to start RocketMQ consumer", e);
        }
        return consumer;
    }
}

3.监听器方法

@Component
public class MQConsumeMsgListenerProcessor implements MessageListenerConcurrently {
    @Override
    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgList, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
        if (CollectionUtils.isEmpty(msgList)) {
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
        MessageExt messageExt = msgList.get(0);
        try {
            String topic = messageExt.getTopic();
            String tags = messageExt.getTags();
            String body = new String(messageExt.getBody(), "utf-8");
        } catch (Exception e) {
            // TODO 异常处理逻辑
        }
        // TODO 处理业务逻辑
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
    }
}

MQ发送

1.同步消息

    /*通过 @ConfigurationProperties 注解，
    可以将配置文件中的属性绑定到 MQProducerConfigure 类的字段上，
    然后通过 @Bean 方法创建并配置 DefaultMQProducer 实例。
     */
    @Autowired
    private DefaultMQProducer defaultMQProducer;


    @GetMapping("/send")
    public SendResult send(String msg) throws InterruptedException, RemotingException, MQClientException, MQBrokerException {
        if (StringUtils.isEmpty(msg)) {
            return null;
        }
        LOGGER.info("发送MQ消息内容：" + msg);
        Message sendMsg = new Message("TestTopic", "TestTag", msg.getBytes());
        // 默认3秒超时
        SendResult sendResult = defaultMQProducer.send(sendMsg);
        LOGGER.info("消息发送响应：" + sendResult.toString());
        return sendResult;
    }

2.异步消息

        defaultMQProducer.send(sendMsg, new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                System.out.printf("消息发送成功: %s%n", sendResult);
            }

            @Override
            public void onException(Throwable e) {
                System.err.println("消息发送失败: " + e.getMessage());
            }
        });

3.单向消息

        defaultMQProducer.sendOneway(sendMsg);

4.批量消息

        List<Message> messages = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Message sendMsg = new Message("TestTopic", "TestTag",msg.getBytes(RemotingHelper.DEFAULT_CHARSET));
            messages.add(sendMsg);
        }
        // 批量发送消息
        defaultMQProducer.send(messages);

RocketMQTempate简化操作

简化配置
通过 Spring Boot 的自动配置，无需手动创建 DefaultMQProducer 和 DefaultMQPushConsumer。

易用性
提供了更简洁的 API，支持同步、异步、单向、延迟、批量等多种消息发送方式。

与 Spring 生态集成
支持 Spring 的依赖注入、事务管理、AOP 等特性。

自动序列化和反序列化
支持将 Java 对象自动序列化为消息体，以及将消息体反序列化为 Java 对象。

1.依赖注入

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.2.2</version> <!-- 使用最新版本 -->
</dependency>

2.配置文件

（1）生产者服务配置

# application.yml 示例
rocketmq:
    name-server: 127.0.0.1:9876 # 替换为你的NameServer地址
    producer:
        group: your-producer-group
        send-message-timeout: 3000 # 发送超时时间，默认3000ms
        retry-times-when-send-failed: 2 # 发送失败时的重试次数

（2）消费者服务配置

# application.yml 示例
rocketmq:
    name-server: 127.0.0.1:9876 # 替换为你的NameServer地址
    consumer:
        consume-thread-min: 5 # 最小消费线程数
        consume-thread-max: 10 # 最大消费线程数
        namesrvAddr: 127.0.0.1:9876 # 如果没有全局设置，则可以在这里单独设置NameServer地址
        # broadcast: true # 默认false, 表示集群消费模式；如果设为true则表示广播消费模式

3.代码示例

（1）生产者

同步消息

@Service
public class RocketMQService {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    public void sendMessage(String topic, User userMessage) {
        rocketMQTemplate.convertAndSend(topic, userMessage);
    }
}

异步消息

rocketMQTemplate.asyncSend("your-topic", userMessage, new SendCallback() {
    @Override
    public void onSuccess(SendResult sendResult) {
        // 成功回调处理
    }

    @Override
    public void onException(Throwable throwable) {
        // 异常回调处理
    }
});

单向消息

rocketMQTemplate.sendOneWay("your-topic", "your-message");

（2）消费者

@RocketMQMessageListener可以追加selecrorExpression实现对tag的过滤

@Service
@RocketMQMessageListener(topic = "your-topic", consumerGroup = "your-consumer-group")
public class YourMessageListener implements RocketMQListener<User> {

    @Override
    public void onMessage(User userMessage) {
        // 处理接收到的消息
    }
}

4.生产者多个Group

在 RocketMQ 中，RocketMQTemplate 的 group 是通过配置文件（如 application.yml）指定的，默认情况下，一个 RocketMQTemplate 实例只需绑定一个生产者 Group。如果你需要支持多个生产者 Group，可以通过以下方式实现：

（1）定义多个 RocketMQTemplate Bean
每个 RocketMQTemplate 实例绑定一个生产者 Group。

rocketmq:
  name-server: localhost:9876
  producer:
    group1:
      group: ProducerGroup1 # 生产者 Group1
      send-message-timeout: 3000
      retry-times-when-send-failed: 2
    group2:
      group: ProducerGroup2 # 生产者 Group2
      send-message-timeout: 5000
      retry-times-when-send-failed: 3

@Configuration
@ConfigurationProperties(prefix = "rocketmq.producer")
public class RocketMQConfig {

    private Map<String, ProducerConfig> group1 = new HashMap<>();
    private Map<String, ProducerConfig> group2 = new HashMap<>();

    public Map<String, ProducerConfig> getGroup1() {
        return group1;
    }

    public void setGroup1(Map<String, ProducerConfig> group1) {
        this.group1 = group1;
    }

    public Map<String, ProducerConfig> getGroup2() {
        return group2;
    }

    public void setGroup2(Map<String, ProducerConfig> group2) {
        this.group2 = group2;
    }

    @Bean("rocketMQTemplate1")
    public RocketMQTemplate rocketMQTemplate1() {
        RocketMQTemplate template = new RocketMQTemplate();
        template.setProducerGroup(group1.get("group")); // 动态注入 Group1
        template.setNameServer("localhost:9876");
        return template;
    }

    @Bean("rocketMQTemplate2")
    public RocketMQTemplate rocketMQTemplate2() {
        RocketMQTemplate template = new RocketMQTemplate();
        template.setProducerGroup(group2.get("group")); // 动态注入 Group2
        template.setNameServer("localhost:9876");
        return template;
    }

    public static class ProducerConfig {
        private String group;
        private int sendMessageTimeout;
        private int retryTimesWhenSendFailed;

        // Getters and Setters
        public String getGroup() {
            return group;
        }

        public void setGroup(String group) {
            this.group = group;
        }

        public int getSendMessageTimeout() {
            return sendMessageTimeout;
        }

        public void setSendMessageTimeout(int sendMessageTimeout) {
            this.sendMessageTimeout = sendMessageTimeout;
        }

        public int getRetryTimesWhenSendFailed() {
            return retryTimesWhenSendFailed;
        }

        public void setRetryTimesWhenSendFailed(int retryTimesWhenSendFailed) {
            this.retryTimesWhenSendFailed = retryTimesWhenSendFailed;
        }
    }
}

（2）在代码中通过 @Qualifier 注入不同的 RocketMQTemplate&动态切换生产者 Group
发送消息时，选择对应的 RocketMQTemplate。

@Service
public class MessageService {

    @Autowired
    @Qualifier("rocketMQTemplate1")
    private RocketMQTemplate rocketMQTemplate1;

    @Autowired
    @Qualifier("rocketMQTemplate2")
    private RocketMQTemplate rocketMQTemplate2;

    /**
     * 使用 ProducerGroup1 发送消息
     */
    public void sendToGroup1(String topic, String tag, String message) {
        rocketMQTemplate1.syncSend(topic + ":" + tag, message);
    }

    /**
     * 使用 ProducerGroup2 发送消息
     */
    public void sendToGroup2(String topic, String tag, String message) {
        rocketMQTemplate2.syncSend(topic + ":" + tag, message);
    }
}