RabbitMQ 08 路由模式

路由模式

路由模式结构图：

1. 定义配置类。

   import org.springframework.amqp.core.Binding;
   import org.springframework.amqp.core.BindingBuilder;
   import org.springframework.amqp.core.Exchange;
   import org.springframework.amqp.core.ExchangeBuilder;
   import org.springframework.amqp.core.Queue;
   import org.springframework.beans.factory.annotation.Qualifier;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   
   /**
    * RabbitMQ配置类
    */
   @Configuration
   public class RabbitMqConfig {
   
       /**
        * 定义交换机，可以很多个
        * @return 交换机对象
        */
       @Bean
       public Exchange directExchange(){
           return ExchangeBuilder.directExchange("amq.direct").build();
       }
   
       /**
        * 定义消息队列
        * @return 消息队列对象
        */
       @Bean
       public Queue directQueue(){
           return new Queue("directQueue");
       }
   
       /**
        * 定义绑定关系
        * @return 绑定关系
        */
       @Bean
       public Binding binding1(@Qualifier("directExchange") Exchange exchange,
                               @Qualifier("directQueue") Queue queue){
           // 将定义的交换机和队列进行绑定
           return BindingBuilder
                   // 绑定队列
                   .bind(queue)
                   // 到交换机
                   .to(exchange)
                   // 使用自定义的routingKey
                   .with("test_springboot_key1")
                   // 不设置参数
                   .noargs();
       }
   
       /**
        * 定义绑定关系
        * @return 绑定关系
        */
       @Bean
       public Binding binding(@Qualifier("directExchange") Exchange exchange,
                              @Qualifier("directQueue") Queue queue){
           // 将定义的交换机和队列进行绑定
           return BindingBuilder
                   // 绑定队列
                   .bind(queue)
                   // 到交换机
                   .to(exchange)
                   // 使用自定义的routingKey
                   .with("test_springboot_key2")
                   // 不设置参数
                   .noargs();
       }
   }
   

2. 定义消费者。

   import org.springframework.amqp.rabbit.annotation.RabbitListener;
   import org.springframework.stereotype.Component;
   
   /**
    * 直连队列监听器
    */
   @Component
   public class DirectListener {
   
       /**
        * 监听直连队列消息
        */
       @RabbitListener(queues = "directQueue")
       public void receiver(String message) {
           System.out.println("直连队列接收到消息：" + message);
       }
   }
   

3. 定义生产者。

   import org.junit.jupiter.api.Test;
   import org.springframework.amqp.rabbit.core.RabbitTemplate;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.test.context.SpringBootTest;
   
   @SpringBootTest
   class RabbitMqSpringBootTests {
   
       /**
        * RabbitTemplate封装了大量的RabbitMQ操作，已经由Starter提供，因此直接注入使用即可
        */
       @Autowired
       private RabbitTemplate rabbitTemplate;
   
       /**
        * 生产者
        */
       @Test
       void producer()  {
   
           rabbitTemplate.convertAndSend("amq.direct", "test_springboot_key1", "Hello World");
           rabbitTemplate.convertAndSend("amq.direct", "test_springboot_key2", "Hello World");
       }
   
   }
   

4. 启动生产者，发送消息。

   

   可以看到，不同的routingKey都发送到了目标队列进行消费，这就是路由模式。

---

• 环境
  • JDK 17.0.6
  • Maven 3.6.3
  • SpringBoot 3.0.4
  • spring-boot-starter-amqp 3.0.4
• 参考
  • https://www.bilibili.com/video/BV1pe4y1W7ru?p=7&vd_source=299f4bc123b19e7d6f66fefd8f124a03