RabbitMQ 08 routing mode

routing mode

Routing mode structure diagram:

1. Define configuration classes.

   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. Define consumers.

   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. Define producer.

   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. Start the producer and send messages.

   

   It can be seen that different routingKeys are sent to the target queue for consumption. This is the routing mode.

---

• environment
  • JDK 17.0.6
  • Maven 3.6.3
  • SpringBoot 3.0.4
  • spring-boot-starter-amqp 3.0.4
• reference
  • Publish, subscribe and route mode_bilibili_bilibili