springboot Rabbit MQ topic 配置文件绑定队列和交换机的实现方法

目录

• Spring Boot 中如何将队列和交换机绑定（含实例讲解）
• 一、RabbitMQ中的关键概念
• 二、需求描述
• 三、配置代码实现
• 1. 引入必要的依赖
• 2. 配置类中绑定队列和交换机
• 3. 代码详细解读
• 四、如何发送消息
• 五、消息接收方如何处理
• 六、几种常见的绑定示例
• 1. 使用 Direct Exchange 进行精确匹配
• 2. 使用 Fanout Exchange 广播消息

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

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

一、RabbitMQ中的关键概念

• Exchange（交换机）：交换机负责接收消息，并根据路由规则分发给绑定的队列。常见的交换机类型有 Direct、Fanout、Topic 等。
• Queue（队列）：队列是消息实际存储的地方，消费者从队列中获取消息。
• Routing Key（路由键）：生产者发送消息时，会携带一个路由键，RabbitMQ 根据这个路由键决定把消息发送到哪个队列。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() {
        returnwww.devze.com new Queue(SECKILL_QUEUE);
    }
    // 3. 绑定队列到交换机，并指定路由键
    @Bean
    public Binding bindingSeckillQueue(Queue seckillQueue, TopicExchange seckillExchange) {
        return BindingBuilder.bind(seckillQueue).to(seckillExchangjavascripte).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.spr编程客栈ingframework.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 BindingBandroiduilder.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);
}

到此这篇关于springboot Rabbit MQ topic 配置文件绑定队列和交换机的文章就介绍到这了,更多相关springboot Rabbit MQ topic 配置文件绑定队列内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！