上一篇我们介绍了如何使用 Java client 操作 RabbitMQ，这种方式是基础、更接近本质，但是用起来还是有些麻烦，实际的开发中更多的会和 Spring 框架整合来提高开发效率，本文将介绍如何在 SpringBoot 中使用 RabbitMQ，详细的原理可翻阅之前的文章。
例子的话，会以购买火车票成功后，发送订单信息到短信消息队列、微信消息队列，然后短信服务、微信服务分别将队列中的消息以短信、微信的形式发送给用户，会结合Fanout、Direct、Topic、Default四种的交换机来实现。
一、准备工作
创建一个 SpringBoot 项目，pom.xml中添加 RabbitMQ 依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
在application.properties配置 RabbitMQ 服务的相关连接信息：
server.port=8080
# rabbitmq 相关配置
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123456
spring.rabbitmq.virtual-host=/
简单起见，我们将生产者和消费者定义在同一个项目里。
二、Fanout Exchange
首先需要创建 Exchange、Queue，并绑定它们。在 SpringBoot 中可以通过配置类的形式来完成：
@Configuration
public class FanoutRabbitMQConfig {
// Fanout交换机
@Bean
FanoutExchange fanoutExchange() {
return new FanoutExchange("fanout.ticket.exchange", true, false);
}
// 短信消息队列
@Bean
Queue fanoutSmsQueue() {
return new Queue("fanout.sms.queue", true);
}
// 微信消息队列
@Bean
Queue fanoutWeChatQueue() {
return new Queue("fanout.wechat.queue", true);
}
// 绑定队列和交换机
@Bean
Binding fanoutSmsBinding() {
return BindingBuilder.bind(fanoutSmsQueue()).to(fanoutExchange());
}
@Bean
Binding fanoutEmailBinding() {
return BindingBuilder.bind(fanoutWeChatQueue()).to(fanoutExchange());
}
}
Fanout交换机使用FanoutExchange类来创建。
然后就是发送消息的逻辑：
@Service
public class TicketService {
@Autowired
private RabbitTemplate rabbitTemplate;
public void buyTicketFanout() {
String orderId = UUID.randomUUID().toString();
String exchangeName = "fanout.ticket.exchange";
String routingKey = "";
System.out.println("fanout-购票成功：" + orderId);
// 发送消息
rabbitTemplate.convertAndSend(exchangeName, routingKey, orderId);
}
}
这里注入了RabbitTemplate对象，用它来发送消息。
按照Fanout类型交换机的原理，无论是绑定 Exchange 和 Queue 还是发送消息都不用指定 routingKey。
最后就是接收队列中的消息并处理了：
@Service
public class SmsService {
@RabbitListener(queues = "fanout.sms.queue")
public void handleMessageFanout(String message) {
System.out.println("fanout-短信消息通知：" + message);
}
}
@Service
public class WeChatService {
@RabbitListener(queues = "fanout.wechat.queue")
public void handleMessageFanout(String message) {
System.out.println("fanout-微信消息通知：" + message);
}
}
主要就是RabbitListener注解了，用它来决定接收那个队列的消息。
我们先启动项目，然后通过单元测试发送消息：
@SpringBootTest
public class RabbitMQApplicationTests {
@Autowired
private TicketService ticketService;
@Test
void contextLoads() {
ticketService.buyTicketFanout();
}
}
最终的测试结果如下：
三、Direct Exchange
使用 Direct 类型的交换机方法类似，创建交换机使用DirectExchange类，注意绑定的时候需要指定routingKey：
@Configuration
public class DirectRabbitMQConfig {
// Direct交换机
@Bean
DirectExchange directExchange() {
return new DirectExchange("direct.ticket.exchange", true, false);
}
// 短信消息队列
@Bean
Queue directSmsQueue() {
return new Queue("direct.sms.queue", true);
}
// 微信消息队列
@Bean
Queue directWeChatQueue() {
return new Queue("direct.wechat.queue", true);
}
// 绑定队列和交换机
@Bean
Binding directSmsBinding() {
return BindingBuilder.bind(directSmsQueue()).to(directExchange()).with("sms");
}
@Bean
Binding directEmailBinding() {
return BindingBuilder.bind(directWeChatQueue()).to(directExchange()).with("wechat");
}
}
发送消息时同样需要指定routingKey：
public void buyTicketDirect() {
String orderId = UUID.randomUUID().toString();
String exchangeName = "direct.ticket.exchange";
String routingKey = "sms";
System.out.println("direct-购票成功：" + orderId);
rabbitTemplate.convertAndSend(exchangeName, routingKey, orderId);
}
接收处理消息时只需要修改队列名即可：
// SmsService
@RabbitListener(queues = "direct.sms.queue")
public void handleMessageDirect(String message) {
System.out.println("direct-短信消息通知：" + message);
}
// WeChatService
@RabbitListener(queues = "direct.wechat.queue")
public void handleMessageDirect(String message) {
System.out.println("direct-微信消息通知：" + message);
}
重启项目，按照前边的方法测试，最终消息只发送到了短信消息队列，被短信服务消费：
四、Topic Exchange
之前已经说过，Topic Exchange 和 Direct Exchage 很类似，只是 routingKey 支持通配符。
创建交换机使用TopicExchange类：
@Configuration
public class TopicRabbitMQConfig {
// Topic交换机
@Bean
TopicExchange topicExchange() {
return new TopicExchange("topic.ticket.exchange", true, false);
}
// 短信消息队列
@Bean
Queue topicSmsQueue() {
return new Queue("topic.sms.queue", true);
}
// 微信消息队列
@Bean
Queue topicWeChatQueue() {
return new Queue("topic.wechat.queue", true);
}
// 绑定队列和交换机
// # 匹配 0个、1个、多个单词；* 匹配一个单词
@Bean
Binding topicSmsBinding() {
return BindingBuilder.bind(topicSmsQueue()).to(topicExchange()).with("#.sms.#");
}
@Bean
Binding topicEmailBinding() {
return BindingBuilder.bind(topicWeChatQueue()).to(topicExchange()).with("*.wechat.#");
}
}
发送消息：
public void buyTicketTopic() {
String orderId = UUID.randomUUID().toString();
String exchangeName = "topic.ticket.exchange";
String routingKey = "sms.wechat";
System.out.println("topic-购票成功：" + orderId);
rabbitTemplate.convertAndSend(exchangeName, routingKey, orderId);
}
接收处理消息：
// SmsService
@RabbitListener(queues = "topic.sms.queue")
public void handleMessageDirect(String message) {
System.out.println("topic-短信消息通知：" + message);
}
// WeChatService
@RabbitListener(queues = "topic.wechat.queue")
public void handleMessageDirect(String message) {
System.out.println("topic-微信消息通知：" + message);
}
最终的效果如下：
五、Default Exchange
Default Exchange 是一种特殊的 Direct Exchange，使用它时，我们只需要创建 Queue 即可，RabbitMQ 服务会自动将 Queue 和一个名称为空的默认的 Exchange 绑定，同时将 Routing Key 指定为 Queue 的名称。这样自然也就不够灵活了，不好做业务划分。但了解一下，做一些简单的需求还是可以的。
首先创建队列：
@Configuration
public class DefaultRabbitMQConfig {
// 短信消息队列
@Bean
Queue defaultSmsQueue() {
return new Queue("default.sms.queue", true);
}
// 微信消息队列
@Bean
Queue defaultWeChatQueue() {
return new Queue("default.wechat.queue", true);
}
}
然后发送消息：
public void buyTicketDefault() {
String orderId = UUID.randomUUID().toString();
String routingKey = "default.sms.queue";
System.out.println("topic-购票成功：" + orderId);
rabbitTemplate.convertAndSend(routingKey, orderId);
}
发送消息时不用指定交换机名称，routingKey为目标队列的名称。
接收消息和之前一样就不赘述了。
六、小结
其实可以发现整合 SpringBoot 后，使用起来很简单，几种模式大同小异，很容易上手。要选择那种模式还要根据实际的业务来决定。
