SpringBoot AMQP多源的使用

说明

最近来写几个使用SpringBoot下会遇到的多数据源的接入问题以及处理方式吧~。

在实际的项目中，我们经常会需要接入或者发给很多不同的MQ，那么在Springboot下有什么比较好的处理方式？当当当，AMQP(Advanced Message Queuing Protocol 高级消息队列协议)来啦，这是一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。简单来说这个协议野心比较大(ง •_•)ง，他想要市面上的MQ去按照这个协议标准去开发，那么对于我们开发者来说，接入不同的MQ的成本就会比较低了，然而现在只有RabbitMQ遵循了这个协议。。。所以如果项目使用的是RabbitMQ的开发者可以考虑使用这个AMQP的包来处理多源问题。

快速开始

首先当然要引入包

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

然后在配置文件application.yml里填MQ地址(假设有两个MQ待接入，如果是测试的话可以通过不同virtual-host的方式来测试，virtual-host不同就相当于多个不同的MQ了)

spring:
  rabbitmq:
    # 多源配置
    outside:
      port: 5672
      username: yunlingfly
      password: password
      host: xxx.xxx.xxx.xxx
      virtual-host: /
    inside:
      port: 5672
      username: test
      password: test
      host: xxx.xxx.xxx.xxx
      virtual-host: test

编写Java配置文件

import org.springframework.amqp.rabbit.annotation.RabbitListener;
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;

import javax.annotation.Resource;

/**
 * rabbitMQ多源配置
 *
 * @author : yunlingfly
 * @date : 2020/1/9
 */
@Configuration
public class RabbitMqConfig {
    @Bean(name = "insideConnectionFactory")
    @Primary
    public ConnectionFactory insideConnectionFactory(
            @Value("${spring.rabbitmq.inside.host}") String host,
            @Value("${spring.rabbitmq.inside.port}") int port,
            @Value("${spring.rabbitmq.inside.username}") String username,
            @Value("${spring.rabbitmq.inside.password}") String password,
            @Value("${spring.rabbitmq.inside.virtual-host}") String virtualHost) {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);

        return connectionFactory;
    }

    @Bean(name = "outsideConnectionFactory")
    public ConnectionFactory outsideConnectionFactory(
            @Value("${spring.rabbitmq.outside.host}") String host,
            @Value("${spring.rabbitmq.outside.port}") int port,
            @Value("${spring.rabbitmq.outside.username}") String username,
            @Value("${spring.rabbitmq.outside.password}") String password,
            @Value("${spring.rabbitmq.outside.virtual-host}") String virtualHost) {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        return connectionFactory;
    }

    @Bean(name = "insideRabbitTemplate")
    @Primary
    public RabbitTemplate firstRabbitTemplate(@Qualifier("insideConnectionFactory") ConnectionFactory connectionFactory) {
        return new RabbitTemplate(connectionFactory);
    }

    @Bean(name = "outsideRabbitTemplate")
    public RabbitTemplate secondRabbitTemplate(@Qualifier("outsideConnectionFactory") ConnectionFactory connectionFactory) {
        return new RabbitTemplate(connectionFactory);
    }

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

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

那么如何使用呢（多源同理接收或发送改@RabbitListener里的containerFactory或者@Resource里的name即可）->

    // 接收使用containerFactory指定源
    @RabbitListener(queues = "hello", containerFactory="insideContainerFactory")
    public void receiver(String data) {
        System.out.println(data);
    }
    // 发送使用Resource指定源
    @Resource(name="insideRabbitTemplate")
    private RabbitTemplate insideRabbitTemplate;

    private void sendMsgToMQ() {
        insideRabbitTemplate.convertAndSend("queueName", "msg");
    }