spring boot配置多rabbitMQ

因为在项目中，有可能会用到多套RabbitMQ，如果只用一套那则用SpringBoot自带的配置就可以了，但多套则不行，需要自行配置。以下为本人自己总结的配置。

发现了一个更好的配置多套rabbitMQ的方式

1.application.yml
spring:
    rabbitmq:
      hospSync:
        host: localhost
        port: 5672
        username: test
        password: test
        virtual-host: test
      pay:
        host: localhost
        port: 5672
        username: demo
        password: demo
        virtual-host: demo
2.配置mq
package com.medrd.hpay.config;

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;

@Configuration
public class RabbitMqConfiguration{

    @Bean(name="hospSyncConnectionFactory")
    @Primary
    public ConnectionFactory hospSyncConnectionFactory(
            @Value("${spring.rabbitmq.hospSync.host}") String host,
            @Value("${spring.rabbitmq.hospSync.port}") int port,
            @Value("${spring.rabbitmq.hospSync.username}") String username,
            @Value("${spring.rabbitmq.hospSync.password}") String password,
            @Value("${spring.rabbitmq.hospSync.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="hPayConnectionFactory")
    public ConnectionFactory hPayConnectionFactory(
            @Value("${spring.rabbitmq.pay.host}") String host,
            @Value("${spring.rabbitmq.pay.port}") int port,
            @Value("${spring.rabbitmq.pay.username}") String username,
            @Value("${spring.rabbitmq.pay.password}") String password,
            @Value("${spring.rabbitmq.pay.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="hospSyncRabbitTemplate")
//    @Primary
    public RabbitTemplate firstRabbitTemplate(
            @Qualifier("hospSyncConnectionFactory") ConnectionFactory connectionFactory
    ){
        RabbitTemplate hospSyncRabbitTemplate = new RabbitTemplate(connectionFactory);
        //使用外部事物
        //ydtRabbitTemplate.setChannelTransacted(true);
        return hospSyncRabbitTemplate;
    }

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

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

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

}

3.监听(消费方)

package com.medrd.hpay.domain;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

@Component
public class RabbitMqMessage {

    private static final Logger logger = LoggerFactory.getLogger(RabbitMqMessage.class);

    @RabbitListener(queues = {"test.hospital.add","test.hospital.update","test.hospital.delete"}, containerFactory="hospSyncContainerFactory")
    public void hospitalAdd(@Header("amqp_receivedRoutingKey") String routeKey, Object data) {
        logger.debug("Reciver routeKey: {}, data: {}", data);
    }

    @RabbitListener(queues = {"demo.add","demo.update"}, containerFactory="hPayContainerFactory")
    public void hPayAdd(@Header("amqp_receivedRoutingKey") String routeKey, String data) {
        System.out.println(data);
        System.out.println();
    }

}
4.生产者（消息生产方

package com.paas.springboot.demo01;
 
import java.util.Date;
import javax.annotation.Resource;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;
 
@Component
public class Sender {
 
    @Resource(name="hospSyncRabbitTemplate")
    private RabbitTemplate hospSyncRabbitTemplate;
 
    public void send1() {
        String context = "hello1 " + new Date();
        System.out.println("Sender : " + context);
        this.firstRabbitTemplate.convertAndSend("test.hospital.add", context);
    }
 
    public void send2() {
        String context = "hello2 " + new Date();
        System.out.println("Sender : " + context);
        this.firstRabbitTemplate.convertAndSend("test.hospital.add", context);
    }
 
}

5.配置文件

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

引自：https://blog.csdn.net/qq_37608766/article/details/80912370

========================================================

下面是我自己研究的，感觉上面的更好，要不断进步和优化  嘿嘿

场景：现有first 、second俩个RabbitMQ  监听first的消息，处理完毕发送到second中，再监听second

package com.daling.message_center.cofig;


import org.springframework.amqp.core.*;
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.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
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 org.springframework.context.annotation.Scope;
import org.springframework.retry.backoff.BackOffPolicy;
import org.springframework.retry.backoff.ExponentialBackOffPolicy;
import org.springframework.retry.support.RetryTemplate;

@Configuration
public class RabbitMQConfigTest {

    public static final String topicExchangeName = "test-topic-exchange";
    public static final String fanoutExchange = "public_message_exchange";
    public static final String headersExchange = "test-headers-exchange";

    /*ConnectionFactory*/
    @Bean(name="firstConnectionFactory")
    @Primary
    public ConnectionFactory firstConnectionFactory(
            @Value("${spring.rabbitmq.first.host}") String host,
            @Value("${spring.rabbitmq.first.port}") int port,
            @Value("${spring.rabbitmq.first.username}") String username,
            @Value("${spring.rabbitmq.first.password}") String password,
            @Value("${spring.rabbitmq.first.virtual-host}") String virtualHost,
            @Value("${spring.rabbitmq.first.publisher-confirms}") Boolean confirm
    ){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setPublisherConfirms(confirm);
        connectionFactory.setVirtualHost(virtualHost);
        return connectionFactory;
    }

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


    /*RabbitAdmin*/

    /**
     * 声明RabbitAdmin
     */
    @Bean(name = "firstRabbitAdmin")
    public RabbitAdmin firstRabbitAdmin(@Qualifier("firstConnectionFactory") ConnectionFactory firstConnectionFactory){
        return new RabbitAdmin(firstConnectionFactory);
    }

    /**
     * 声明RabbitAdmin
     */
    @Bean(name = "secondRabbitAdmin")
    public RabbitAdmin secondRabbitAdmin(@Qualifier("secondConnectionFactory") ConnectionFactory secondConnectionFactory){
        return new RabbitAdmin(secondConnectionFactory);
    }

    /*RabbitTemplate*/
    @Bean(name="firstRabbitTemplate")
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    @Primary
    public RabbitTemplate firstRabbitTemplate(
            @Qualifier("firstConnectionFactory") ConnectionFactory connectionFactory
    ){
        RabbitTemplate firstRabbitTemplate = new RabbitTemplate(connectionFactory);
        return firstRabbitTemplate;
    }

    @Bean(name="secondRabbitTemplate")
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public RabbitTemplate secondRabbitTemplate(
            @Qualifier("secondConnectionFactory") ConnectionFactory connectionFactory,
            @Qualifier("secondRetryTemplate") RetryTemplate retryTemplate
    ){
        System.out.println("configuration secondRabbitTemplate ........................");
        RabbitTemplate secondRabbitTemplate = new RabbitTemplate(connectionFactory);
        secondRabbitTemplate.setExchange("fanout-exchange-msg_box");
        secondRabbitTemplate.setRetryTemplate(retryTemplate);
        return secondRabbitTemplate;
    }

    /*SimpleRabbitListenerContainerFactory*/
    @Bean(name="firstFactory")
    public SimpleRabbitListenerContainerFactory firstFactory(
            SimpleRabbitListenerContainerFactoryConfigurer configurer,
            @Qualifier("firstConnectionFactory") ConnectionFactory connectionFactory
    ) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        configurer.configure(factory, connectionFactory);
        return factory;
    }

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

    /*Queue*/
    @Bean(name = "msg_center_queue")
    public Queue msgCenterQueue() {
        System.out.println("configuration msg_center_queue ........................");
        return new Queue("msg_center_queue");
    }

    @Bean(name = "msg_box_queue")
    public Queue msgBoxQueue() {
        System.out.println("configuration msg_box_queue ........................");
        return new Queue("msg_box_queue_test");
    }

    /*Exchange*/
    @Bean(name = "firstFanoutExchange")
    public FanoutExchange firstfanoutExchange(@Qualifier("firstRabbitAdmin") RabbitAdmin rabbitAdmin) {
        System.out.println("configuration firstExchange ........................");
        FanoutExchange fanoutExchange = new FanoutExchange(RabbitMQConfigTest.fanoutExchange);
        rabbitAdmin.declareExchange(fanoutExchange);
        boolean fula = fanoutExchange.isAutoDelete();
        return fanoutExchange;
    }

    @Bean(name = "secondFanoutExchange")
    public FanoutExchange secondfanoutExchange(@Qualifier("secondRabbitAdmin") RabbitAdmin rabbitAdmin) {
        System.out.println("configuration secondExchange ........................");
        FanoutExchange fanoutExchange = new FanoutExchange("fanout-exchange-msg_box");
        rabbitAdmin.declareExchange(fanoutExchange);
        fanoutExchange.isAutoDelete();
        return fanoutExchange;
    }

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(topicExchangeName);
    }

    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange(headersExchange);
    }

    /*Binding*/
//    @Bean
//    public Binding msgCenterQueueBinding() {
//        return BindingBuilder.bind(firstQueue()).to(fanoutExchange(@Qualifier("firstRabbitAdmin") RabbitAdmin));
//    }

    /**
     * 绑定queue与exchange
     */
    @Bean
    public Binding binding1(@Qualifier("msg_center_queue") Queue msgCenterQueue, @Qualifier("firstFanoutExchange") FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(msgCenterQueue).to(fanoutExchange);
    }


    @Bean//测试用
    public Binding binding2(@Qualifier("msg_box_queue") Queue msgBoxQueue, @Qualifier("secondFanoutExchange") FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(msgBoxQueue).to(fanoutExchange);
    }

    /**
     * 声明MessageListenerContainer
     */
    @Bean(name = "centerListenerContainerFactory")
    public SimpleMessageListenerContainer insMessageListenerContainer(@Qualifier("msg_center_queue") Queue testQuene,
                                                                      @Qualifier("firstConnectionFactory") ConnectionFactory firstConnectionFactory,
                                                                      @Qualifier("commonMessageListener") MessageListener commonMessageListener) {

        SimpleMessageListenerContainer messageListenerContainer = new SimpleMessageListenerContainer();
        messageListenerContainer.setConnectionFactory(firstConnectionFactory);
        messageListenerContainer.addQueues(testQuene);
        messageListenerContainer.setAcknowledgeMode(AcknowledgeMode.AUTO);
        messageListenerContainer.setMessageListener(commonMessageListener);
        return messageListenerContainer;
    }

    @Bean(name = "boxListenerContainerFactory")//测试用(自己发自己接收)
    public SimpleMessageListenerContainer insMessageListenerContainer2(@Qualifier("msg_box_queue") Queue testQuene,
                                                                      @Qualifier("secondConnectionFactory") ConnectionFactory secondConnectionFactory,
                                                                      @Qualifier("boxMessageListener") MessageListener boxMessageListener) {

        SimpleMessageListenerContainer messageListenerContainer = new SimpleMessageListenerContainer();
        messageListenerContainer.setConnectionFactory(secondConnectionFactory);
        messageListenerContainer.addQueues(testQuene);
        messageListenerContainer.setAcknowledgeMode(AcknowledgeMode.AUTO);
        messageListenerContainer.setMessageListener(boxMessageListener);
        return messageListenerContainer;
    }

    /**
     * Retry策略Bean
     * @return
     */
    @Bean(name = "secondRetryTemplate")
    public RetryTemplate secondRetryTemplate(@Qualifier("secondBackOffPolicy") BackOffPolicy policy){
        System.out.println("configuration secondRetryTemplate ........................");
        RetryTemplate retryTemplate = new RetryTemplate();
        retryTemplate.setBackOffPolicy(policy);
        return retryTemplate;
    }

    @Bean(name = "secondBackOffPolicy")
    public BackOffPolicy secondBackOffPolicy() {
        System.out.println("configuration secondBackOffPolicy ........................");
        ExponentialBackOffPolicy policy = new ExponentialBackOffPolicy();
        policy.setInitialInterval(500);
        policy.setMultiplier(2.0);
        policy.setMaxInterval(10000);
        return policy;
    }

}

监听器fist
package com.daling.message_center.service.rabbitmq.listners;

import com.daling.message_center.service.processor.IMsgCenterListenerAssembly;
import com.daling.message_center.util.LoggerHelp;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.UnsupportedEncodingException;

@Component
public class CommonMessageListener implements MessageListener {

    @Autowired
    private IMsgCenterListenerAssembly iMsgCenterListenerAssembly;

    static {
        LoggerHelp.setLog(LoggerHelp.rabbitmq);
    }

    @Override
    public void onMessage(Message message) {

        String eventStr = new String(message.getBody());
        String msg = null;
        try {
            msg = new String(eventStr.getBytes(), "utf-8");
        } catch (UnsupportedEncodingException e) {
            LoggerHelp.getLog().error("error", e);
        }

        LoggerHelp.getLog().info("===============msg:{}", msg);
        iMsgCenterListenerAssembly.assembly(msg);
    }
}
监听器second

package com.daling.message_center.service.rabbitmq.listners;

import com.daling.message_center.util.LoggerHelp;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;
import org.springframework.stereotype.Component;

import java.io.UnsupportedEncodingException;

@Component
public class boxMessageListener implements MessageListener {
    @Override
    public void onMessage(Message message) {
        String eventStr = new String(message.getBody());
        String msg = null;
        try {
            msg = new String(eventStr.getBytes(), "utf-8");
        } catch (UnsupportedEncodingException e) {
            LoggerHelp.getLog().error("error", e);
        }
        LoggerHelp.getLog().info("===============msg:{}", msg);
        System.out.println("监听的信息==="+msg.toString());
    }
}

//向second  RabbitMQ发送消息

package com.daling.message_center.service.rabbitmq.senders;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import java.util.concurrent.CompletableFuture;

@Component
public class MsgCenterSender {

    @Autowired
    @Qualifier("secondRabbitTemplate")
    private AmqpTemplate secondRabbitTemplate;

    public CompletableFuture<Void> sendToBox(String msg){
            secondRabbitTemplate.convertAndSend(msg);
        return CompletableFuture.completedFuture(null);
    }
}

 

参考：https://my.oschina.net/woter/blog/1843401  和本人实际项目配置完成