RabbitMQ中交换机的应用 ,原理 ,案例的实现

这篇具有很好参考价值的文章主要介绍了RabbitMQ中交换机的应用 ,原理 ,案例的实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

                                🎉🎉欢迎来到我的CSDN主页!🎉🎉

                    🏅我是平顶山大师,一个在CSDN分享笔记的博主。📚📚

    🌟推荐给大家我的博客专栏《RabbitMQ中交换机的应用及原理,案例的实现》。🎯🎯

                    🎁如果感觉还不错的话请给我关注加三连吧!🎁🎁

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

目录

一、RabbitMQ中交换机的介绍

1.基本概念

1.1. 概述

1.2.RabbitMQ交换机类型

2. 作用及优势

2.1 作用

 2.2 优势

3. 工作原理

二、交换机Exchange

1. Direct 

2. Topic

3. Fanout

三、代码案例

1. 直连direct 

生产者代码

消费者代码:

直连测试:

2.Topic

生产者代码

测试

3. 扇形fanout 

生产者代码

测试

总结:


一、RabbitMQ中交换机的介绍

1.基本概念


1.1. 概述

RabbitMQ中的交换机(exchange)是消息的分发中心,它接收来自生产者的消息,并将这些消息路由到一个或多个队列中。交换机根据消息的路由键(routing key)将消息发送到相应的队列中。

1.2.RabbitMQ交换机类型

RabbitMQ一共四种交换机,如下所示:

直连交换机(direct exchange):直连交换机根据消息的路由键将消息发送到与之匹配的队列中。如果消息的路由键与队列的绑定键(binding key)完全匹配,那么消息将被发送到该队列中。

主题交换机(topic exchange):主题交换机根据消息的路由键和队列的绑定键的模式进行匹配。可以使用通配符(*和#)来匹配多个路由键,从而实现更灵活的消息路由。符号#表示一个或多个词,*表示一个词。

扇形交换机(fanout exchange):扇出交换机将消息发送到所有与之绑定的队列中,无论消息的路由键是什么。它实现了一对多的消息分发。

头部交换机(headers exchange):头部交换机根据消息的头部信息进行匹配,而不是路由键。可以根据消息的头部属性来决定消息的路由。

交换机和队列之间通过绑定(binding)进行关联,生产者将消息发送到交换机,交换机根据路由键将消息发送到相应的队列中。交换机和队列的绑定关系可以通过管理界面或者命令行工具进行配置。交换机它负责将消息路由到相应的队列中,实现了灵活的消息分发机制。不同类型的交换机可以满足不同的业务需求,开发者可以根据实际情况选择合适的交换机类型来实现消息的路由和分发。

2. 作用及优势


2.1 作用

交换机在项目中的主要作用包括:

       1. 消息路由:交换机负责将消息路由到一个或多个队列中,根据消息的路由键和交换机的类型进行匹配和分发,确保消息能够准确地到达目标队列。

       2. 消息分发:交换机可以根据不同的规则将消息分发到不同的队列中,实现灵活的消息分发机制。这对于实现消息的多播、广播等场景非常有用。

       3. 解耦:通过交换机,生产者和消费者之间可以完全解耦,生产者只需要将消息发送到交换机中,而不需要关心消息具体发送到哪个队列中,消费者也只需要从队列中接收消息,而不需要关心消息的来源。

        4. 消息过滤:通过不同类型的交换机和绑定规则,可以实现消息的过滤和选择性接收,确保消费者只接收到其关心的消息。

        5. 实现消息通道:交换机是消息在RabbitMQ中的通道,通过交换机可以将消息从生产者传递给消费者,实现了消息的传递和通信。

交换机在项目中起到了消息路由、分发、解耦和过滤等重要作用,是实现消息传递和通信的关键组件。通过合理使用不同类型的交换机,可以实现灵活、高效的消息传递机制,满足不同业务场景的需求。

 2.2 优势

交换机在消息传递系统中具有以下优势:

        1. 灵活的消息路由:交换机可以根据消息的路由键将消息发送到不同的队列中,实现了灵活的消息路由机制。这样可以根据消息的不同属性将消息发送到不同的消费者或处理逻辑中,提高了系统的灵活性和可扩展性。

        2. 解耦和分布式系统支持:通过交换机,生产者和消费者之间可以完全解耦,生产者只需要将消息发送到交换机中,而不需要关心消息具体发送到哪个队列中,消费者也只需要从队列中接收消息,而不需要关心消息的来源。这对于构建分布式系统和微服务架构非常有用。

        3. 多播和广播支持:通过扇出交换机(fanout exchange),交换机可以将消息发送到所有与之绑定的队列中,实现了一对多的消息分发,支持了多播和广播的消息传递方式。

        4. 消息过滤和选择性接收:通过不同类型的交换机和绑定规则,可以实现消息的过滤和选择性接收,确保消费者只接收到其关心的消息,提高了系统的效率和性能。

        5. 实现消息通道:交换机是消息在消息队列系统中的通道,通过交换机可以将消息从生产者传递给消费者,实现了消息的传递和通信,为系统中的消息传递提供了可靠的通道。

总的来说,交换机在消息传递系统中具有灵活的消息路由、解耦和分布式系统支持、多播和广播支持、消息过滤和选择性接收等优势,为构建高效、灵活的消息传递系统提供了重要的支持。        

3. 工作原理

RabbitMQ的交换机(Exchange)是消息路由的核心组件,负责消息的分发和路由。下面是RabbitMQ交换机的工作原理:

       1. 发布消息:生产者将消息发送到RabbitMQ的交换机中,同时指定一个路由键(Routing Key)。

       2. 交换机根据类型进行路由:RabbitMQ的交换机有四种类型,分别是直连交换机(direct exchange)、扇出交换机(fanout exchange)、主题交换机(topic exchange)和头部交换机(headers exchange)。不同类型的交换机根据不同的路由规则进行消息的路由和分发。

       3. 路由规则:直连交换机根据消息的路由键将消息发送到与之绑定的队列中;扇出交换机将消息发送到所有与之绑定的队列中;主题交换机根据消息的路由键和队列的绑定规则进行匹配,将消息发送到匹配的队列中;头部交换机根据消息的头部属性进行匹配,将消息发送到匹配的队列中。

       4. 绑定队列:交换机需要和队列进行绑定,指定绑定的路由键或者其他条件,确保消息能够被正确地路由到目标队列中。

       5. 发送到队列:一旦消息被交换机路由到目标队列,消费者就可以从队列中接收并处理消息。

总的来说,RabbitMQ的交换机根据不同的类型和路由规则,将消息发送到目标队列中,实现了消息的路由和分发。通过合理使用不同类型的交换机和绑定规则,可以实现灵活、高效的消息传递机制,满足不同业务场景的需求。

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

二、交换机Exchange

1. Direct 

 直连交换机(Direct Exchange)是RabbitMQ中最简单的交换机类型之一,它使用消息的路由键(Routing Key)来决定将消息发送到哪个队列。

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

 

2. Topic


主题交换机(Topic Exchange)是RabbitMQ中一种灵活且强大的交换机类型,它使用消息的路由键和通配符模式来决定将消息发送到哪个队列。Queue 通过 routingkey 绑定到TopicExchange 上,当消息到达 TopicExchange 后,TopicExchange 根据消息的 routingkey 将消息路由到一个或者多个 Queue 上。

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

3. Fanout


扇形交换机是RabbitMQ中的一种消息路由方式,FanoutExchange 的数据交换策略是把所有到达 FanoutExchange 的消息转发给所有与它绑定的 Queue 上,在这种策略中,routingkey 将不起任何作用,不管消息的路由键是什么。

进入RabbitMQ的管理页面:

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

这里会展示交换机的各种信息:

Type 表示交换机的类型。

Features 有两个取值 D 和 I。

D 表示交换机持久化,将交换机的属性在服务器内部保存,当 MQ 的服务器发生意外或关闭之后,重启 RabbitMQ 时不需要重新手动或执行代码去建立交换机,交换机会自动建立,相当于一直存在。

I 表示这个交换机不可以被消息生产者用来推送消息,仅用来进行交换机和交换机之间的绑定。

Message rate in 表示消息进入的速率。 Message rate out 表示消息出去的速率。

点击下方的 Add a new exchange 可以创建一个新的交换机。

三、代码案例

如果你掌握了上一篇博客的基础上,再来写这一次的案例,就是soeasy

3.1开启docker服务

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

登录:

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

1. 直连direct 

生产者代码

        在生产者项目中的RabbitConfig中增加以下代码:

 /**
     * 直连交换机
     * /
     * 创建两个Binding Bean,分别与Queue01和Queue02队列进行绑定
     * 并都指向directExchange01(直连交换机),键分别为Key01和Key02
     */
    //  创建队列
    @Bean
    public Queue Queue01() {
        return new Queue("Queue01");
    }
    @Bean
    public Queue Queue02() {
        return new Queue("Queue02");
    }
 
    // 创建直连(direct)交换机
    @Bean
    public DirectExchange directExchange01() {
        return new DirectExchange("directExchange01");
    }
 
    // 创建Binding Bean,与Queue01和directExchange01绑定,键为Key01
    @Bean
    public Binding binding01() {
        return BindingBuilder
                .bind(Queue01())
                .to(directExchange01())
                .with("Key01");
    }
 
    // 创建Binding Bean,与Queue02和directExchange01绑定,键为Key02
    @Bean
    public Binding binding02() {
        return BindingBuilder
                .bind(Queue02())
                .to(directExchange01())
                .with("Key02");
    }

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

        在生产者项目中的TestController中增加以下代码:

//    -------------------------直连------------------------------------

    @RequestMapping("sender3")
    @ResponseBody
    public String sender3() {
        // 发送消息到名为directExchange01的交换机,路由键为key01,信息内容为:Hello, direct exchange!
        // 这里的directExchange01是RabbitMQ中定义的交换机名称
        // 这里的key01是RabbitMQ中定义的路由键名称
        rabbitTemplate.convertAndSend("directExchange01","Key01", "Hello, direct exchange!");
        return "👍3";
    }

    @RequestMapping("sender4")
    @ResponseBody
    public String sender4() {
        // 发送消息到名为directExchange01的交换机,路由键为key02,信息内容为:Hello, direct exchange!
        // 这里的directExchange01是RabbitMQ中定义的交换机名称
        // 这里的key02是RabbitMQ中定义的路由键名称
        rabbitTemplate.convertAndSend("directExchange01","Key02", "Hello, direct exchange!");
        return "😘4";
    }
消费者代码:

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

        ReceiverQ1接收交换机中Queue01队列消息的方法:

package com.example.consumer;
 
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 = "Queue01")
public class ReceiverQ1 {
 
        // 接收directExchange01交换机中Queue01队列消息的方法
        @RabbitHandler
        public void Queue01(String msg) {
            log.warn("Queue01,接收到信息:" + msg);
        }
 
}

        ReceiverQ2接收交换机中Queue02队列消息的方法

package com.example.consumer;
 
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 = "Queue02")
public class ReceiverQ2 {
 
        // 接收directExchange01交换机中Queue02队列消息的方法
        @RabbitHandler
        public void Queue02(String msg) {
            log.warn("Queue02,接收到信息:" + msg);
        }
 
}

这里在备注一下;生产者根据key来找对应的消息队列
RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

直连测试:

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件
 

2.Topic

生产者代码

        RabbitConfig中增加以下代码:

 /**
     * 主题交换机
     *
     *  '*'代表一个单词,
     *  '#'代表任意数量的字符,也代表0个或多个
     */
    // 创建主题交换机
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange("topicExchange");
    }
    @Bean
    public Binding binding03() {
        return BindingBuilder
                .bind(Queue01())
                .to(topicExchange())
                .with("*.*.Q1");
    }
    @Bean
    public Binding binding04() {
        return BindingBuilder
                .bind(Queue02())
                .to(topicExchange())
                .with("*.*.Q2");
    }
    @Bean
    public Binding binding05() {
        return BindingBuilder
                .bind(Queue01())
                .to(topicExchange())
                .with("平顶山大师.#");
    }
    @Bean
    public Binding binding06() {
        return BindingBuilder
                .bind(Queue02())
                .to(topicExchange())
                .with("平顶山大师.#");
    }

        TestController中增加以下代码:

 //    -------------------------主题topic ------------------------------------

    @RequestMapping("sender5")
    @ResponseBody
    public String test05(String rex) {
        rabbitTemplate.convertAndSend("topicExchange",rex,"Hello,topicExchange:Queue!");
        return "🎈5";
    }

    @RequestMapping("sender6")
    @ResponseBody
    public String test06() {
        rabbitTemplate.convertAndSend("fanoutExchange","","Hello,fanoutExchange:Queue!");
        return "💕6";
    }
测试

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

3. 扇形fanout 

生产者代码

RabbitConfig中增加以下代码:

    /**
     * 扇形交换机
     *
     * 定义了一个FanoutExchange,加上Bean注解
     * 定义了两个Binding,加上Bean注解
     * 将两个队列绑定到FanoutExchange上,从而实现广播消息的功能
     * 扇形交换机会将接收到的消息路由到所有绑定到它上的队列。
     */
    // 创建扇形交换机
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    @Bean
    public Binding binding07() {
        return BindingBuilder
                .bind(Queue01())
                .to(fanoutExchange());
    }
    @Bean
    public Binding binding08() {
        return BindingBuilder
                .bind(Queue02())
                .to(fanoutExchange());
    }

TestController中增加以下代码:

    @RequestMapping("sender6")
    @ResponseBody
    public String test06() {
        rabbitTemplate.convertAndSend("fanoutExchange","","Hello,fanoutExchange:Queue!");
        return "💕6";
    }

这里会直接发送到Q1,Q2

测试

RabbitMQ中交换机的应用 ,原理 ,案例的实现,RabbitMQ,网络,中间件

全部代码:

RabbitConfig:

package com.example.provide;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@SuppressWarnings("all")
public class RabbitConfig {
    @Bean
    public Queue firstQueue() {
        return new Queue("firstQueue");
    }

    @Bean
    public Queue secondQueue() {
        return new Queue("secondQueue");
    }

//   RabbitConfigII
    /**
     * 直连交换机
     * /
     * 创建两个Binding Bean,分别与Queue01和Queue02队列进行绑定
     * 并都指向directExchange01(直连交换机),键分别为Key01和Key02
     */
    //  创建队列
    @Bean
    public Queue Queue01() {
        return new Queue("Queue01");
    }
    @Bean
    public Queue Queue02() {
        return new Queue("Queue02");
    }

    // 创建直连(direct)交换机
    @Bean
    public DirectExchange directExchange01() {
        return new DirectExchange("directExchange01");
    }

    // 创建Binding Bean,与Queue01和directExchange01绑定,键为Key01
    @Bean
    public Binding binding01() {
        return BindingBuilder
                .bind(Queue01())
                .to(directExchange01())
                .with("Key01");
    }

    // 创建Binding Bean,与Queue02和directExchange01绑定,键为Key02
    @Bean
    public Binding binding02() {
        return BindingBuilder
                .bind(Queue02())
                .to(directExchange01())
                .with("Key02");
    }

    /**
     * 主题交换机
     *
     *  '*'代表一个单词,
     *  '#'代表任意数量的字符,也代表0个或多个
     */
    // 创建主题交换机
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange("topicExchange");
    }
    @Bean
    public Binding binding03() {
        return BindingBuilder
                .bind(Queue01())
                .to(topicExchange())
                .with("*.*.Q1");
    }
    @Bean
    public Binding binding04() {
        return BindingBuilder
                .bind(Queue02())
                .to(topicExchange())
                .with("*.*.Q2");
    }
    @Bean
    public Binding binding05() {
        return BindingBuilder
                .bind(Queue01())
                .to(topicExchange())
                .with("平顶山大师.#");
    }
    @Bean
    public Binding binding06() {
        return BindingBuilder
                .bind(Queue02())
                .to(topicExchange())
                .with("平顶山大师.#");
    }

    /**
     * 扇形交换机
     *
     * 定义了一个FanoutExchange,加上Bean注解
     * 定义了两个Binding,加上Bean注解
     * 将两个队列绑定到FanoutExchange上,从而实现广播消息的功能
     * 扇形交换机会将接收到的消息路由到所有绑定到它上的队列。
     */
    // 创建扇形交换机
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    @Bean
    public Binding binding07() {
        return BindingBuilder
                .bind(Queue01())
                .to(fanoutExchange());
    }
    @Bean
    public Binding binding08() {
        return BindingBuilder
                .bind(Queue02())
                .to(fanoutExchange());
    }
}

TestController:

package com.example.provide;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author 程序猿-小李哥
 * @site www.xiaolige.com
 * @company 猪八戒有限集团
 * @create 2024-01-19-18:46
 */
@Controller
public class Testcontrol {
    @Autowired
    private AmqpTemplate rabbitTemplate;
    @Autowired
    private ObjectMapper objectMapper;

    @RequestMapping("/sender1")
    @ResponseBody
    public String sendFirst() {
        rabbitTemplate.convertAndSend("firstQueue", "Hello World");
        return "😶‍🌫️1";
    }

    @RequestMapping("/sender2")
    @ResponseBody
    public String sender2() throws JsonProcessingException {
        User user = new User("1", "1");
        // 序列化对象转换为JSON字符串
        String json = objectMapper.writeValueAsString(user);
        rabbitTemplate.convertAndSend("secondQueue", json);
        return "😎2";
    }

//    -------------------------直连------------------------------------

    @RequestMapping("sender3")
    @ResponseBody
    public String sender3() {
        // 发送消息到名为directExchange01的交换机,路由键为key01,信息内容为:Hello, direct exchange!
        // 这里的directExchange01是RabbitMQ中定义的交换机名称
        // 这里的key01是RabbitMQ中定义的路由键名称
        rabbitTemplate.convertAndSend("directExchange01","Key01", "Hello, direct exchange!");
        return "👍3";
    }

    @RequestMapping("sender4")
    @ResponseBody
    public String sender4() {
        // 发送消息到名为directExchange01的交换机,路由键为key02,信息内容为:Hello, direct exchange!
        // 这里的directExchange01是RabbitMQ中定义的交换机名称
        // 这里的key02是RabbitMQ中定义的路由键名称
        rabbitTemplate.convertAndSend("directExchange01","Key02", "Hello, direct exchange!");
        return "😘4";
    }

    //    -------------------------主题topic ------------------------------------

    @RequestMapping("sender5")
    @ResponseBody
    public String test05(String rex) {
        rabbitTemplate.convertAndSend("topicExchange",rex,"Hello,topicExchange:Queue!");
        return "🎈5";
    }

    @RequestMapping("sender6")
    @ResponseBody
    public String test06() {
        rabbitTemplate.convertAndSend("fanoutExchange","","Hello,fanoutExchange:Queue!");
        return "💕6";
    }

}

总结:

问题:为啥要使用RabbitMQ中交换机???

  1. 消息路由:交换机用于将消息从生产者发送到消费者之间建立起路由规则。它可以根据不同的路由键(routing key)将消息传递给不同的队列或者其他交换机,实现灵活的消息传递方式。

  2. 解耦和扩展性:通过使用交换机,生产者和消费者之间可以解耦。生产者只需要将消息发送到交换机上,并不需要关心具体的消费者。消费者可以根据自己的需求,绑定到交换机上接收特定类型的消息,这样可以实现系统的灵活扩展和升级。

  3. 发布-订阅模式:交换机支持发布-订阅模式,可以将消息广播给多个消费者。当多个消费者同时绑定到同一个交换机上时,交换机会将消息复制并传递给所有绑定的队列,实现消息的多播。文章来源地址https://www.toymoban.com/news/detail-821233.html

到了这里,关于RabbitMQ中交换机的应用 ,原理 ,案例的实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • SpringBoot实现RabbitMQ的通配符交换机(SpringAMQP 实现Topic交换机)

    Topic 类型的 Exchange 与 Direct 相比,都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型 Exchange 可以让队列在绑定 Routing key 的时候使用通配符! Routingkey 一般都是有一个或多个单词组成,多个单词之间以”.”分割,例如: snow.com 通配符规则: # :匹配一个或多

    2024年04月12日
    浏览(48)
  • 网络_TCP/IP_第五章_交换机的基本原理与配置_实验案例一:交换机的初始配置

    实验用具包括一台Cisco交换机,一台PC,一根Console线缆。 如图5.17所示,实验案例一的配置需求如下。 通过PC连接并配置一台Cisco交换机。 在交换机的各个配置模式之间切换 将交换机主机的名称改为BDON。 通过 Console线缆将PC的COM接口与路由器的Console接口相连并通过SecureCRT 软件

    2024年04月12日
    浏览(52)
  • 【初始RabbitMQ】交换机的实现

    RabbitMQ消息传递模型的核心思想就是: 生产者生产的消息从不会直接发送到队列 。实际上,通常生产者不知道这些消息会传递到那些队列中 相反,生产者只能将消息发送到交换机,交换机的工作内容也很简单,一方面是接受来自生产者的消息,另一方面是将它们推入到队列

    2024年02月20日
    浏览(37)
  • 网络_TCP/IP_第五章_交换机的基本原理与配置_实验案例二:交换机的基本配置

    如图5.18所示、两台交换机互连,并与四台计算机连接在一起,设备之间接口的连接情况如表5-4所示。 图 5-18 实验案例二示意图 表5-4 设备之间接口的连接情况         通过命令查看MAC地址表,观察各个接口对应的MAC地址;配置交换机互连接口的双工模式及速率,观察在双工模式

    2024年04月10日
    浏览(52)
  • 交换机怎么设置实现三层交换功能案例详解

    首先我们看一下交换机怎么设置三层交换技术的应用环境为了使VLAN之间通信,单臂路由容易产生瓶颈,使用三层交换可以实现线速转发。 1什么是三层交换技术 : 简单的说三层交换技术就是:二层交换技术+三层转发技术。(交换机工作在二层,路由器工作在三层.) 下面是本次

    2024年02月05日
    浏览(43)
  • RabbitMQ系列(14)--Topics交换机的简介与实现

    1、Topics交换机的介绍 Topics交换机能让消息只发送往绑定了指定routingkey的队列中去,不同于Direct交换机的是,Topics能把一个消息往多个不同的队列发送;Topics交换机的routingkey不能随意写,必须是一个单词列表,并以点号分隔开,例如“one.two.three”,除此外还有两个替换符,

    2024年02月13日
    浏览(46)
  • RabbitMQ 备份交换机和死信交换机

      为处理生产者将消息推送到交换机中,交换机按照消息中的路由键及自身策略无法将消息投递到指定队列中造成消息丢失的问题,可以使用备份交换机。   为处理在消息队列中到达TTL的过期消息,可采用死信交换机进行消息转存。可以通过死信交换机的方式实现延迟队

    2024年02月14日
    浏览(52)
  • golang整合rabbitmq-实现创建生产者绑定交换机-创建消费者消费完整代码

    1,在生产者端初始化mq连接 2,创建生产者 3,另起一个go服务进行消费者消费 后面将会发布golang整合es操作的文章

    2024年01月25日
    浏览(58)
  • 华为S8500交换机实现灵活QinQ的配置原理

    一、简单原理介绍 使用普通的QinQ虽然可以解决VLAN的扩展和简单二层VPN的功能,但对一个端口只能增加固定的外层TAG,无法满足对不同业务的用户增加不同外层VLAN TAG的要求。如VLAN 100~200为一种业务的用户,要求打上外层标签10;VLAN 201~300为另一业务,要求打上外层标签2

    2024年02月05日
    浏览(30)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包