消息队列--RabbitMQ 高可用集群部署

系列导读：本篇将深入讲解 RabbitMQ 高可用集群的部署与最佳实践。

文章目录

- [一、RabbitMQ 架构](#一、RabbitMQ 架构)
- - [1.1 核心概念](#1.1 核心概念)
  - [1.2 核心组件](#1.2 核心组件)
  - [1.3 Exchange 类型](#1.3 Exchange 类型)
- 二、集群部署
- - [2.1 集群架构](#2.1 集群架构)
  - [2.2 Docker Compose 部署](#2.2 Docker Compose 部署)
  - [2.3 集群配置](#2.3 集群配置)
- 三、镜像队列
- - [3.1 镜像策略](#3.1 镜像策略)
  - [3.2 镜像模式](#3.2 镜像模式)
- 四、生产者最佳实践
- - [4.1 配置](#4.1 配置)
  - [4.2 发送消息](#4.2 发送消息)
- 五、消费者最佳实践
- - [5.1 消费配置](#5.1 消费配置)
  - [5.2 消费消息](#5.2 消费消息)
- 总结

一、RabbitMQ 架构

1.1 核心概念

复制代码

┌─────────────────────────────────────────────────────────────┐
│                    RabbitMQ 架构                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Producer ──► Exchange ──► Queue ──► Consumer               │
│                   │                                         │
│                   ▼                                         │
│              Binding                                        │
│           (路由规则)                                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

1.2 核心组件

组件	说明
Exchange	交换机，接收消息并路由
Queue	队列，存储消息
Binding	绑定，Exchange 与 Queue 的关联
Virtual Host	虚拟主机，隔离环境

1.3 Exchange 类型

类型	说明
Direct	精确匹配路由键
Topic	通配符匹配
Fanout	广播到所有队列
Headers	根据消息头匹配

二、集群部署

2.1 集群架构

复制代码

┌─────────────────────────────────────────────────────────────┐
│                  RabbitMQ 集群                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────┐    ┌─────────┐    ┌─────────┐                  │
│  │ Node 1  │◄──►│ Node 2  │◄──►│ Node 3  │                  │
│  │ (Disk)  │    │ (RAM)   │    │ (RAM)   │                  │
│  └─────────┘    └─────────┘    └─────────┘                  │
│                                                             │
│  磁盘节点：持久化集群状态                                     │
│  内存节点：高性能，但不持久化                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

2.2 Docker Compose 部署

yaml 复制代码

version: '3'
services:
  rabbitmq1:
    image: rabbitmq:3-management
    hostname: rabbitmq1
    ports:
      - "5672:5672"
      - "15672:15672"
    environment:
      RABBITMQ_ERLANG_COOKIE: "secret_cookie"
      RABBITMQ_NODENAME: "rabbit@rabbitmq1"
    volumes:
      - ./data1:/var/lib/rabbitmq

  rabbitmq2:
    image: rabbitmq:3-management
    hostname: rabbitmq2
    ports:
      - "5673:5672"
      - "15673:15672"
    environment:
      RABBITMQ_ERLANG_COOKIE: "secret_cookie"
      RABBITMQ_NODENAME: "rabbit@rabbitmq2"
    volumes:
      - ./data2:/var/lib/rabbitmq

2.3 集群配置

bash 复制代码

# 在 Node 2 上加入集群
docker exec rabbitmq2 rabbitmqctl stop_app
docker exec rabbitmq2 rabbitmqctl join_cluster rabbit@rabbitmq1
docker exec rabbitmq2 rabbitmqctl start_app

# 查看集群状态
docker exec rabbitmq1 rabbitmqctl cluster_status

三、镜像队列

3.1 镜像策略

bash 复制代码

# 设置镜像策略（所有队列镜像到所有节点）
rabbitmqctl set_policy ha-all "^" '{"ha-mode":"all","ha-sync-mode":"automatic"}'

# 设置镜像策略（指定队列）
rabbitmqctl set_policy ha-order "^order\." '{"ha-mode":"all"}'

3.2 镜像模式

模式	说明
all	镜像到所有节点
exactly	镜像到指定数量节点
nodes	镜像到指定节点

四、生产者最佳实践

4.1 配置

java 复制代码

@Configuration
public class RabbitMQConfig {
    
    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory factory = new CachingConnectionFactory();
        factory.setAddresses("192.168.1.100:5672,192.168.1.101:5672");
        factory.setUsername("admin");
        factory.setPassword("admin");
        factory.setVirtualHost("/order");
        return factory;
    }
    
    @Bean
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        template.setMandatory(true);  // 消息路由失败回调
        template.setConfirmCallback((correlationData, ack, cause) -> {
            if (ack) {
                log.info("消息发送成功");
            } else {
                log.error("消息发送失败: {}", cause);
            }
        });
        return template;
    }
    
    // 订单交换机
    @Bean
    public DirectExchange orderExchange() {
        return new DirectExchange("order.exchange", true, false);
    }
    
    // 订单队列
    @Bean
    public Queue orderQueue() {
        return QueueBuilder.durable("order.queue")
            .withArgument("x-message-ttl", 86400000)  // TTL
            .withArgument("x-dead-letter-exchange", "dlx.exchange")  // 死信
            .build();
    }
    
    // 绑定
    @Bean
    public Binding orderBinding() {
        return BindingBuilder.bind(orderQueue())
            .to(orderExchange())
            .with("order.created");
    }
}

4.2 发送消息

java 复制代码

@Service
public class OrderProducer {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void sendOrder(Order order) {
        // 发送消息
        rabbitTemplate.convertAndSend(
            "order.exchange",
            "order.created",
            JSON.toJSONString(order),
            message -> {
                message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                return message;
            }
        );
    }
}

五、消费者最佳实践

5.1 消费配置

java 复制代码

@Configuration
public class RabbitConsumerConfig {
    
    @Bean
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory() {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory());
        factory.setConcurrentConsumers(3);  // 并发消费者数
        factory.setMaxConcurrentConsumers(10);
        factory.setPrefetchCount(10);  // 预取数量
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);  // 手动确认
        return factory;
    }
}

5.2 消费消息

java 复制代码

@Component
public class OrderConsumer {
    
    @RabbitListener(queues = "order.queue")
    public void consume(Message message, Channel channel) throws IOException {
        try {
            Order order = JSON.parseObject(
                new String(message.getBody()), 
                Order.class
            );
            
            // 业务处理
            processOrder(order);
            
            // 手动确认
            channel.basicAck(
                message.getMessageProperties().getDeliveryTag(), 
                false
            );
            
        } catch (Exception e) {
            log.error("消费失败", e);
            // 拒绝并重新入队
            channel.basicNack(
                message.getMessageProperties().getDeliveryTag(),
                false,
                false
            );
        }
    }
}

总结

✅ RabbitMQ 架构 ：Exchange、Queue、Binding

✅ 集群部署 ：磁盘节点、内存节点

✅ 镜像队列 ：高可用配置

✅ 生产者实践 ：确认机制、持久化

✅ 消费者实践：手动确认、并发消费

下篇预告 ：[RocketMQ 架构设计与优化](#RocketMQ 架构设计与优化)

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