springboot Rabbit MQ topic 配置文件绑定队列和交换机

Spring Boot 中如何将队列和交换机绑定（含实例讲解）

在使用 Spring Boot 开发高并发的秒杀系统或者其他场景时，RabbitMQ 是常用的消息队列中间件之一。本文将详细讲解如何在配置类中通过代码将队列与交换机绑定，并指定路由键来实现消息路由。

一、RabbitMQ中的关键概念

1. Exchange（交换机）：交换机负责接收消息，并根据路由规则分发给绑定的队列。常见的交换机类型有 Direct、Fanout、Topic 等。
2. Queue（队列）：队列是消息实际存储的地方，消费者从队列中获取消息。
3. Routing Key（路由键）：生产者发送消息时，会携带一个路由键，RabbitMQ 根据这个路由键决定把消息发送到哪个队列。
4. Binding（绑定）：绑定是将队列和交换机关联在一起，消息通过路由键决定是否路由到某个队列。

二、需求描述

假设我们在秒杀系统中有一个秒杀订单的队列和对应的交换机，分别为 seckill.queue 和 seckill.exchange。为了将订单处理的消息路由到正确的队列，我们需要将它们通过一个 seckill.routingkey 绑定在一起。

三、配置代码实现

1. 引入必要的依赖

首先，在 pom.xml 中引入 RabbitMQ 的依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2. 配置类中绑定队列和交换机

在配置类中，我们需要定义交换机、队列，以及将两者通过路由键绑定。以下是具体实现：

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    // 定义常量表示交换机、队列和路由键
    public static final String SECKILL_EXCHANGE = "seckill.exchange";
    public static final String SECKILL_QUEUE = "seckill.queue";
    public static final String SECKILL_ROUTINGKEY = "seckill.routingkey";

    // 1. 定义秒杀交换机
    @Bean
    public TopicExchange seckillExchange() {
        return new TopicExchange(SECKILL_EXCHANGE);
    }

    // 2. 定义秒杀队列
    @Bean
    public Queue seckillQueue() {
        return new Queue(SECKILL_QUEUE);
    }

    // 3. 绑定队列到交换机，并指定路由键
    @Bean
    public Binding bindingSeckillQueue(Queue seckillQueue, TopicExchange seckillExchange) {
        return BindingBuilder.bind(seckillQueue).to(seckillExchange).with(SECKILL_ROUTINGKEY);
    }
}

3. 代码详细解读

• seckillExchange()：这是定义的一个 TopicExchange 类型的交换机。在 RabbitMQ 中，TopicExchange 允许根据路由键的模式匹配将消息路由到不同的队列中。
• seckillQueue()：定义了一个 Queue 队列，用来存储秒杀订单的消息。此处的 Queue 是持久化的，当 RabbitMQ 重启时，队列中的消息不会丢失。
• bindingSeckillQueue()：通过 BindingBuilder 将队列和交换机绑定在一起，并使用 with(SECKILL_ROUTINGKEY) 指定了路由键。这样，当消息生产者发送带有 seckill.routingkey 的消息时，消息会被路由到 seckill.queue 队列中。

四、如何发送消息

绑定完成后，你可以使用 RabbitTemplate 将消息发送到交换机，并指定路由键：

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class SeckillMessageSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    // 发送秒杀订单消息
    public void sendSeckillOrderMessage(String message) {
        rabbitTemplate.convertAndSend(RabbitMQConfig.SECKILL_EXCHANGE, RabbitMQConfig.SECKILL_ROUTINGKEY, message);
        System.out.println("秒杀消息已发送：" + message);
    }
}

在上面的代码中，RabbitTemplate 提供了 convertAndSend 方法，将消息发送到 seckill.exchange 交换机，并且指定 seckill.routingkey 作为路由键，消息最终会被路由到绑定的 seckill.queue 队列。

五、消息接收方如何处理

消费者（监听队列消息的服务）可以使用 @RabbitListener 来监听队列中的消息。例如：

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class SeckillMessageReceiver {

    // 监听秒杀队列
    @RabbitListener(queues = RabbitMQConfig.SECKILL_QUEUE)
    public void receiveMessage(String message) {
        System.out.println("接收到秒杀消息：" + message);
        // 处理消息的逻辑
    }
}

六、几种常见的绑定示例

1. 使用 Direct Exchange 进行精确匹配

如果你想要根据路由键的精确匹配来路由消息，可以使用 DirectExchange，而不是 TopicExchange。

@Bean
public DirectExchange directExchange() {
    return new DirectExchange("direct.exchange");
}

@Bean
public Binding bindingDirectQueue(Queue seckillQueue, DirectExchange directExchange) {
    return BindingBuilder.bind(seckillQueue).to(directExchange).with("direct.routingkey");
}

这种方式下，只有当路由键完全匹配 direct.routingkey 时，消息才会被路由到对应的队列。

2. 使用 Fanout Exchange 广播消息

如果你想将消息广播到多个队列，可以使用 FanoutExchange，它会忽略路由键，将消息发送到所有绑定的队列。

@Bean
public FanoutExchange fanoutExchange() {
    return new FanoutExchange("fanout.exchange");
}

@Bean
public Binding bindingFanoutQueue(Queue seckillQueue, FanoutExchange fanoutExchange) {
    return BindingBuilder.bind(seckillQueue).to(fanoutExchange);
}