spring boot rabbitmq direct模式 ,消费多个QueueName ，如何根据自定义配置来消费

在Spring Boot中使用RabbitMQ的直连（direct）模式消费多个队列，并根据自定义的配置来消费，你可以按照以下步骤操作：

• 首先，在你的Spring Boot项目中添加RabbitMQ依赖。可以使用Maven来管理依赖关系，添加以下依赖到你的pom.xml文件中：

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

•  创建一个配置类，用于配置RabbitMQ的连接和队列消费。例如，创建一个RabbitMQConfig类，添加以下代码：

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableRabbit
public class RabbitMQConfig {

    @Autowired
    private ConnectionFactory connectionFactory;

    // 自定义配置类
    @Autowired
    private RabbitMQCustomConfig rabbitMQCustomConfig;

    // 配置队列1
    @Bean
    public Queue queue1() {
        return new Queue(rabbitMQCustomConfig.getQueueName1());
    }

    // 配置队列2
    @Bean
    public Queue queue2() {
        return new Queue(rabbitMQCustomConfig.getQueueName2());
    }

    // 配置exchange和binding
    @Bean
    public DirectExchange exchange() {
        return new DirectExchange(rabbitMQCustomConfig.getExchangeName());
    }

    @Bean
    public Binding binding1(DirectExchange exchange, Queue queue1) {
        return BindingBuilder.bind(queue1).to(exchange).with(rabbitMQCustomConfig.getRoutingKey1());
    }

    @Bean
    public Binding binding2(DirectExchange exchange, Queue queue2) {
        return BindingBuilder.bind(queue2).to(exchange).with(rabbitMQCustomConfig.getRoutingKey2());
    }

    // 配置消息监听器并指定消费方法
    @Bean
    public SimpleMessageListenerContainer container1(ConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter1) {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.setQueueNames(rabbitMQCustomConfig.getQueueName1());
        container.setMessageListener(listenerAdapter1);
        return container;
    }

    @Bean
    public SimpleMessageListenerContainer container2(ConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter2) {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.setQueueNames(rabbitMQCustomConfig.getQueueName2());
        container.setMessageListener(listenerAdapter2);
        return container;
    }

    // 消息监听适配器
    @Bean
    public MessageListenerAdapter listenerAdapter1(RabbitMQConsumer rabbitMQConsumer) {
        return new MessageListenerAdapter(rabbitMQConsumer, "consumeMessage1");
    }

    @Bean
    public MessageListenerAdapter listenerAdapter2(RabbitMQConsumer rabbitMQConsumer) {
        return new MessageListenerAdapter(rabbitMQConsumer, "consumeMessage2");
    }
}

上述代码中，RabbitMQConfig类通过 @Configuration 标注为配置类，@EnableRabbit 表示开启RabbitMQ的支持。在配置类中，我们定义了两个队列 queue1() 和 queue2()，一个直连交换器 exchange()，并通过 binding1() 和 binding2() 方法将队列绑定到交换器上，并指定了对应的路由键。

在 container1() 和 container2() 方法中，我们分别设置了消息监听器容器，并指定了消费队列的名称和消费方法。在这里创建的SimpleMessageListenerContainer可同时消费多个队列。

• 创建一个消费者类，例如 RabbitMQConsumer，其中包含消费消息的逻辑。示例如下：

 

import org.springframework.stereotype.Component;

@Component
public class RabbitMQConsumer {
    
    public void consumeMessage1(String message) {
        // 处理队列1的消息
        System.out.println("消费队列1的消息：" + message);
    }

    public void consumeMessage2(String message) {
        // 处理队列2的消息
        System.out.println("消费队列2的消息：" + message);
    }
}

在消费者类中，我们定义了 consumeMessage1() 方法用于消费队列1的消息，以及 consumeMessage2() 方法用于消费队列2的消息。你可以根据实际需求进行逻辑处理。

• 创建一个自定义配置类，例如 RabbitMQCustomConfig，用于读取自定义的配置项。示例如下：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "rabbitmq")
public class RabbitMQCustomConfig {
    
    private String queueName1;
    private String queueName2;
    private String exchangeName;
    private String routingKey1;
    private String routingKey2;

    // getter 和 setter 方法

    public String getQueueName1() {
        return queueName1;
    }

    public void setQueueName1(String queueName1) {
        this.queueName1 = queueName1;
    }

    public String getQueueName2() {
        return queueName2;
    }

    public void setQueueName2(String queueName2) {
        this.queueName2 = queueName2;
    }

    public String getExchangeName() {
        return exchangeName;
    }

    public void setExchangeName(String exchangeName) {
        this.exchangeName = exchangeName;
    }

    public String getRoutingKey1() {
        return routingKey1;
    }

    public void setRoutingKey1(String routingKey1) {
        this.routingKey1 = routingKey1;
    }

    public String getRoutingKey2() {
        return routingKey2;
    }

    public void setRoutingKey2(String routingKey2) {
        this.routingKey2 = routingKey2;
    }
}

 

在自定义配置类中，我们使用 @ConfigurationProperties(prefix = "rabbitmq") 注解将配置项映射到类的属性上，这样可以方便地读取自定义的配置项。

• 在你的配置文件（例如 application.properties 或 application.yml）中添加RabbitMQ的相关配置项，例如：

rabbitmq.queueName1=queue1
rabbitmq.queueName2=queue2
rabbitmq.exchangeName=exchange
rabbitmq.routingKey1=routingKey1
rabbitmq.routingKey2=routingKey2

上述配置项中，rabbitmq.queueName1 和 rabbitmq.queueName2 分别是队列1和队列2的名称，rabbitmq.exchangeName 是交换器的名称，rabbitmq.routingKey1 和 rabbitmq.routingKey2 是对应的路由键。

现在，你可以根据自定义配置来消费多个队列了。当你启动应用程序时，RabbitMQ将根据配置的队列和交换器进行消费。