RabbitMq（三）Springboot 整合RabbitMq应用——Direct、Topic、Fanout的使用

我就是我 2023-07-24 14:38 146阅读 0赞

## 开发中一般使用的交换机，分三种 ##

1.Direct Exchange 根据route key 直接找到队列  
2.Topic Exchange 根据route key 匹配队列  
3.Topic Exchange 不处理route key 全网发送，所有绑定的队列都发送  
我们分2个springboot项目，一个 rabbitmq\_prov\_demo （生产者），一个rabbitmq\_cons\_demo（消费者）。

#### 少啰嗦先看东西 ####

## 一、Direct直报 ##

Direct Exchange是RabbitMQ默认的交换机模式，也是最简单的模式，根据key全文匹配去寻找队列。

Q1 绑定了一个 binding key 名字为 orange；

Q2 就有 2 个 binding key，名字为black和 green。

当消息中的 路由键 和 这个 binding key 对应上的时候，那么就知道了该消息去到哪一个队列中。

#### rabbitmq\_prov\_demo ####

application.yml

server:
      port: 8021
    string:
      application:
        name: rabbitmq_prov_demo
      rabbitmq:
       host: localhost
       port: 5672
       username: admin
       password: 123456
       #虚拟host 可以不设置,使用server默认host
       #virtual-host: IManiyHost

接着我们先使用下direct exchange(直连型交换机),创建DirectRabbitConfig.java

package com.example.rabbitmq_prov_demo;
    
    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;
    
    /**
     * @author liuzonghua
     * @Package com.example.rabbitmq_prov_demo
     * @Description: 接着我们先使用下direct exchange(直连型交换机)
     * @date 2020/4/12 14:01
     */
    @Configuration
    public class DirectRabbitConfig {
    
        //队列 起名：TestDirectQueue
        @Bean
        public Queue TestDirectQueue() {
            return new Queue("TestDirectQueue",true);  //true 是否持久
        }
    
        //Direct交换机 起名：TestDirectExchange
        @Bean
        DirectExchange TestDirectExchange() {
            return new DirectExchange("TestDirectExchange");
        }
    
        //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
        @Bean
        Binding bindingDirect() {
            return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
        }
    }

然后写个简单的接口进行消息推送（根据需求也可以改为定时任务等等，具体看需求）

import org.springframework.amqp.rabbit.core.RabbitTemplate;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.UUID;
    
    /**
     * @author liuzonghua
     * @Package com.example.rabbitmq_prov_demo
     * @Description: 写个简单的接口进行消息推送（根据需求也可以改为定时任务等等，具体看需求）
     * @date 2020/4/12 14:03
     */
    @RestController
    public class SendMessageController {
    
        @Autowired
        RabbitTemplate rabbitTemplate;  //使用RabbitTemplate,这提供了接收/发送等等方法
    
        @GetMapping("/sendDirectMessage")
        public String sendDirectMessage() {
            String messageId = String.valueOf(UUID.randomUUID());
            String messageData = "test message, hello!";
            String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            Map<String,Object> map=new HashMap<>();
            map.put("messageId",messageId);
            map.put("messageData",messageData);
            map.put("createTime",createTime);
            //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
            rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
            return "ok";
        }
    
    
    }

项目运行，调用下接口,就有一个消息在该队列中  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lNYW5peQ_size_16_color_FFFFFF_t_70]

#### rabbitmq\_cons\_demo消费者 ####

application.yml  
端口默认8080

String:
      application:
        name: rabbitmq_cons_demo
      rabbitmq:
       host: localhost
       port: 5672
       username: admin
       password: 123456

创建消息接收监听类,项目运行起来，可以看到把之前推送的那条消息消费下来了

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    
    /**
     * @author liuzonghua
     * @Package com.example.rabbitmq_cons_demo.direct
     * @Description: 创建消息接收监听类,项目运行起来，可以看到把之前推送的那条消息消费下来了
     * @date 2020/4/12 14:13
     */
    
    @Component
    @RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
    public class DirectReceiver {
    
        @RabbitHandler
        public void process(Map testMessage) {
            System.out.println("DirectReceiver消费者收到消息  : " + testMessage.toString());
        }
    
    }

也可以加上配置，让它也成为生产者，也能推送该消息

/**
     * @author liuzonghua
     * @Package com.example.rabbitmq_cons_demo.direct
     * @Description: 消费者单纯的使用，其实可以不用添加这个配置，直接建后面的监听就好，使用注解来让监听器监听对应的队列即可。
     * 配置上了的话，其实消费者也是生成者的身份，也能推送该消息。
     * @date 2020/4/12 14:09
     */
    @Configuration
    public class DirectRabbitConfig {
    
        //队列 起名：TestDirectQueue
        @Bean
        public Queue TestDirectQueue() {
            return new Queue("TestDirectQueue",true);
        }
    
        //Direct交换机 起名：TestDirectExchange
        @Bean
        DirectExchange TestDirectExchange() {
            return new DirectExchange("TestDirectExchange");
        }
    
        //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
        @Bean
        Binding bindingDirect() {
            return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
        }
    }

运行后如果队列有消息就会读出来

![在这里插入代码片](https://img-blog.csdnimg.cn/20200412144752659.png)

生产者再发送，也会立马读取到。

## Topic ##

Topic Exchange 转发消息主要是根据通配符。 在这种交换机下，队列和交换机的绑定会定义一种路由模式，那么，通配符就要在这种路由模式和路由键之间匹配后交换机才能转发消息。

在这种交换机模式下：

路由键必须是一串字符，用句号（.） 隔开，比如说 agreements.us，或者 agreements.eu.stockholm 等。  
路由模式必须包含一个 星号（*），主要用于匹配路由键指定位置的一个单词，比如说，一个路由模式是这样子：agreements…b.*，那么就只能匹配路由键是这样子的：第一个单词是 agreements，第四个单词是 b。 井号（\#）就表示相当于一个或者多个单词，例如一个匹配模式是agreements.eu.berlin.\#，那么，以agreements.eu.berlin开头的路由键都是可以的。

#### rabbitmq\_prov\_demo ####

package com.example.rabbitmq_prov_demo.topic;
    
    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;
    
    /**
     * @author liuzonghua
     * @Package com.example.rabbitmq_prov_demo.topic
     * @Description:
     * @date 2020/4/12 14:49
     */
    @Configuration
    public class TopicRabbitConfig {
        //绑定键
        public final static String man = "topic.man";
        public final static String woman = "topic.woman";
    
        @Bean
        public Queue firstQueue() {
            return new Queue(TopicRabbitConfig.man);
        }
    
        @Bean
        public Queue secondQueue() {
            return new Queue(TopicRabbitConfig.woman);
        }
    
        @Bean
        TopicExchange exchange() {
            return new TopicExchange("topicExchange");
        }
    
    
        //将firstQueue和topicExchange绑定,而且绑定的键值为topic.man
        //这样只要是消息携带的路由键是topic.man,才会分发到该队列
        @Bean
        Binding bindingExchangeMessage() {
            return BindingBuilder.bind(firstQueue()).to(exchange()).with(man);
        }
    
        //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
        // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
        @Bean
        Binding bindingExchangeMessage2() {
            return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
        }
    
    }

controller添加多2个接口，用于推送消息到主题交换机

@GetMapping("/sendTopicMessage1")
        public String sendTopicMessage1() {
            String messageId = String.valueOf(UUID.randomUUID());
            String messageData = "message: M A N ";
            String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            Map<String, Object> manMap = new HashMap<>();
            manMap.put("messageId", messageId);
            manMap.put("messageData", messageData);
            manMap.put("createTime", createTime);
            rabbitTemplate.convertAndSend("topicExchange", "topic.man", manMap);
            return "ok";
        }
    
        @GetMapping("/sendTopicMessage2")
        public String sendTopicMessage2() {
            String messageId = String.valueOf(UUID.randomUUID());
            String messageData = "message: woman is all ";
            String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            Map<String, Object> womanMap = new HashMap<>();
            womanMap.put("messageId", messageId);
            womanMap.put("messageData", messageData);
            womanMap.put("createTime", createTime);
            rabbitTemplate.convertAndSend("topicExchange", "topic.woman", womanMap);
            return "ok";
        }

#### rabbitmq\_cons\_demo ####

全部接受的

package com.example.rabbitmq_cons_demo.topic;
    
    import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    
    /**
     * @author liuzonghua
     * @Package com.example.rabbitmq_cons_demo.topic
     * @Description:
     * @date 2020/4/12 14:57
     */
    @Component
    @RabbitListener(queues = "topic.woman")
    public class TopicTotalReceiver {
    
        /*@RabbitHandler*/
        public void process(Map testMessage) {
            System.out.println("TopicTotalReceiver消费者收到消息  : " + testMessage.toString());
        }
    }

man接受

package com.example.rabbitmq_cons_demo.topic;
    
    import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    
    /**
     * @author liuzonghua
     * @Package com.example.rabbitmq_cons_demo.topic
     * @Description:
     * @date 2020/4/12 14:53
     */
    @Component
    @RabbitListener(queues = "topic.man")
    public class TopicManReceiver {
    
        @RabbitHandler
        public void process(Map testMessage) {
            System.out.println("TopicManReceiver消费者收到消息  : " + testMessage.toString());
        }
    }

然后看消费者rabbitmq-consumer的控制台输出情况：  
TopicManReceiver监听队列1，绑定键为：topic.man  
TopicTotalReceiver监听队列2，绑定键为：topic.\#  
调用接口/sendTopicMessage1:当推送的消息，携带的路由键为：topic.man  
全都成功消费到了消息  
![在这里插入图片描述][20200412153454414.png]  
调用接口/sendTopicMessage2:当推送的消息，携带的路由键为：topic.woman  
只有TopicTotalReceiver成功消费到了消息  
![在这里插入图片描述][20200412153603434.png]

## Fanout ##

不处理路由键。你只需要简单的将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。Fanout交换机转发消息是最快的。

发送消息，只需要指定交换机，route key 可以为空

#### rabbitmq\_prov\_demo ####

import org.springframework.amqp.core.Binding;
    import org.springframework.amqp.core.BindingBuilder;
    import org.springframework.amqp.core.FanoutExchange;
    import org.springframework.amqp.core.Queue;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * @author liuzonghua
     * @Package com.example.rabbitmq_prov_demo.fanout
     * @Description:
     * @date 2020/4/12 15:46
     */
    
    @Configuration
    public class FanoutRabbitConfig {
    
        /**
         *  创建三个队列 ：fanout.A   fanout.B  fanout.C
         *  将三个队列都绑定在交换机 fanoutExchange 上
         *  因为是扇型交换机, 路由键无需配置,配置也不起作用
         */
    
    
        @Bean
        public Queue queueA() {
            return new Queue("fanout.A");
        }
    
        @Bean
        public Queue queueB() {
            return new Queue("fanout.B");
        }
    
        @Bean
        public Queue queueC() {
            return new Queue("fanout.C");
        }
    
        @Bean
        FanoutExchange fanoutExchange() {
            return new FanoutExchange("fanoutExchange");
        }
    
        @Bean
        Binding bindingExchangeA() {
            return BindingBuilder.bind(queueA()).to(fanoutExchange());
        }
    
        @Bean
        Binding bindingExchangeB() {
            return BindingBuilder.bind(queueB()).to(fanoutExchange());
        }
    
        @Bean
        Binding bindingExchangeC() {
            return BindingBuilder.bind(queueC()).to(fanoutExchange());
        }
    }

controller

@GetMapping("/sendFanoutMessage")
        public String sendFanoutMessage() {
            String messageId = String.valueOf(UUID.randomUUID());
            String messageData = "message: testFanoutMessage ";
            String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            Map<String, Object> map = new HashMap<>();
            map.put("messageId", messageId);
            map.put("messageData", messageData);
            map.put("createTime", createTime);
            rabbitTemplate.convertAndSend("fanoutExchange", null, map);
            return "ok";
        }

#### rabbitmq\_cons\_demo ####

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    
    /**
     * @author liuzonghua
     * @Package com.example.rabbitmq_cons_demo.fanout
     * @Description:
     * @date 2020/4/12 15:50
     */
    @Component
    @RabbitListener(queues = "fanout.A")
    public class FanoutReceiverA {
    
        @RabbitHandler
        public void process(Map testMessage) {
            System.out.println("FanoutReceiverA消费者收到消息  : " +testMessage.toString());
        }
    
    }

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    
    /**
     * @author liuzonghua
     * @Package com.example.rabbitmq_cons_demo.fanout
     * @Description:
     * @date 2020/4/12 15:50
     */
    @Component
    @RabbitListener(queues = "fanout.B")
    public class FanoutReceiverB {
    
        @RabbitHandler
        public void process(Map testMessage) {
            System.out.println("FanoutReceiverB消费者收到消息  : " +testMessage.toString());
        }
    
    }

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    
    /**
     * @author liuzonghua
     * @Package com.example.rabbitmq_cons_demo.fanout
     * @Description:
     * @date 2020/4/12 15:50
     */
    @Component
    @RabbitListener(queues = "fanout.C")
    public class FanoutReceiverC {
    
        @RabbitHandler
        public void process(Map testMessage) {
            System.out.println("FanoutReceiverC消费者收到消息  : " +testMessage.toString());
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lNYW5peQ_size_16_color_FFFFFF_t_70]: /images/20230528/9fad84cbad894b66acce03bd8976de45.png
[20200412153454414.png]: /images/20230528/10642323e0af43de949d66dea5e3213e.png
[20200412153603434.png]: /images/20230528/473e4af4cf664f8ab1b0c17851fa127f.png