Springboot+rabbitMQ（连接多个rabbitMQ）代码实例_springboot连接多个rabbitmq 简单一些

一、简介
本文使用基础框架为Springboot，连接多个RabbitMQ，简单实例希望能对各位有用。如果有问题的可参照另一篇单rabbitMQ的博文

二、代码
1、application.properties
配置连接地址，要几个复制几份改个名吧

spring.rabbitmq.first.host=地址1
spring.rabbitmq.first.port=端口1
spring.rabbitmq.first.username=用户名1
spring.rabbitmq.first.password=密码1

spring.rabbitmq.second.host=地址2
spring.rabbitmq.second.port=端口2
spring.rabbitmq.second.username=用户名2
spring.rabbitmq.second.password=密码2

spring.rabbitmq.three.host=地址3
spring.rabbitmq.three.port=端口3
spring.rabbitmq.three.username=用户名3
spring.rabbitmq.three.password=密码3
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、配置各个连接的参数

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.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;

/**
 * 用于配置rabbitMQ
 */
@Configuration
public class RabbitConfig {


    /*
    定义连接，我方rabbitMQ
     */
    @Bean(name = "myConnectionFactory")
    @Primary
    public ConnectionFactory myConnectionFactory(
            @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
    ) {
        return connectionFactory(host, port, username, password);
    }

    /*
    定义连接
     */
    @Bean(name = "secondConnectionFactory")

    public ConnectionFactory daHuaConnectionFactory(
            @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
    ) {
        return connectionFactory(host, port, username, password);
    }

    /*
    定义连接
     */
    @Bean(name = "threeConnectionFactory")
    public ConnectionFactory taiShengConnectionFactory(
            @Value("${spring.rabbitmq.three.host}") String host,
            @Value("${spring.rabbitmq.three.port}") int port,
            @Value("${spring.rabbitmq.three.username}") String username,
         //   @Value("${spring.rabbitmq.three.virtual-host}") String virtual_host,
            @Value("${spring.rabbitmq.three.password}") String password

    ) {
        return connectionFactory(host, port, username, password);
    }

    public CachingConnectionFactory connectionFactory(String host,int port,String username,String password){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
      //  connectionFactory.setVirtualHost(virtual_host);
        return connectionFactory;
    }

    @Bean(name = "myRabbitTemplate")
    @Primary
    public RabbitTemplate myRabbitTemplate(
            @Qualifier("myConnectionFactory") ConnectionFactory connectionFactory
    ) {
        RabbitTemplate myRabbitTemplate = new RabbitTemplate(connectionFactory);
        return myRabbitTemplate;
    }

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

    @Bean(name = "threeTemplate")
    public RabbitTemplate threeTemplate(
            @Qualifier("threeConnectionFactory") ConnectionFactory connectionFactory
    ) {
        RabbitTemplate threeRabbitTemplate = new RabbitTemplate(connectionFactory);
        return taiShengRabbitTemplate;
    }


    @Bean(name = "myFactory")
    @Primary
    public SimpleRabbitListenerContainerFactory myFactory(
            SimpleRabbitListenerContainerFactoryConfigurer configurer,
            @Qualifier("myConnectionFactory") 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;
    }
    @Bean(name = "threeFactory")
    public SimpleRabbitListenerContainerFactory threeFactory(
            SimpleRabbitListenerContainerFactoryConfigurer configurer,
            @Qualifier("threeConnectionFactory") ConnectionFactory connectionFactory
    ) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        configurer.configure(factory, connectionFactory);
        return factory;
    }

    /*
    声明交换机 amq.topic topic类型的，其他类型的直接改TopicExchange
     */
    @Bean
    public TopicExchange basicExchange(){
        return new TopicExchange("amq.topic", true,false);
    }

    /*
    声明消息队列 启动创建，停止自动删除
     */
    @Bean(name = "basicQueue")
    public Queue basicQueue(){
        return new Queue("acquire-alarm-volume", false,true,true);
    }

    /*
    队列绑定交换机 *.*.*.*.*.*为rountingkey
     */
    @Bean
    public Binding basicBinding(){
        return BindingBuilder.bind(basicQueue()).to(basicExchange()).with("*.*.*.*.*.*");}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

发送数据

//获取bean
 @Resource(name="secondRabbitTemplate")
    private RabbitTemplate secondRabbitTemplate;
    //发送到模拟RabbitMQ上
    public 	void  send（String completeMessage）{
          secondRabbitTemplate.convertAndSend(exchange_dahua,"",completeMessage);
    }
  
1
2
3
4
5
6
7
8

监听

    @RabbitHandler
    @RabbitListener(queues ="acquire-alarm-volume", id = "Message",containerFactory = "myFactory")
    public void process(byte [] message) {
        System.out.print(new String(message))
    }
1
2
3
4
5