RabbitMQ之Direct（直连）Exchange解读

╰半橙微兮° 2023-10-16 15:02 3阅读 0赞

**目录**

基本介绍

使用场景

springboot代码演示

演示架构

工程概述

RabbitConfig配置类：创建队列及交换机并进行绑定

MessageService业务类：发送消息及接收消息

主启动类RabbitMq01Application：实现ApplicationRunner接口

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

### 基本介绍 ###

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

**路由键（Routingkey）**

生产者将信息发送给交换机的时候 会指定Routingkey指定路由规则

**绑定键（Bindingkey)**

通过绑定键将交换机与队列关联起来，这样rabbtamq就知道如何正确的将信息路由到队列

**Direct（直连）Exchange**

直连交换机的路由算法非常简单： 将消息推送到binding key与该消息的routing key相同的队列。

可以具体理解为：生产者想发送一条消息到指定的Queue队列中，首先这条消息会Exchange接收到，因为Exchange与queue是进行了绑定，这个绑定指定了RoutingKey(路由名称),这时候Exchange就会通过这个路由名称，来找到指定的Queue，然后将消息保存到Queue中 这就是直连交换机

> 直连交换机的 routing\_key方案非常简单 ，如果我们希望一 条消息发送给多个队列 ，那么这个交换机需 要绑定上非常多的 routing\_key. 假设每个交换机上都绑定一堆的 routing\_key连接到各个队列上。那么消息的管理 就会异常地困难。 可以使用Topic交换机解决这个问题

### 使用场景 ###

适用场景：当消费端出现比较挑剔的消费者时，这时候就需要用到direct类型了，路由模式需要使用此交换机。

> Direct模式常用于一对一的场景，例如订单管理系统中将订单分配给特定的处理队列。
> 
> 通过使用Exchange和Routing Key来进行消息传输，Direct模式实现了消息的有选择性地路由，提高了消息传输的效率，减少了系统负载。

### springboot代码演示 ###

#### 演示架构 ####

![b4c8872c6055487198a6b65069ed897a.png][]

> 生产者发送消息道direct交换机上面，队列A和队列B绑定一个direct交换机，对于队列a来说，它绑定的key为error，对于队列b来说，它绑定的key为info

#### 工程概述 ####

工程采用springboot架构，主要用到的依赖为：

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

application.yml配置文件如下：

server:
      port: 8080
    spring:
      rabbitmq:
        host: 123.249.70.148
        port: 5673
        username: admin
        password: 123456
        virtual-host: /

#### RabbitConfig配置类：创建队列及交换机并进行绑定 ####

**创建 RabbitConfig类，这是一个配置类**

@Component
    @Slf4j
    public class MessageService {
        @Resource
        private RabbitTemplate rabbitTemplate;
    
    }

**定义交换机**

@Bean
        public DirectExchange directExchange(){
            return new DirectExchange("exchange.direct");
        }

**定义队列**

@Bean
        public Queue queueA(){
            return new Queue("queue.direct.a");
        }
    
        @Bean
        public Queue queueB(){
            return new Queue("queue.direct.b");
        }

**绑定交换机和队列**

@Bean
        public Binding bindingA(DirectExchange directExchange,Queue queueA){
            return BindingBuilder.bind(queueA).to(directExchange).with("error");
        }
    
    
        @Bean
        public Binding bindingB(DirectExchange directExchange,Queue queueB){
            return BindingBuilder.bind(queueB).to(directExchange).with("info");
        }

#### MessageService业务类：发送消息及接收消息 ####

@Component
    @Slf4j
    public class MessageService {
    
    }

**发送消息方法**

public void sendMsg(){
            String msg="hello world";
            Message message=new Message(msg.getBytes(StandardCharsets.UTF_8));
            rabbitTemplate.convertAndSend("exchange.direct","info",message);
            log.info("消息发送完毕....");
        }

> 这里用的路由key为info

> **MessageConvert**
> 
>  *  涉及网络传输的应用序列化不可避免，发送端以某种规则将消息转成 byte 数组进行发送，接收端则以约定的规则进行 byte\[\] 数组的解析
>  *  RabbitMQ 的序列化是指 `Message` 的 `body` 属性，即我们真正需要传输的内容，**RabbitMQ 抽象出一个 MessageConvert 接口处理消息的序列化**，其实现有 `SimpleMessageConverter`（**默认**）、`Jackson2JsonMessageConverter` 等

**接受消息**

@RabbitListener(queues = {"queue.direct.a","queue.direct.b"})
        public void receiveMsg(Message message){
            byte[] body = message.getBody();
            String queue = message.getMessageProperties().getConsumerQueue();
            String msg=new String(body);
            log.info(queue+"接收到消息:"+msg);
        }

>  **Message**
> 
> 在消息传递的过程中，实际上传递的对象为 `org.springframework.amqp.core.Message` ，它主要由两部分组成：
> 
> 1.  **MessageProperties** // 消息属性
> 2.  **byte\[\] body** // 消息内容

> **@RabbitListener**
> 
> 使用 @RabbitListener 注解标记方法，当监听到队列 debug 中有消息时则会进行接收并处理
> 
>  *  消息处理方法参数是由 MessageConverter 转化，若使用自定义 MessageConverter 则需要在 RabbitListenerContainerFactory 实例中去设置（默认 Spring 使用的实现是 SimpleRabbitListenerContainerFactory）
>  *  消息的 content\_type 属性表示消息 body 数据以什么数据格式存储，接收消息除了使用 Message 对象接收消息（包含消息属性等信息）之外，还可直接使用对应类型接收消息 body 内容，但若方法参数类型不正确会抛异常：
>     
>      *  **application/octet-stream**：二进制字节数组存储，使用 byte\[\]
>      *  **application/x-java-serialized-object**：java 对象序列化格式存储，使用 Object、相应类型（反序列化时类型应该同包同名，否者会抛出找不到类异常）
>      *  **text/plain**：文本数据类型存储，使用 String
>      *  **application/json**：JSON 格式，使用 Object、相应类型

#### 主启动类RabbitMq01Application：实现ApplicationRunner接口 ####

/**
     * @author 风轻云淡
     */
    @SpringBootApplication
    public class RabbitMq01Application implements ApplicationRunner {
    
        public static void main(String[] args) {
            SpringApplication.run(RabbitMq01Application.class, args);
        }
    
        @Resource
        private MessageService messageService;
    
        /**
         * 程序一启动就会调用该方法
         * @param args
         * @throws Exception
         */
        @Override
        public void run(ApplicationArguments args) throws Exception {
            messageService.sendMsg();
    
        }
    }

> 在SpringBoot中，提供了一个接口：ApplicationRunner。 该接口中，只有一个run方法，他执行的时机是：spring容器启动完成之后，就会紧接着执行这个接口实现类的run方法。
> 
> 由于该方法是在容器启动完成之后，才执行的，所以，这里可以从spring容器中拿到其他已经注入的bean。

启动主启动类后查看控制台：

2023-09-26 20:36:44.517  INFO 53616 --- [           main] 
    c.e.rabbitmq01.service.MessageService    : 消息发送完毕....
    2023-09-26 20:36:44.574  INFO 53616 --- [ntContainer#0-1]
    c.e.rabbitmq01.service.MessageService    : queue.direct.b接收到消息:hello world

[b4c8872c6055487198a6b65069ed897a.png]: https://img-blog.csdnimg.cn/b4c8872c6055487198a6b65069ed897a.png