一、Spring Boot 集成 RabbitMQ
Spring Boot 集成 RabbitMQ 非常简单，如果只是简单的使用配置非常少，Spring Boot 提供了spring-boot-starter-amqp 项目对消息各种支持。
（1）配置 Pom 包，主要是添加 spring-boot-starter-amqp 的支持
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>（2）配置文件
配置 RabbitMQ 的安装地址、端口以及账户信息
spring.application.name=Spring-boot-rabbitmq
spring.rabbitmq.host=192.168.147.128
spring.rabbitmq.port=5672
spring.rabbitmq.username=test
spring.rabbitmq.password=passwd（3）队列配置
@Configuration
public class RabbitConfig {
@Bean
public Queue queue() {
return new Queue("hello");
}
}（4）发送者
rabbitTemplate 是 Spring Boot 提供的默认实现
@Component
public class HelloSender {
@Autowired
private AmqpTemplate rabbitTemplate;
public void send() {
String context = "hello " + new Date();
System.out.println("Sender : " + context);
this.rabbitTemplate.convertAndSend("hello", context);
}
}（5）接收者
@Component
@RabbitListener(queues = "hello")
public class HelloReceiver {
@RabbitHandler
public void process(String hello) {
System.out.println("Receiver : " + hello);
}
}（6）测试
@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitMqHelloTest {
@Autowired
private HelloSender helloSender;
@Test
public void hello() throws Exception {
helloSender.send();
}
}
二、多对多使用
一个发送者，N 个接收者或者 N 个发送者和 N 个接收者会出现什么情况呢？
（1）一对多发送
对上面的代码进行了小改造，接收端注册了两个 Receiver,Receiver1 和 Receiver2，发送端加入参数计数，接收端打印接收到的参数，下面是测试代码，发送一百条消息，来观察两个接收端的执行效果
@Test
public void oneToMany() throws Exception {
for (int i = 0; i < 100; i++) {
helloSender.send(i);
}
}
根据返回结果得到结论：一个发送者，N个接受者,经过测试会均匀的将消息发送到N个接收者中
（2）多对多发送
复制了一份发送者，加入标记，在一百个循环中相互交替发送
@Test
public void manyToMany() throws Exception {
for (int i = 0; i < 100; i++) {
helloSender.send(i);
helloSender2.send(i);
}
}
结论：和一对多一样，接收端仍然会均匀接收到消息
三、高级使用
（1）对象的支持
Spring Boot 以及完美的支持对象的发送和接收，不需要格外的配置。
注意：对象需要序列化
发送者：
public void send(Book book) {
System.out.println("Sender : " + book);
this.rabbitTemplate.convertAndSend("obj", book);
}接收者：
@RabbitHandler
public void process(Book book) {
System.out.println("Receiver : " + book);
} 
（2）Topic Exchange
topic 是 RabbitMQ 中最灵活的一种方式，可以根据 routing_key 自由的绑定不同的队列。首先对 topic 规则配置，这里使用两个队列来测试。
@Configuration
public class TopicRabbitConfig {
final static String message = "topic.message";
final static String messages = "topic.messages";
/**
* 创建两个队列
* @return
*/
@Bean
public Queue queueMessage() {
return new Queue(TopicRabbitConfig.message);
}
@Bean
public Queue queueMessages() {
return new Queue(TopicRabbitConfig.messages);
}
/**
* 创建规则交换机
* @return
*/
@Bean
TopicExchange exchange() {
return new TopicExchange("exchange");
}
/**
* 定义匹配规则
* @param queueMessage
* @param exchange
* @return
*/
@Bean
Binding bindingExchangeMessage(Queue queueMessage, TopicExchange exchange) {
return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message");
}
@Bean
Binding bindingExchangeMessages(Queue queueMessages, TopicExchange exchange) {
return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");
}
}public void send1() {
String context = "hi, i am message 1";
System.out.println("Sender : " + context);
this.rabbitTemplate.convertAndSend("exchange", "topic.message", context);
}
public void send2() {
String context = "hi, i am messages 2";
System.out.println("Sender : " + context);
this.rabbitTemplate.convertAndSend("exchange", "topic.messages", context);
}发送send1会匹配到topic.#和topic.message 两个Receiver都可以收到消息
发送send2只有topic.#可以匹配所有只有Receiver2监听到消息
（3）Fanout Exchange
Fanout 就是我们熟悉的广播模式或者订阅模式，给 Fanout 交换机发送消息，绑定了这个交换机的所有队列都收到这个消息。
@Configuration
public class FanoutRabbitConfig {
/**
* 创建3个队列
* @return
*/
@Bean
public Queue AMessage() {
return new Queue("fanout.A");
}
@Bean
public Queue BMessage() {
return new Queue("fanout.B");
}
@Bean
public Queue CMessage() {
return new Queue("fanout.C");
}
/**
* 创建订阅交换机
* @return
*/
@Bean
FanoutExchange fanoutExchange() {
return new FanoutExchange("fanoutExchange");
}
/**
* 绑定队列
* @param AMessage
* @param fanoutExchange
* @return
*/
@Bean
Binding bindingExchangeA(Queue AMessage, FanoutExchange fanoutExchange) {
return BindingBuilder.bind(AMessage).to(fanoutExchange);
}
@Bean
Binding bindingExchangeB(Queue BMessage, FanoutExchange fanoutExchange) {
return BindingBuilder.bind(BMessage).to(fanoutExchange);
}
@Bean
Binding bindingExchangeC(Queue CMessage, FanoutExchange fanoutExchange) {
return BindingBuilder.bind(CMessage).to(fanoutExchange);
}
}这里使用了 A、B、C 三个队列绑定到 Fanout 交换机上面，发送端的 routing_key 写任何字符都会被忽略：
public void send() {
String context = "hi, fanout msg ";
System.out.println("Sender : " + context);
this.rabbitTemplate.convertAndSend("fanoutExchange","", context);
} 
结果说明，绑定到 fanout 交换机上面的队列都收到了消息。
