02、RabbitMQ交换机

曾经终败给现在 2024-03-31 15:37 42阅读 0赞

**目录**

1.、Exchange(交换机)的作用

2、Exchange(交换机)的类型

2.1.直连交换机：Direct Exchange

2.2.主题交换机：Topic Exchange

2.3.扇形交换机：Fanout Exchange

2.4.首部交换机：Headers exchange

2.5.默认交换机

2.6.Dead Letter Exchange（死信交换机）

3、交换机的属性

4、综合案例：交换机的使用

给子模块添加依赖

4.1.直连交换机(Direct Exchange)

4.2.主题交换机(Topic Exchange)

4.3.扇形交换机(Fanout Exchange)

以上就是今天的分享了

--------------------

## 1.、Exchange(交换机)的作用 ##

> 在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列，队列再将消息以推送或者拉取方式给消费者进行消费

创建消息 路由键 pull/push

生产者------------------------------->交换机--------------------------------->队列--------------------------->消费者

![35f3f60ec40847c7aaea3e1dc18df465.png][]

##  2、Exchange(交换机)的类型 ##

### 2.1.直连交换机：Direct Exchange ###

> 直连交换机是一种带路由功能的交换机，一个队列会和一个交换机绑定，除此之外再绑定一个routing\_key，当消息被发送的时候，需要指定一个binding\_key，这个消息被送达交换机的时候，就会被这个交换机送到指定的队列里面去。同样的一个binding\_key也是支持应用到多个队列中的。这样当一个交换机绑定多个队列，就会被送到对应的队列去处理。

> **注1**：什么是路由键  
> 每个消息都有一个称为路由键(routing key)的属性，它其实就是一个简单的字符串
> 
> **注2**：直连交换机适用场景  
> 有优先级的任务，根据任务的优先级把消息发送到对应的队列，这样可以指派更多的资源去处理高优先级的队列。

### 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将会收到

### 2.3.扇形交换机：Fanout Exchange ###

> 扇形交换机是最基本的交换机类型，它所能做的事情非常简单———广播消息。  
> 扇形交换机会把能接收到的消息全部发送给绑定在自己身上的队列。因为广播不需要“思考”，所以扇形交换机处理消息的速度也是所有的交换机类型里面最快的。
> 
> 这个交换机没有路由键概念，就算你绑了路由键也是无视的。

### 2.4.首部交换机：Headers exchange ###

### 2.5.默认交换机 ###

> 实际上是一个由RabbitMQ预先声明好的名字为空字符串的直连交换机（direct exchange）。它有一个特殊的属性使得它对于简单应用特别有用处：那就是每个新建队列（queue）都会自动绑定到默认交换机上，绑定的路由键（routing key）名称与队列名称相同。
> 
> 如：当你声明了一个名为”hello”的队列，RabbitMQ会自动将其绑定到默认交换机上，绑定（binding）的路由键名称也是为”hello”。  
> 因此，当携带着名为”hello”的路由键的消息被发送到默认交换机的时候，此消息会被默认交换机路由至名为”hello”的队列中

> 类似amq.\*的名称的交换机：  
> 这些是RabbitMQ默认创建的交换机。这些队列名称被预留做RabbitMQ内部使用，不能被应用使用，否则抛出403 (ACCESS\_REFUSED)错误

### 2.6.Dead Letter Exchange（死信交换机） ###

> 在默认情况，如果消息在投递到交换机时，交换机发现此消息没有匹配的队列，则这个消息将被悄悄丢弃。  
> 为了解决这个问题，RabbitMQ中有一种交换机叫死信交换机。当消费者不能处理接收到的消息时，将这个消息重新发布到另外一个队列中，等待重试或者人工干预。这个过程中的exchange和queue就是所谓的”Dead Letter Exchange 和 Queue

## 3、交换机的属性 ##

> 除交换机类型外，在声明交换机时还可以附带许多其他的属性，其中最重要的几个分别是：  
> Name：交换机名称  
> Durability：是否持久化。如果持久性，则RabbitMQ重启后，交换机还存在  
> Auto-delete：当所有与之绑定的消息队列都完成了对此交换机的使用后，删掉它  
> Arguments：扩展参数

## 4、综合案例：交换机的使用 ##

> rabbitmq02 \#主模块 maven  
> rabbitmq-provider \#生产者 springboot  
> rabbitmq-consumer \#消费者 springboot

![8701c59d334c4c2396dcc3862118eddd.png][]

### 给子模块添加依赖 ###

<dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-amqp</artifactId>
         </dependency>
         <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
         <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <optional>true</optional>
         </dependency>

### 4.1.直连交换机(Direct Exchange) ###

![7d2991fa02c34fcaaa8307e7257a3ad2.png][]

> 1.RabbitmqDirectConfig  
> 2.SendMessageController  
> 关键代码：rabbitTemplate.convertAndSend("testDirectExchange", "testDirectRouting", map);  
> sendDirectMessage：进行消息推送（也可以改为定时任务，具体看需求）  
>   
> 3.查看rabbitmq管理界面  
> 我们目前还创建消费者rabbitmq-consumer，消息没有被消费的，我们去rabbitMq管理页面看看，是否推送成功  
> Overview选项卡，可以查看到刚刚创建的消息  
> 4.创建消息接收监听类DirectReceiver

> 注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注解

![cdd294dbff0b47b3850c772c13769fd7.png][]

![0d9c7e793c2c4d6290691a931d5d2b4c.png][]

**生产者**

package com.zking.rabbitmqproduct.config;
    
    import org.springframework.amqp.core.Binding;
    import org.springframework.amqp.core.BindingBuilder;
    import org.springframework.amqp.core.DirectExchange;
    import org.springframework.amqp.core.Queue;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * 直连交换机
     */
    @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");
        }
    
    }

**消费者**

### 4.2.主题交换机(Topic Exchange) ###

> RabbitTopicConfig

**生产者**

package com.zking.rabbitmqproduct.config;
    
    import org.springframework.amqp.core.Binding;
    import org.springframework.amqp.core.BindingBuilder;
    import org.springframework.amqp.core.Queue;
    import org.springframework.amqp.core.TopicExchange;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @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.*");
        }
    }

**消费者**

package com.zking.rabbitmqconsumer.receiver;
    
    import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    
    @Component
    public class TopicReceiver {
    
        @RabbitListener(queues = {"queue-a"})
        @RabbitHandler
        public void handlerA(Map<String,Object> json){
            System.out.println("已接受到队列queue-a传递过来的消息："+json);
        }
    
        @RabbitListener(queues = {"queue-b"})
        @RabbitHandler
        public void handlerB(Map<String,Object> json){
            System.out.println("已接受到队列queue-b传递过来的消息："+json);
        }
    
        @RabbitListener(queues = {"queue-c"})
        @RabbitHandler
        public void handlerC(Map<String,Object> json){
            System.out.println("已接受到队列queue-c传递过来的消息："+json);
        }
    }

### 4.3.扇形交换机(Fanout Exchange) ###

//因为是扇型交换机, 路由键无需配置,配置也不起作用，两处地方均未配置路由键
         BindingBuilder.bind(queueA()).to(fanoutExchange()); 
         rabbitTemplate.convertAndSend(RabbitFanoutConfig.EXCHANGE_NAME,null, map);

**生产者**

package com.zking.rabbitmqproduct.config;
    
    import org.springframework.amqp.core.*;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @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());
        }
    }

**消费者**

package com.zking.rabbitmqconsumer.receiver;
    
    import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    
    @Component
    public class FanoutReceiver {
    
        @RabbitListener(queues = {"queue-x"})
        @RabbitHandler
        public void handlerY(Map<String,Object> json){
            System.out.println("已接受到队列queue-x传递过来的消息："+json);
        }
    
        @RabbitListener(queues = {"queue-y"})
        @RabbitHandler
        public void handlerX(Map<String,Object> json){
            System.out.println("已接受到队列queue-y传递过来的消息："+json);
        }
    
        @RabbitListener(queues = {"queue-z"})
        @RabbitHandler
        public void handlerZ(Map<String,Object> json){
            System.out.println("已接受到队列queue-z传递过来的消息："+json);
        }
    }

### 以上就是今天的分享了 ###

[35f3f60ec40847c7aaea3e1dc18df465.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/5cb1f25aff1848c592db23d8c18d1ec1.png
[8701c59d334c4c2396dcc3862118eddd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/1c57c9cf977f4c74a08927b7cdeec7a0.png
[7d2991fa02c34fcaaa8307e7257a3ad2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c7bdec867bf44bddbddaa5d1b1959b49.png
[cdd294dbff0b47b3850c772c13769fd7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/272f92690c87498891cfc53449383a0b.png
[0d9c7e793c2c4d6290691a931d5d2b4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/60f67f69f1a54637ac033e9b929a42b9.png