消息队列--RocketMQ 架构设计与优化

系列导读：本篇将深入讲解 RocketMQ 架构设计与生产环境最佳实践。

文章目录

- [一、RocketMQ 架构](#一、RocketMQ 架构)
- - [1.1 核心组件](#1.1 核心组件)
  - [1.2 组件说明](#1.2 组件说明)
  - [1.3 与 Kafka 对比](#1.3 与 Kafka 对比)
- 二、集群部署
- - [2.1 集群架构](#2.1 集群架构)
  - [2.2 Docker 部署](#2.2 Docker 部署)
  - [2.3 Broker 配置](#2.3 Broker 配置)
- 三、生产者最佳实践
- - [3.1 配置](#3.1 配置)
  - [3.2 发送消息](#3.2 发送消息)
- 四、消费者最佳实践
- - [4.1 消费配置](#4.1 消费配置)
  - [4.2 消费消息](#4.2 消费消息)
- 五、事务消息
- - [5.1 事务消息流程](#5.1 事务消息流程)
  - [5.2 实现代码](#5.2 实现代码)
- 总结

一、RocketMQ 架构

1.1 核心组件

复制代码

┌─────────────────────────────────────────────────────────────┐
│                    RocketMQ 架构                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Producer ──► NameServer ──► Broker ──► Consumer            │
│                   │              │                          │
│                   │              ▼                          │
│                   │         CommitLog                       │
│                   │         ConsumeQueue                    │
│                   │                                         │
│                   └─── 路由注册 ───► Topic 路由信息          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

1.2 组件说明

组件	说明
NameServer	路由注册中心，轻量级
Broker	消息服务器，存储消息
Producer	消息生产者
Consumer	消息消费者

1.3 与 Kafka 对比

特性	RocketMQ	Kafka
吞吐量	十万级	百万级
延迟	ms级	ms级
事务消息	支持	不支持
延迟消息	支持	不支持
消息过滤	支持	不支持

二、集群部署

2.1 集群架构

复制代码

┌─────────────────────────────────────────────────────────────┐
│                  RocketMQ 集群                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │ NameServer1 │  │ NameServer2 │  │ NameServer3 │          │
│  └─────────────┘  └─────────────┘  └─────────────┘          │
│         │                │                │                 │
│         └────────────────┼────────────────┘                 │
│                          │                                  │
│         ┌────────────────┼────────────────┐                 │
│         ▼                ▼                ▼                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │ Broker-Master│ │ Broker-Master│ │ Broker-Master│         │
│  │   (主)      │  │   (主)      │  │   (主)      │          │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘          │
│         │                │                │                 │
│         ▼                ▼                ▼                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │Broker-Slave │  │Broker-Slave │  │Broker-Slave │          │
│  └─────────────┘  └─────────────┘  └─────────────┘          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

2.2 Docker 部署

yaml 复制代码

version: '3'
services:
  namesrv:
    image: apache/rocketmq:5.1.0
    container_name: rmqnamesrv
    ports:
      - "9876:9876"
    command: sh mqnamesrv

  broker:
    image: apache/rocketmq:5.1.0
    container_name: rmqbroker
    ports:
      - "10911:10911"
      - "10909:10909"
    environment:
      NAMESRV_ADDR: "namesrv:9876"
    command: sh mqbroker -c /opt/rocketmq/conf/broker.conf
    volumes:
      - ./broker.conf:/opt/rocketmq/conf/broker.conf
      - ./logs:/opt/rocketmq/logs
      - ./store:/opt/rocketmq/store

2.3 Broker 配置

properties 复制代码

# broker.conf
brokerClusterName = DefaultCluster
brokerName = broker-a
brokerId = 0
namesrvAddr = 192.168.1.100:9876;192.168.1.101:9876
defaultTopicQueueNums = 4
autoCreateTopicEnable = true
autoCreateSubscriptionGroup = true
listenPort = 10911
deleteWhen = 04
fileReservedTime = 48
mapedFileSizeCommitLog = 1073741824
mapedFileSizeConsumeQueue = 300000
diskMaxUsedSpaceRatio = 88
storePathRootDir = /opt/rocketmq/store
maxMessageSize = 65536

三、生产者最佳实践

3.1 配置

java 复制代码

@Configuration
public class RocketMQConfig {
    
    @Bean
    public DefaultMQProducer producer() {
        DefaultMQProducer producer = new DefaultMQProducer("order-producer-group");
        producer.setNamesrvAddr("192.168.1.100:9876;192.168.1.101:9876");
        producer.setRetryTimesWhenSendFailed(3);
        producer.setSendMsgTimeout(3000);
        producer.setMaxMessageSize(4 * 1024 * 1024);  // 4MB
        return producer;
    }
}

3.2 发送消息

java 复制代码

@Service
public class OrderProducer {
    
    @Autowired
    private DefaultMQProducer producer;
    
    // 同步发送
    public SendResult sendSync(Order order) throws Exception {
        Message message = new Message(
            "order-topic",
            "order-created",
            JSON.toJSONString(order).getBytes()
        );
        return producer.send(message);
    }
    
    // 异步发送
    public void sendAsync(Order order) {
        Message message = new Message(
            "order-topic",
            "order-created",
            JSON.toJSONString(order).getBytes()
        );
        producer.send(message, new SendCallback() {
            @Override
            public void onSuccess(SendResult result) {
                log.info("发送成功: {}", result);
            }
            
            @Override
            public void onException(Throwable e) {
                log.error("发送失败", e);
            }
        });
    }
    
    // 延迟消息
    public void sendDelay(Order order, int delayLevel) {
        Message message = new Message(
            "order-topic",
            JSON.toJSONString(order).getBytes()
        );
        message.setDelayTimeLevel(delayLevel);  // 1-18
        producer.send(message);
    }
}

四、消费者最佳实践

4.1 消费配置

java 复制代码

@Configuration
public class RocketMQConsumerConfig {
    
    @Bean
    public DefaultMQPushConsumer consumer() {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order-consumer-group");
        consumer.setNamesrvAddr("192.168.1.100:9876;192.168.1.101:9876");
        consumer.setConsumeThreadMin(10);
        consumer.setConsumeThreadMax(20);
        consumer.setConsumeMessageBatchMaxSize(10);
        return consumer;
    }
}

4.2 消费消息

java 复制代码

@Component
public class OrderConsumer {
    
    @PostConstruct
    public void start() throws MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order-consumer-group");
        consumer.setNamesrvAddr("192.168.1.100:9876");
        consumer.subscribe("order-topic", "order-created");
        
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(
                List<MessageExt> msgs, 
                ConsumeConcurrentlyContext context
            ) {
                for (MessageExt msg : msgs) {
                    try {
                        Order order = JSON.parseObject(
                            new String(msg.getBody()), 
                            Order.class
                        );
                        processOrder(order);
                    } catch (Exception e) {
                        log.error("消费失败", e);
                        return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                    }
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        
        consumer.start();
    }
}

五、事务消息

5.1 事务消息流程

复制代码

1. 发送半消息（Half Message）
2. 执行本地事务
3. 提交或回滚消息
4. 事务回查机制

5.2 实现代码

java 复制代码

@Service
public class OrderTransactionProducer {
    
    @Autowired
    private TransactionMQProducer producer;
    
    public void sendTransactionMessage(Order order) {
        Message message = new Message(
            "order-topic",
            JSON.toJSONString(order).getBytes()
        );
        
        producer.sendMessageInTransaction(message, order);
    }
}

// 事务监听器
@Component
public class OrderTransactionListener implements TransactionListener {
    
    @Autowired
    private OrderService orderService;
    
    @Override
    public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        try {
            Order order = (Order) arg;
            orderService.createOrder(order);
            return LocalTransactionState.COMMIT_MESSAGE;
        } catch (Exception e) {
            return LocalTransactionState.ROLLBACK_MESSAGE;
        }
    }
    
    @Override
    public LocalTransactionState checkLocalTransaction(MessageExt msg) {
        // 事务回查
        Order order = JSON.parseObject(new String(msg.getBody()), Order.class);
        if (orderService.exists(order.getId())) {
            return LocalTransactionState.COMMIT_MESSAGE;
        }
        return LocalTransactionState.ROLLBACK_MESSAGE;
    }
}

总结

✅ RocketMQ 架构 ：NameServer、Broker

✅ 集群部署 ：主从架构、配置优化

✅ 生产者实践 ：同步、异步、延迟消息

✅ 消费者实践 ：并发消费、批量消费

✅ 事务消息：半消息、事务回查

下篇预告 ：消息队列选型对比指南

作者：刘~浪地球
系列：消息队列（三）
更新时间：2026-04-13