RabbitMQ（02章）：RabbitMQ之交换机（直联、主题、扇形）
目录
7.交换机（直联、主题、扇形）
7. 1Exchange(交换机)的作用
7.2. Exchange(交换机)的类型
7.3. 交换机的属性
7.4. 综合案例：交换机的使用
7.4.1.直连交换机(Direct Exchange)
7.4.2.主题交换机(Topic Exchange)
7.4.3.扇形交换机(Fanout Exchange)
7.交换机（直联、主题、扇形）
7. 1Exchange(交换机)的作用
在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列，
队列再将消息以推送或者拉取方式给消费者进行消费
创建消息 路由键 pull/push
生产者------------>交换机------------>队列------------>消费者
交换机原理图见：
7.2. Exchange(交换机)的类型
7.2.1.直连交换机：Direct Exchange
直连交换机是一种带路由功能的交换机，一个队列会和一个交换机绑定，除此之外再绑定一个routing_key，当消息被发送的时候，需要指定一个binding_key，这个消息被送达交换机的时候，就会被这个交换机送到指定的队列里面去。同样的一个binding_key也是支持应用到多个队列中的。
这样当一个交换机绑定多个队列，就会被送到对应的队列去处理。
注1：什么是路由键
每个消息都有一个称为路由键(routing key)的属性，它其实就是一个简单的字符串
注2：直连交换机适用场景
有优先级的任务，根据任务的优先级把消息发送到对应的队列，这样可以指派更多的资源去处理高优先级的队列。
7.2.2.主题交换机：Topic Exchange
直连交换机的缺点！
直连交换机的routing_key方案非常简单，如果我们希望一条消息发送给多个队列，那么这个交换机需要绑定上非常多的routing_key，
假设每个交换机上都绑定一堆的routing_key连接到各个队列上。那么消息的管理就会异常地困难。
所以RabbitMQ提供了一种主题交换机，发送到主题交换机上的消息需要携带指定规则的routing_key，
主题交换机会根据这个规则将数据发送到对应的(多个)队列上。
主题交换机的routing_key需要有一定的规则，交换机和队列的binding_key需要采用*.#.*.....的格式，每个部分用.分开，其中
* 表示一个单词
# 表示任意数量（零个或多个）单词。
示例：
队列Q1绑定键为 *.TT.*
队列Q2绑定键为TT.#
如果一条消息携带的路由键为 A.TT.B，那么队列Q1将会收到
如果一条消息携带的路由键为TT.AA.BB，那么队列Q2将会收到
7.2.3.扇形交换机：Fanout Exchange
扇形交换机是最基本的交换机类型，它所能做的事情非常简单———广播消息。
扇形交换机会把能接收到的消息全部发送给绑定在自己身上的队列。因为广播不需要“思考”，
所以扇形交换机处理消息的速度也是所有的交换机类型里面最快的。
这个交换机没有路由键概念，就算你绑了路由键也是无视的。
7.2.4.首部交换机： Headers exchange
7.2.5.默认交换机
实际上是一个由RabbitMQ预先声明好的名字为空字符串的直连交换机（direct exchange）。它有一个特殊的属性使得它对于
简单应用特别有用处：那就是每个新建队列（queue）都会自动绑定到默认交换机上，绑定的路由键（routing key）名称与队列名称相同。
如：当你声明了一个名为”hello”的队列，RabbitMQ会自动将其绑定到默认交换机上，绑定（binding）的路由键名称也是为”hello”。
因此，当携带着名为”hello”的路由键的消息被发送到默认交换机的时候，此消息会被默认交换机路由至名为”hello”的队列中
类似amq.*的名称的交换机：
这些是RabbitMQ默认创建的交换机。这些队列名称被预留做RabbitMQ内部使用，不能被应用使用，否则抛出403 (ACCESS_REFUSED)错误
7.2.6.Dead Letter Exchange（死信交换机）
在默认情况，如果消息在投递到交换机时，交换机发现此消息没有匹配的队列，则这个消息将被悄悄丢弃。
为了解决这个问题，RabbitMQ中有一种交换机叫死信交换机。当消费者不能处理接收到的消息时，将这个消息重新发布到另外一个队列中，
等待重试或者人工干预。这个过程中的exchange和queue就是所谓的”Dead Letter Exchange 和 Queue
7.3. 交换机的属性
除交换机类型外，在声明交换机时还可以附带许多其他的属性，其中最重要的几个分别是：
Name：交换机名称
Durability：是否持久化。如果持久性，则RabbitMQ重启后，交换机还存在
Auto-delete：当所有与之绑定的消息队列都完成了对此交换机的使用后，删掉它
Arguments：扩展参数
7.4. 综合案例：交换机的使用
rabbitmq02 #主模块
rabbitmq-provider #生产者
rabbitmq-consumer #消费者
7.4.0 给子模块添加依赖
7.4.1.直连交换机(Direct Exchange)
示例：
7.4.1.1.RabbitmqDirectConfig
/**
* 直接交换机配置类
*/
@Configuration
public class RabbitmqDirectConfig {
/**
* 定义队列
* @return
*/
@Bean
public Queue directQueue(){
return new Queue("direct-queue");
}
/**
* 定义直联交换机
* @return
*/
@Bean
public DirectExchange directExchange(){
return new DirectExchange("direct-exchange",true,false);
}
/**
* 将队列与交换机绑定，并设置路由键
* @return
*/
@Bean
public Binding binding(){
return BindingBuilder.bind(directQueue())
.to(directExchange())
.with("direct_routing_key");
}
}
7.4.1.2.SendController
@RestController
@RequestMapping("/send")
public class SendController {
@Autowired
private RabbitTemplate rabbitTemplate;
@RequestMapping("/directSend")
public Map directSend(){
Map json=new HashMap();
json.put("msg","OK");
json.put("code",200);
//获取发送消息
Map data=this.json("hello,rabbitmq!! this is a directExchange");
//将消息通过绑定建发送到直连交换机，再由之间交换机根据路由键的执行推送到指定队列
// 流程：生产者--》交换机--》队列《--》消费者
rabbitTemplate.convertAndSend("direct-exchange",
"direct_routing_key",data);
return json;
}
/**
* 消息发送的方法
* @param msg
* @return
*/
private Map json(String msg){
Map param=new HashMap<>();
param.put("msg",msg);
param.put("code",200);
param.put("date", LocalDateTime.now()
.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
return param;
}
}
关键代码：rabbitTemplate.convertAndSend("direct-exchange", "direct_routing_key",data);
sendDirectMessage：进行消息推送（也可以改为定时任务，具体看需求）
7.4.1.3.查看rabbitmq管理界面
我们目前还创建消费者rabbitmq-consumer，消息没有被消费的，我们去rabbitMq管理页面看看，是否推送成功
Overview选项卡，可以查看到刚刚创建的消息
7.4.1.4.创建消息接收监听类DirectReceiver
@Component
@RabbitListener(queues = {"direct-queue"})
public class DirectReceiver {
@RabbitHandler
public void handler(Map json){
System.out.println(json);
}
} 注1：新版jdk日期及格式化
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
注2：rabbitTemplate和amqpTemplate有什么关系
查看源码中会发现rabbitTemplate实现自amqpTemplate接口，两者使用起来并无区别，功能一致
注3：不要@Configuration写成了@Configurable，这两个长得很像
@Configuration该注解是可以用来替代XML文件。
手动new出来的对象，正常情况下，Spring是无法依赖注入的，这个时候可以使用@Configurable注解
7.4.2.主题交换机(Topic Exchange)
示例：
RabbitmqTopicConfig
@Configuration
public class RabbitmqTopicConfig {
@Bean
public Queue queueA(){
return new Queue("queue-a");
}
@Bean
public Queue queueB(){
return new Queue("queue-b");
}
@Bean
public Queue queueC(){
return new Queue("queue-c");
}
/**
* 定义主题交换机
* @return
*/
@Bean
public TopicExchange topicExchange(){
return new TopicExchange("topic-exchange",true,false);
}
@Bean
public Binding bindingA(){
return BindingBuilder.bind(queueA())
.to(topicExchange())
.with("topic.person.aa");
}
@Bean
public Binding bindingB(){
return BindingBuilder.bind(queueB())
.to(topicExchange())
.with("topic.person.bb");
}
@Bean
public Binding bindingC(){
return BindingBuilder.bind(queueC())
.to(topicExchange())
.with("topic.person.*");
}
}SendController：
@RestController
@RequestMapping("/send")
public class SendController {
@Autowired
private RabbitTemplate rabbitTemplate;
@RequestMapping("/topicSend")
public Map topicSend(String routingKey){
Map json=new HashMap();
json.put("msg","OK");
json.put("code",200);
//获取发送消息
Map data=this.json("hello,rabbitmq!! this is a directExchange");
//将消息通过绑定建发送到直连交换机，再由之间交换机根据路由键的执行推送到指定队列
// 流程：生产者--》交换机--》队列《--》消费者
rabbitTemplate.convertAndSend("topic-exchange",
routingKey,data);
return json;
}
/**
* 消息发送的方法
* @param msg
* @return
*/
private Map json(String msg){
Map param=new HashMap<>();
param.put("msg",msg);
param.put("code",200);
param.put("date", LocalDateTime.now()
.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
return param;
}
} TopicReceiver
@Component
public class TopicReceiver {
@RabbitListener(queues = {"queue-a"})
@RabbitHandler
public void handlerA(Map json){
System.out.println("已接收到队列queue-a"+json);
}
@RabbitListener(queues = {"queue-b"})
@RabbitHandler
public void handlerB(Map json){
System.out.println("已接收到队列queue-b"+json);
}
@RabbitListener(queues = {"queue-c"})
@RabbitHandler
public void handleCr(Map json){
System.out.println("已接收到队列queue-c"+json);
}
} 7.4.3.扇形交换机(Fanout Exchange)
//因为是扇型交换机, 路由键无需配置,配置也不起作用，两处地方均未配置路由键
BindingBuilder.bind(queueA()).to(fanoutExchange());
rabbitTemplate.convertAndSend(RabbitFanoutConfig.EXCHANGE_NAME,null, map);
示例：
RabbitmqFanoutConfig
@Configuration
public class RabbitmqFanoutConfig {
@Bean
public Queue queueX(){
return new Queue("queue-x");
}
@Bean
public Queue queueY(){
return new Queue("queue-y");
}
@Bean
public Queue queueZ(){
return new Queue("queue-z");
}
/**
* 定义扇形交换机
* @return
*/
@Bean
public FanoutExchange fanoutExchange(){
return new FanoutExchange("fanout-exchange",true,false);
}
@Bean
public Binding bindingX(){
return BindingBuilder.bind(queueX())
.to(fanoutExchange());
}
@Bean
public Binding bindingY(){
return BindingBuilder.bind(queueY())
.to(fanoutExchange());
}
@Bean
public Binding bindingZ(){
return BindingBuilder.bind(queueZ())
.to(fanoutExchange());
}
}SendController：
@RestController
@RequestMapping("/send")
public class SendController {
@Autowired
private RabbitTemplate rabbitTemplate;
@RequestMapping("/fanoutSend")
public Map fanoutSend(){
Map json=new HashMap();
json.put("msg","OK");
json.put("code",200);
//获取发送消息
Map data=this.json("hello,rabbitmq!! this is a directExchange");
//将消息通过绑定建发送到直连交换机，再由之间交换机群发的执行推送到队列，与路由器无关
// 流程：生产者--》交换机--》队列《--》消费者
rabbitTemplate.convertAndSend("fanout-exchange",
null,data);
return json;
}
/**
* 消息发送的方法
* @param msg
* @return
*/
private Map json(String msg){
Map param=new HashMap<>();
param.put("msg",msg);
param.put("code",200);
param.put("date", LocalDateTime.now()
.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
return param;
}
} FanoutReceiver
@Component
public class FanoutReceiver {
@RabbitListener(queues = {"queue-x"})
@RabbitHandler
public void handlerX(Map json){
System.out.println("已接收到队列queue-x"+json);
}
@RabbitListener(queues = {"queue-y"})
@RabbitHandler
public void handlerY(Map json){
System.out.println("已接收到队列queue-y"+json);
}
@RabbitListener(queues = {"queue-z"})
@RabbitHandler
public void handlerZ(Map json){
System.out.println("已接收到队列queue-z"+json);
}
} baibai~
上一章：RabbitMQ（01章）：MQ之RabbitMQ安装部署、springboot整合
下一章：RabbitMQ（03章）：RabbitMQ之延迟队列