RabbitMQ之交换机

已于 2023-04-06 10:54:12 修改
阅读量1.2w 收藏 51
点赞数 11
分类专栏： RabbitMQ 文章标签： rabbitmq 分布式 java
于 2022-02-27 16:13:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53151031/article/details/123140428
版权

目录

一、RabbitMQ交换机

1、交换机的由来

​

2、交换机类型​

2.1直连交换机（Direct  Exchange）

​2.2主题交换机（Topic  Exchange） 

​2.3扇形交换机（Fanout  Exchange）  ​

2.4首部交换机（Headers  Exchange）

2.5默认交换机（Default Exchange） 

二、RabbitMQ交换机实例讲解

        一、直连交换机讲解

                  1、先在生产者中创建一个直连交换机配置类

                  2、之后创建一个控制类，用来发信息

                  3、在消费者中定义好接受者

        二、主题交换机讲解

                  1、先在生产者中创建一个直连交换机配置类

                  2、之后创建一个控制类，用来发信息

                  3、在消费者中定义好接受者：

        三、扇形(广播)交换机讲解

                  1、先在生产者中创建一个直连交换机配置类

                  2、之后创建一个控制类，用来发信息

                  3、在消费者中定义好接受者：

一、RabbitMQ交换机

1、交换机的由来

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

在交换机诞生了两个概念

1、路由键：

 2、绑定键：

 3、两者中的关系

2、交换机类型

2.1直连交换机（Direct  Exchange）

如图所示：

2.2主题交换机（Topic  Exchange） 

2.3扇形交换机（Fanout  Exchange）  

2.4首部交换机（Headers  Exchange）

2.5默认交换机（Default Exchange） 

二、RabbitMQ交换机实例讲解

        一、直连交换机讲解

                  1、先在生产者中创建一个直连交换机配置类

DirectQueueConfig：生成队列，交换机，以及路由键，定义三个队列

package com.zj.provider;

import lombok.With;
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
@SuppressWarnings("all")
public class DirectQueueConfig {


    /**
     * 生成一个队列
     * @return
     */
    @Bean
    public Queue directQueueA(){
        return new Queue("directQueueA",true);
    }

    @Bean
    public Queue directQueueB(){
        return new Queue("directQueueB",true);
    }

    @Bean
    public Queue directQueueC(){
        return new Queue("directQueueC",true);
    }



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


    @Bean
    public Binding bindingA(){
        return BindingBuilder.bind(directQueueA()).to(directExchange()).with("AA");
    }

    @Bean
    public Binding bindingB(){
        return BindingBuilder.bind(directQueueB()).to(directExchange()).with("BB");
    }

    @Bean
    public Binding bindingC(){
        return BindingBuilder.bind(directQueueC()).to(directExchange()).with("CC");
    }





}

                  2、之后创建一个控制类，用来发信息

DirectController：其中rabbitTemplate用来发送信息辅助类

package com.zj.provider;


import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
@RequestMapping("/sendDirect")
@SuppressWarnings("all")
public class DirectController {

    @Autowired
    private RabbitTemplate rabbitTemplate;


    @RequestMapping("/sendDirect")
    public String sendDirect(String routerKey) {
        rabbitTemplate.convertAndSend("directExchange", routerKey, "Hello world");
        return "yes";
    }
}

                  3、在消费者中定义好接受者

DirectReciverA：再生成连个同样的类但是要注意的是必须要打@RabbitHandler和@RabbitListener(queues = "directQueueA")第一个是对队列处理者，第二个是队列的监听者，监听队列，不加第一个注解，消息将会接收不到
package com.zj.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@Slf4j
@RabbitListener(queues = "directQueueA")
public class DirectReciverA {



        @RabbitHandler
        public void process(String message){
            log.warn("A接收到了"+message);
        }


}

 结果运行成功：

        二、主题交换机讲解

                  1、先在生产者中创建一个直连交换机配置类

TopicQueueConfig：注意：这里面需要特定指定键

注意：必须在绑定键前加一个Topic来区分，必须介以区别，不然将会报错，因为加入了bean对象

package com.zj.provider.MQ;

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
@SuppressWarnings("all")
public class TopicQueueConfig {

    private final static String KEY_A="*.orange.*";
    private final static String KEY_B="*.*.rabbit";
    private final static String KEY_C="lazy.#";



    /**
     * 生成一个队列
     * @return
     */
    @Bean
    public Queue topicQueueA(){
        return new Queue("topicQueueA",true);
    }

    @Bean
    public Queue topicQueueB(){
        return new Queue("topicQueueB",true);
    }

    @Bean
    public Queue topicQueueC(){
        return new Queue("topicQueueC",true);
    }


    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topicExchange");
    }


    @Bean
    public Binding topicbindingA(){
        return BindingBuilder.bind(topicQueueA()).to(topicExchange()).with(KEY_A);
    }

    @Bean
    public Binding topicbindingB(){
        return BindingBuilder.bind(topicQueueB()).to(topicExchange()).with(KEY_B);
    }

    @Bean
    public Binding topicbindingC(){
        return BindingBuilder.bind(topicQueueC()).to(topicExchange()).with(KEY_C);
    }





}

                  2、之后创建一个控制类，用来发信息

  @RequestMapping("/sendTopic")
    public String sendTopic(String routerKey) {
        rabbitTemplate.convertAndSend("topicExchange", routerKey, "Hello world");
        return "yes";
    }

                  3、在消费者中定义好接受者：

package com.zj.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@Slf4j
@RabbitListener(queues = "topicQueueA")
public class TopicReciverA {



        @RabbitHandler
        public void process(String message){
            log.info("A接收到了"+message);
        }


}

注意：需要进行发信息才能在RabbitMQ发现队列

 显示出队列：

 接收成功：

        三、扇形(广播)交换机讲解

 扇形交换机和其他两个交换机不一样，扇形交换机不用绑定键，因为他会进行广播，同样的在队列与交换机进行绑定时，需要加上不同的名字来进行区分

                  1、先在生产者中创建一个直连交换机配置类

package com.zj.provider.MQ;

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;


@Configuration
@SuppressWarnings("all")
public class FanoutQueueConfig {


    /**
     * 生成一个队列
     * @return
     */
    @Bean
    public Queue fanoutQueueA(){
        return new Queue("fanoutQueueA",true);
    }

    @Bean
    public Queue fanoutQueueB(){
        return new Queue("fanoutQueueB",true);
    }

    @Bean
    public Queue fanoutQueueC(){
        return new Queue("fanoutQueueC",true);
    }



    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanoutExchange");
    }


    @Bean
    public Binding fanoutbindingA(){
        return BindingBuilder.bind(fanoutQueueA()).to(fanoutExchange());
    }

    @Bean
    public Binding fanoutbindingB(){
        return BindingBuilder.bind(fanoutQueueB()).to(fanoutExchange());
    }

    @Bean
    public Binding fanoutbindingC(){
        return BindingBuilder.bind(fanoutQueueC()).to(fanoutExchange());
    }

}

                  2、之后创建一个控制类，用来发信息

没有绑定键，但是要写空值，不然fanoutExchange会被认为是路由键
@RequestMapping("/sendFanout")
public String sendFanout() {
    rabbitTemplate.convertAndSend("fanoutExchange", "null" ,"Hello world");
    return "yes";
}

                  3、在消费者中定义好接受者：

package com.zj.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@Slf4j
@RabbitListener(queues = "fanoutQueueA")
public class FanoutReciverA {



        @RabbitHandler
        public void process(String message){
            log.info("A接收到了"+message);
        }


}

 生产者运行效果：

 消费者接收到信息

 今天的知识就分享到这了，希望能够帮助到你！ 

落日飞行
关注
专栏目录
02、RabbitMQ之交换机
qq_43469718的博客
12-24 359
一、 Exchange(交换机)的作用 在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列， 队列再将消息以推送或者拉取方式给消费者进行消费 创建消息 路由键 pull/push 生产者------------>交换机------------>队列------------...
【RabbitMQ】交换机详解看这一篇就够了
万维网连五洲，二进制写尽天下事，喜欢结识新伙伴寻找志同道合的朋友，欢迎一起探讨学习
01-22 8873
交换机（Exchange）是消息队列中的一个重要概念，用于实现消息的路由和分发。交换机接收发布到它的消息，并根据特定的规则将消息发送到一个或多个队列中。 在消息队列系统中，交换机起到了消息的分发中心的作用。它接收生产者发送的消息，并根据预定义的路由规则将消息发送到符合条件的队列中，然后由消费者从队列中获取并处理消息。
RabbitMQ创建交换机和队列——配置类 & 注解
最新发布
sdg_advance的博客
09-09 814
direct模式由于要绑定多个KEY，每一个Key都要编写一个binding，会非常麻烦，基于配置类适用与简单的情况，所以我们就可以基于注解来声明交换机、队列和绑定关系。：通配符订阅，与Direct类似，只不过RoutingKey可以使用通配符（# （一个或多个单词）和 * （一个单词））。步骤一：配置类中创建交换机和队列的Bean，并设置绑定关系，设置routingKey为sdg。：订阅，基于RoutingKey（路由key）发送给订阅了消息的队列。：头匹配，基于MQ的消息头匹配，用的较少。
RabbitMq中的交换机
weixin_30689307的博客
10-29 144
Rabbitmq的核心概念（如下图所示）：有虚拟主机、交换机、队列、绑定； 交换机可以理解成具有路由表的路由程序，仅此而已。每个消息都有一个称为路由键（routing key）的属性，就是一个简单的字符串。 最新版本的RabbitMQ有四种交换机类型，分别是Direct exchange、Fanout exchange、To...
RabbitMQ——交换机
风间琉璃の博客
03-08 2489
1. 交换机 exchange 不指定交换机直接发送到队列时，多个消费者之间存在的是竞争关系，一个消息只能被一个消费者接收，其他的消费者不能够再次接收；交换机可以绑定多个不同的队列，但是其Routingkkey是相同的，这样就可以从多个不同的队列发送相同的消息给多个消费者。 不指定交换机的情况，称为简单(工作)模式： 使用交换机的情况，称为发布、订阅模式： 在RabbitMQ中生产者不会讲消息直接发送到队列(不指定有默认交换机)；交换机接收来自生产者的消息并推送给队列。 交换机类型： dire
rabbitmq交换机
白鸽
07-15 1397
交换机 1、Exchange概念 RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。 相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。 1、Exchanges 的类型 直接(direct)
批量删除rabbitmq的队列或交换机
06-29
采用python编写的批量删除rabbitmq的队列或交换机。 1.修改rabbitmq_delete.py中rabbitmq的配置； 2.执行以下命令： 删除队列: python3 rabbitmq_delete.py -k ‘udata.climb’ -d 1 删除交换机: python3 rabbitmq_...
RabbitMQ（02章）：RabbitMQ之交换机（直联、主题、扇形）
weixin_61024320的博客
12-12 699
在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列， 队列再将消息以推送或者拉取方式给消费者进行消费 创建消息 路由键 pull/push 生产者------------>交换机------------>队列------------>消费者
RabbitMQ与交换机
weixin_66202611的博客
12-18 796
直连交换机是一种带路由功能的交换机，一个队列会和一个交换机绑定，除此之外再绑定一个routing_key，当消息被发送的时候，需要指定一个binding_key，这个消息被送达交换机的时候，就会被这个交换机送到指定的队列里面去。主题交换机的routing_key需要有一定的规则，交换机和队列的binding_key需要采用*.#.*.....的格式，每个部分用.分开，其中。因此，当携带着名为”hello”的路由键的消息被发送到默认交换机的时候，此消息会被默认交换机路由至名为”hello”的队列中。
RabbitMQ交换机详解
weixin_74268571的博客
01-25 2229
交换机（Exchange）是RabbitMQ中重要的概念之一，用于接收生产者发送的消息，并根据一定的规则将消息路由到相应的队列中。本文将详细介绍交换机的定义、作用、应用场景以及常见的交换机类型。交换机是计算机网络中的一种设备，用于连接多个计算机或其他网络设备，并根据目标设备的MAC地址将数据包从一个接口转发到另一个接口。它可以在局域网内部实现数据包的转发和通信功能，使得多台计算机能够快速、可靠地进行数据传输和交流。交换机是实现局域网的重要组成部分，被广泛应用于各种网络环境，包括家庭、办公室、数据中心等。
RabbitMq(四) -- 交换机（rabbitmq的工作模式）
weixin_39724194的博客
03-02 3233
1. 实现一个消息被消费2次 一个消息经过交换机之后，可以被交换机分发给2个不同的队列，不同的队列的消息被各自的消费者消费。 注意：一个队列中的消息只能被消费一次 2. 什么是交换机？ RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。 相反，生产者只能将消息发送到交换机 (exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息，
RabbitMQ交换器
寻常的博客
02-11 804
RabbitMQ交换器类型有fanout、direct、topic、headers fanout 它会把所有发送到该交换器的消息路由到所有与该交换器绑定的队列中。 direct 类型的交换器路由规则也很简单，它会把消息路由到那些 BindingKey和RoutingKey完全匹配的队列中。 topic direct 类型的交换器路由规则是完全匹配 BindingKey和RoutingKey ,但是这种严格的匹配方式在很多情况下不能满足实际业务的需求. topic 类型的交换器在匹配规则上进行了扩展，.
5. RabbitMQ之交换机
u010502101的博客
06-17 1051
交换机其实是一种routingKey，或者叫路由key，生产者生产的消息根据指定的key路由到指定的队列中。无名交换机其实也是一种direct交换机，在之前几篇文章中发布消息时一直采用下面的形式，第一个参数就表示无名交换机，也就是如果不送交换机默认采用的交换机。 从RabbitMQ管理端可以看无名交换机如下所示 就是说凡是生产者生产的消息没有指定交换机时，都会通过默认的交换机把消息投递到QUEUE_NAME队列中。Binding其实就是绑定exchange交换机与队列的关系，用来指明交换机绑定了哪个或哪些
RabbitMQ ---- 交换机
是微风，是晚霞，是无可替代
07-14 724
Fanout 这种类型非常简单。它接收到所有消息广播到它知道的所有队列中。系统中默认有些 exchange 类型上一节中的我们的日志系统将所有消息广播给所有消费者，对此我们想做一些改变，例如我们希望将日志消息写入磁盘的程序仅接收严重错误(errros)，而不存储哪些警告(warning)或信息(info)日志消息避免浪费磁盘空间。
rabbitMQ 交换机
TonyWu的博客
09-30 481
rabbitMq有四种类型的交换机fanout、direct、topic、headers 实际在RabbitMQ中，生产者将消息发送到Exchange（交换器，下图中的X），由Exchange将消息路由到一个或多个Queue中（或者丢弃）。 Exchange是按照什么逻辑将消息路由到Queue的？。 RabbitMQ中的Exchange有四种类型，不同的类型有着不同的路由策略，。有四种类型的...
RabbitMQ交换机
08-09
RabbitMQ交换机是消息中间件RabbitMQ中的一个重要组件。它用于接收生产者发送的消息，并将其路由到一个或多个绑定的队列中。交换机根据不同的路由规则来确定消息应该被发送到哪个队列。 RabbitMQ提供了不同类型的交换机，包括直连交换机（direct exchange）、主题交换机（topic exchange）、头交换机（headers exchange）和扇形交换机（fanout exchange）。每种类型的交换机都有不同的路由规则和使用场景。 直连交换机根据消息携带的路由键（routing key）将消息发送到与之完全匹配的队列中。主题交换机根据通配符的匹配规则将消息发送到匹配的队列中。头交换机则根据消息头部的键值对进行匹配，而扇形交换机则将消息广播到所有绑定的队列中。 交换机在消息传递过程中起着重要的作用，它能够实现灵活的消息路由和分发，帮助系统实现高效可靠的消息传递机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值