spring boot配置多mq

spring boot配置多mq

把spring项目重构成springboot架构，遇到mq配置问题，刚开始利用springboot默认的mq配置简单声明了队列，发现只有一个mq配置生效，另外一个未注册成功。
这里记录下spring boot配置多mq：手动创建mq连接，监听不同链接下的队列消费mq消息
代码如下:

package com;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

/**
 * springboot多个mq配置
 * @author
 */
@Configuration
public class MultiSpringBootMqConfig {

    @Value("${aHost}")
    private String aHost;
    @Value("${aPort}")
    private int aPort;
    @Value("${aUserName}")
    private String aUserName;
    @Value("${aUserPwd}")
    private String aUserPwd;
    @Value("${aVirtualHost}")
    private String aVirtualHost;
    @Value("${aDirectExchange}")
    private String aDirectExchange;
    /**
     * 队列名
     */
    private static final String A_QUEUE = "a_queue";

    @Value("${bHost}")
    private String bHost;
    @Value("${bPort}")
    private int bPort;
    @Value("${bUserName}")
    private String bUserName;
    @Value("${bUserPwd}")
    private String bUserPwd;
    @Value("${bVirtualHost}")
    private String bVirtualHost;
    @Value("${bDirectExchange}")
    private String bDirectExchange;
    @Value("${bRoutingKey}")
    private String bRoutingKey;
    /**
     * 队列名
     */
    private static final String B_QUEUE = "b_queue";

    /**
     * a mq配置
     * @Primary 优先
     * @return
     */
    @Bean(name="aMqConnectionFactory")
    @Primary
    public ConnectionFactory aMqConnectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(aHost);
        connectionFactory.setPort(aPort);
        connectionFactory.setUsername(aUserName);
        connectionFactory.setPassword(aUserPwd);
        connectionFactory.setVirtualHost(aVirtualHost);

        return connectionFactory;
    }

    @Bean(name="aRabbitTemplate")
    @Primary
    public RabbitTemplate aRabbitTemplate(
            @Qualifier("aMqConnectionFactory") ConnectionFactory connectionFactory){
        RabbitTemplate hPayRabbitTemplate = new RabbitTemplate(connectionFactory);
        //使用外部事物
        //lpzRabbitTemplate.setChannelTransacted(true);
        return hPayRabbitTemplate;
    }

    @Bean(name="aMqContainerFactory")
    public SimpleRabbitListenerContainerFactory aMqContainerFactory(
            SimpleRabbitListenerContainerFactoryConfigurer configurer,
            @Qualifier("aMqConnectionFactory") ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        configurer.configure(factory, connectionFactory);
        return factory;
    }

    @Bean
    public DirectExchange aDirectExchange() {
        return new DirectExchange(aDirectExchange, true, false);
    }

    @Bean
    public Queue aQueue() {
        // 第一个参数是队列名字， 第二个参数是指是否持久化
        return new Queue(A_QUEUE, true);
    }

    @Bean
    public Binding aBind() {
        // with(A_QUEUE);  routingKey
        return BindingBuilder.bind(aQueue()).to(aDirectExchange()).with(A_QUEUE);
    }


    /**
     * b配置
     * @return
     */
    @Bean(name="bMqConnectionFactory")
    public ConnectionFactory bMqConnectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(bHost);
        connectionFactory.setPort(bPort);
        connectionFactory.setUsername(bUserName);
        connectionFactory.setPassword(bUserPwd);
        connectionFactory.setVirtualHost(bVirtualHost);

        return connectionFactory;
    }

    @Bean(name="bRabbitTemplate")
    public RabbitTemplate bRabbitTemplate(
            @Qualifier("bMqConnectionFactory") ConnectionFactory connectionFactory){
        RabbitTemplate hPayRabbitTemplate = new RabbitTemplate(connectionFactory);
        //使用外部事物
        //lpzRabbitTemplate.setChannelTransacted(true);
        return hPayRabbitTemplate;
    }

    @Bean(name="bMqContainerFactory")
    public SimpleRabbitListenerContainerFactory bMqContainerFactory(
            SimpleRabbitListenerContainerFactoryConfigurer configurer,
            @Qualifier("bMqConnectionFactory") ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        configurer.configure(factory, connectionFactory);
        return factory;
    }

    @Bean
    public DirectExchange bDirectExchange() {
        return new DirectExchange(bDirectExchange, true, false);
    }

    @Bean
    public Queue bQueue() {
        // 第一个参数是队列名字， 第二个参数是指是否持久化
        return new Queue(B_QUEUE, true);
    }

    @Bean
    public Binding bBind() {
        return BindingBuilder.bind(bQueue()).to(bDirectExchange()).with(bRoutingKey);
    }

}

增加指定虚拟机注册交换机，队列等方法
exchangeName, queueName 可以自定义

/**
     * 消息交换机
     * @return
     */
    @Bean
    public String screenMessageExchange(@Qualifier("bMqConnectionFactory") ConnectionFactory connectionFactory) {
        log.info("声明消息交换机 :{}", bDirectExchange);
        try {
            connectionFactory.createConnection()
                    .createChannel(false)
                    .exchangeDeclare(exchangeName,
                            BuiltinExchangeType.FANOUT, true, false, false, null);
        } catch (IOException e) {
            log.error("声明消息交换机异常:{}", e.getMessage());
        }

        return exchangeName;
    }
    
/**
     * 如果要在第二个mq中也创建队列hello1，那么需要指定数据源secondConnectionFactory
     * @param connectionFactory
     * @return
     */
    @Bean
    public String screenMessageQueue(@Qualifier("bMqConnectionFactory") ConnectionFactory connectionFactory) {
        log.info("声明消息队列 :{}", queueName);
        try {
            connectionFactory.createConnection()
                    .createChannel(false)
                    .queueDeclare(queueName, true, false, false, null);
        }catch (IOException e){
            log.error("声明消息队列异常:{}", e.getMessage());
        }

        return queueName;
    }

接收消息类：

public class MqTest {

    @RabbitListener(queues = MultiSpringBootMqConfig.A_QUEUE,
            containerFactory="aMqContainerFactory")
    @RabbitHandler
    public void aTest(Message message, Channel channel) {
        System.out.println("hello, a mq收到消息");
    }

    @RabbitListener(queues = MultiSpringBootMqConfig.B_QUEUE,
            containerFactory="bMqContainerFactory")
    @RabbitHandler
    public void bTest(Message message, Channel channel) {
        System.out.println("hello, b mq收到消息");
    }
}

以上仅供参考，技术无界，大佬们有更好的更简单方便的方法，可以分享出来共同学习。