根据源码,模拟实现 RabbitMQ - 虚拟主机设计(5)

这篇具有很好参考价值的文章主要介绍了根据源码,模拟实现 RabbitMQ - 虚拟主机设计(5)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、虚拟主机设计

1.1、需求分析

1.1.1、核心  API

1.1.2、虚拟主机的是用来干什么的?

1.1.3、如何表示 交换机和虚拟主机 之间的从属关系?

二、实现 VirtualHost 类

2.1、属性

2.2、锁对象

2.3、公开实例

2.4、虚拟主机构造方法

2.5、交换机相关操作

2.5、队列相关操作

2.6、绑定相关操作

2.7、消息相关操作

2.8、补充线程安全问题


一、虚拟主机设计


1.1、需求分析

1.1.1、核心  API

虚拟主机的概念类似于 MySQL 的 database ,把 交换机、队列、绑定、消息...... 进行 逻辑 上的隔离,因此不仅仅需要管理数据,还需要提供一些核心 API 供上层代码调用.

核心 API(就是把之前写内存中的数据管理和硬盘的数据管理,串起来):

  1. 创建交换机 exchangeDeclare
  2. 删除交换机 exchagneDelete
  3. 创建队列 queueDeclare
  4. 删除队列 queueDelete
  5. 创建绑定 queueBind
  6. 删除绑定 queueUnbind
  7. 发送消息 basicPublish
  8. 订阅消息 basicCosume
  9. 确认消息 basicAck

1.1.2、虚拟主机的是用来干什么的?

虚拟主机的目的,是为了保证隔离,不同虚拟主机之间的内容不要有影响.

例如,虚拟主机1 中创建了一个 exchange,叫做:“testExchange”,虚拟主机2 中,也创建了一个 exchange,叫做 “testExchange” ,他两虽然名字相同,但却是不同空间中的 exchange。

 从调用者的角度来讲,虽然这两个创建 exchange 时,起的名字叫做 testExchange,但是在虚拟主机内部会自动处理,加上前缀,“virtualHost1testExchange”,“virtualHost2testExchange”。

按照这个方式,就可以区分开不同交换机,进一步区分不同队列(一个交换机对应多个队列),进一步的,绑定也就隔离开了(绑定是和交换机与队列相关的),再进一步消息是和队列强相关的,消息自然也就区分开了.

1.1.3、如何表示 交换机和虚拟主机 之间的从属关系?

方案一:参考数据库的设计,“一对多” 方案,比如给交换机表,添加个属性,虚拟主机id/name...

方案二(RabbitMQ 采取的策略):重新约定,交换机的名字 = 虚拟主机的名字 + 交换机的名字

方案三: 更优雅的办法,就是给每个虚拟主机,分配一组不同的数据库和文件,但是有点麻烦.

这里我们按照 RabbitMQ 采取的策略~~

二、实现 VirtualHost 类


2.1、属性

    private String virtualHostName;
    private MemoryDataCenter memoryDataCenter = new MemoryDataCenter();
    private DiskDataCenter diskDataCenter = new DiskDataCenter();
    private Router router;

Router 这个类就描述了 routingKey 和 bindingKey 是否合法,以及消息与队列之间的匹配规则.

2.2、锁对象

用来处理 交换机操作、队列操作、绑定操作、消息操作 中的线程安全问题

例如:针对多线程操作“增加交换机”,以及“边增加边删除”进行加锁操作(多线程同时删除其实没什么事,因为都是 sql 的 delete 进行删除,即使删除多次,也没有副作用)

    //交换机锁对象
    private final Object exchangeLocker = new Object(); //final 修饰是为了防止程序员修改引用,导致不是一个锁对象(其实可有可无,自己注意就 ok)
    //队列锁对象
    private final Object queueLocker = new Object();

2.3、公开实例

让上层代码调用时可以分别拿到 虚拟主机名、内存数据处理中心、硬盘数据处理中心.


    public String getVirtualHostName() {
        return virtualHostName;
    }

    public MemoryDataCenter getMemoryDataCenter() {
        return memoryDataCenter;
    }

    public DiskDataCenter getDiskDataCenter() {
        

2.4、虚拟主机构造方法

主要针对主机名,硬盘、内存数据处理中心进行初始化操作.

    public VirtualHost(String name) {
        this.virtualHostName = name;
        //对于 MemoryDataCenter 来说,不需要进行初始化工作,只需要 new 出来即可
        //但是,对于 DiskDataCenter 来说,需要进行初始化操作,建库建表和初始数据的设定
        diskDataCenter.init();

        //另外还需要针对硬盘初始化的数据,恢复到内存中
        try {
            memoryDataCenter.recovery(diskDataCenter);
        } catch (IOException | MqException | ClassNotFoundException e) {
            e.printStackTrace();
            System.out.println("[VirtualHost] 恢复内存数据失败!");
        }
    }

2.5、交换机相关操作

创建交换机:从内存中获取对应交换机,如果不存在就创建,如果存在,就直接返回

删除交换机:先检查交换机是否存在,不存在抛出异常,存在就删除

Ps:返回值是 boolean 类型,true 表示成功,false 表示失败


    /**
     * 创建交换机
     * @param exchangeName
     * @param exchangeType
     * @param durable
     * @param autoDelete
     * @param arguments
     * @return
     */
    public boolean exchangeDeclare(String exchangeName, ExchangeType exchangeType, boolean durable, boolean autoDelete,
                                   Map<String, Object> arguments) {
        //1.把交换机加上虚拟主机的名字作为前缀(虚拟主机的隔离效果)
        exchangeName = virtualHostName + exchangeName;
        try {
            synchronized (exchangeLocker) {
                //2.通过内存查询交换机是否存在
                Exchange exchange = memoryDataCenter.getExchange(exchangeName);
                if(exchange != null) {
                    //已经存在就直接返回
                    System.out.println("[VirtualHost] 交换机已经存在!exchangeName=" + exchangeName);
                    return true;
                }
                //3.不存在就创建一个
                exchange = new Exchange();
                exchange.setName(exchangeName);
                exchange.setType(exchangeType);
                exchange.setDurable(durable);
                exchange.setAutoDelete(autoDelete);
                exchange.setArguments(arguments);

                //4.内存中是一定要创建的,硬盘中是否存储,就要传来的参数 durable 是否为 true 了(持久化)
                if(durable) {
                    diskDataCenter.insertExchange(exchange);
                }
                memoryDataCenter.insertExchange(exchange);
                System.out.println("[VirtualHost] 交换机创建成功!exchangeName=" + exchangeName);
                //上述逻辑中,先写硬盘,后写内存,就是因为硬盘更容易写失败,如果硬盘写失败了,内存就不用写了
                //但要是先写内存,一旦内存写成功了,硬盘写失败了,还需要把内存中的数据给删掉,比较麻烦
            }
            return true;
        } catch (Exception e) {
            System.out.println("[VirtualHost] 交换机创建失败!exchangeName=" + exchangeName);
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除交换机
     * @param exchangeName
     * @return
     */
    public boolean exchangeDelete(String exchangeName) {
        //1.虚拟主机前缀
        exchangeName = virtualHostName + exchangeName;
        try {
            synchronized (exchangeLocker) {
                //2.检查当前内存中是否存在该交换机
                Exchange exchange = memoryDataCenter.getExchange(exchangeName);
                if(exchange == null) {
                    throw new MqException("[VirtualHost] 该交换机不存在无法删除!exchangeName=" + exchangeName);
                }
                //3.如果持久化到硬盘上,就把硬盘的先删除了
                if(exchange.isDurable()) {
                    diskDataCenter.deleteExchange(exchangeName);
                }
                //4.存在就删除
                memoryDataCenter.deleteExchange(exchangeName);
                System.out.println("[VirtualHost] 交换机删除成功!exchangeName=" + exchangeName);
            }
            return true;
        } catch (Exception e) {
            System.out.println("[VirtualHost] 交换机删除失败!exchangeName=" + exchangeName);
            e.printStackTrace();
            return false;
        }
    }

2.5、队列相关操作

这里的操作逻辑和交换机差不多~~

    /**
     * 创建队列
     * @param queueName
     * @param durable
     * @param exclusive
     * @param autoDelete
     * @param arguments
     * @return
     */
    public boolean queueDeclare(String queueName, boolean durable, boolean exclusive, boolean autoDelete,
                                Map<String, Object> arguments) {
        //1.虚拟主机前缀
        queueName = virtualHostName + queueName;
        try {
            synchronized (queueLocker) {
                //2.先检查内存是否存在此队列
                MSGQueue queue = memoryDataCenter.getQueue(queueName);
                if(queue != null) {
                    System.out.println("[VirtualHost] 当前队列已存在!queueName=" + queueName);
                    return true;
                }
                //3.不存在则创建并赋值
                queue = new MSGQueue();
                queue.setName(queueName);
                queue.setExclusive(exclusive);
                queue.setDurable(durable);
                queue.setAutoDelete(autoDelete);
                queue.setArguments(arguments);
                //4.如果设置了持久化,就先在硬盘上保存一份
                if(durable) {
                    diskDataCenter.insertQueue(queue);
                }
                //5.写内存
                memoryDataCenter.insertQueue(queue);
                System.out.println("[VirtualHost] 队列创建成功!queueName=" + queueName);
            }
            return true;
        } catch (Exception e) {
            System.out.println("[VirtualHost] 队列创建失败!queueName=" + queueName);
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 队列删除
     * @param queueName
     * @return
     */
    public boolean queueDelete(String queueName) {
        //1.虚拟主机前缀
        queueName = virtualHostName + queueName;
        try {
            synchronized (queueLocker) {
                //2.判断队列是否存在,若不存在则抛出异常
                MSGQueue queue = memoryDataCenter.getQueue(queueName);
                if(queue == null) {
                    throw new MqException("[VirtualHost] 队列不存在,删除失败!queueName=" + queueName);
                }
                //3.存在则判断是否持久化,若持久化到硬盘上,则先删硬盘
                if(queue.isDurable()) {
                    diskDataCenter.deleteQueue(queueName);
                }
                //4.删内存
                memoryDataCenter.deleteQueue(queueName);
                System.out.println("[VirtualHost] 队列删除成功!queueName=" + queueName);
            }
            return true;
        } catch (Exception e) {
            System.out.println("[VirtualHost] 队列删除失败!queueName=" + queueName);
            e.printStackTrace();
            return false;
        }
    }

2.6、绑定相关操作

创建绑定:先判断内存中是否存在这种绑定,如果存在则创建失败,如果不存在就需要看交换机和队列是否都同时存在,存在才能创建成功

删除绑定::先判断内存中是否存在这种绑定,不存在抛出异常,如果存在,不用判定交换机和队列是否存在(反而复杂了步骤),也不用判定硬盘上有没有此绑定,直接从内存和硬盘上删除就可,因为即使硬盘中没有数据,也不会有什么副作用(本质是 MyBatis 底层调用 delete 语句进行删除).

    /**
     * 创建队列交换机绑定关系
     * @param queueName
     * @param exchangeName
     * @param bindingKey
     * @return
     */
    public boolean queueBind(String queueName, String exchangeName, String bindingKey) {
        //1.虚拟主机前缀
        queueName = virtualHostName + queueName;
        exchangeName = virtualHostName + exchangeName;
        try {
            synchronized (exchangeLocker) {
                synchronized (queueLocker) {
                    //2.检测内存中是否存在绑定
                    Binding existsBinding = memoryDataCenter.getBinding(exchangeName, queueName);
                    if(existsBinding != null) {
                        throw new MqException("[VirtualHost] 绑定已存在,创建失败!exchangeName=" + exchangeName +
                                "queueName=" + queueName);
                    }
                    //3.不存在,先检验 bindingKey 是否合法
                    if(!router.checkBindingKey(bindingKey)) {
                        throw new MqException("[VirtualHost] bindingKey 非法!bingdingKey=" + bindingKey);
                    }
                    //4.检验队列和交换机是否存在,不存在抛出异常
                    Exchange existsExchange = memoryDataCenter.getExchange(exchangeName);
                    if(existsExchange == null) {
                        throw new MqException("[VirtualHost] 交换机不存在!exchangeName=" + exchangeName);
                    }
                    MSGQueue existsQueue = memoryDataCenter.getQueue(queueName);
                    if(existsQueue == null) {
                        throw new MqException("[VirtualHost] 队列不存在!queueName=" + queueName);
                    }
                    //5.创建绑定
                    Binding binding = new Binding();
                    binding.setBindingKey(bindingKey);
                    binding.setQueueName(queueName);
                    binding.setExchangeName(exchangeName);
                    //6.硬盘中创建绑定的前提是队列和交换机都是持久化的,否则绑定在硬盘中无意义
                    if(existsQueue.isDurable() && existsExchange.isDurable()) {
                        diskDataCenter.insertBinding(binding);
                    }
                    //7.写内存
                    memoryDataCenter.insertBinding(binding);
                    System.out.println("[VirtualHost] 绑定创建成功!exchangeName=" + exchangeName +
                            "queueName=" + queueName);
                }
            }
            return true;
        } catch (Exception e) {
            System.out.println("[VirtualHost] 绑定创建失败!exchangeName=" + exchangeName +
                    "queueName=" + queueName);
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除绑定关系
     * @param queueName
     * @param exchangeName
     * @return
     */
    public boolean queueUnBind(String queueName, String exchangeName) {
        //1.虚拟主机前缀
        queueName = virtualHostName + queueName;
        exchangeName = virtualHostName + exchangeName;
        try {
            //这里的加锁顺序一定要和上面的两次加锁保持一致(防止死锁)
            synchronized (exchangeLocker) {
                synchronized (queueLocker) {
                    //2.检查绑定是否存在,不存在则抛出异常
                    Binding binding = memoryDataCenter.getBinding(exchangeName, queueName);
                    if(binding == null) {
                        throw new MqException("[VirtualHost] 绑定不存在, 删除失败!binding=" + binding);
                    }
                    //3.直接删除硬盘数据,不用判断是否存在,因为即使不存在绑定,直接删也不会有什么副作用,因为本质就是调用 sql 删除
                    diskDataCenter.deleteBinding(binding);
                    //4.删内存
                    memoryDataCenter.deleteBinding(binding);
                    System.out.println("[VirtualHost] 绑定删除成功!queueName=" + queueName +
                            ", exchangeName=" + exchangeName);
                }
            }
            return true;
        } catch (Exception e) {
            System.out.println("[VirtualHost] 绑定删除失败!queueName=" + queueName +
                    ", exchangeName=" + exchangeName);
            e.printStackTrace();
            return false;
        }
    }

2.7、消息相关操作

发布消息:本质就是发送消息到指定的 交换机/队列 中,首先判定 routingKey 是否合法,然后再去获取交换机,再根据不同交换机的类型进行不同的处理(不同交换机给队列发送消息的方式不同),最后调用发送消息方法

放送消息:发送消息本质上就是将消息写入 内存/硬盘 上,对于硬盘上是否要写入,就要看消息是否支持持久化(deliverMode 为 1 表示不持久化,deliverMode 为 2 表示要持久化),最后还需要补充一个逻辑,通知消费者可以消费消息了(这里先不补充了,下一章会讲到).

Ps:这里对于直接交换机,约定以 routingKey 作为队列名称,直接将消息发送给指定的队列,也就可以直接无视绑定关系了(这是实际开发中最常用的场景,因此这里这样设定)

    /**
     * 发送消息到指定的 交换机/队列 中
     * @param exchangeName
     * @return
     */
    public boolean basicPublish(String exchangeName, String routingKey, BasicProperties basicProperties, byte[] body) {
        //1.虚拟主机前缀
        exchangeName = virtualHostName + exchangeName;
        try {
            //2.判定 routingKey 是否合法
            if(!router.checkRoutingKey(routingKey)) {
                throw new MqException("[VirtualHost] routingKey 非法!routingKey=" + routingKey);
            }
            //3.获取交换机
            Exchange exchange = memoryDataCenter.getExchange(exchangeName);
            if(exchange == null) {
                throw new MqException("[VirtualHost] 交换机不存在,消息发送失败!exchangeName=" + exchangeName);
            }
            //4.判定交换机类型
            if(exchange.getType() == ExchangeType.DIRECT) {
                //直接交换机转发消息,以 routingKey 作为队列名字
                //直接把消息写入指定队列,也就可以无视绑定关系(这是实际开发环境中最常用的,因此这里这样设定)

                String queueName = virtualHostName + routingKey;
                //5.构造消息对象
                Message message = Message.createMessageWithId(routingKey, basicProperties, body);
                //6.查找该队列名对应的对象
                MSGQueue queue = memoryDataCenter.getQueue(queueName);
                if(queue == null) {
                    throw new MqException("[VirtualHost] 队列不存在!queueName=" + queueName);
                }
                //7.发送消息
                sendMessage(queue, message);
            } else {
                // 按照 fanout 和 topic 的方式转发
                //5.找到该交换机的所有绑定,并遍历绑定对象
                ConcurrentHashMap<String, Binding> bindingsMap = memoryDataCenter.getBindings(exchangeName);
                for(Map.Entry<String, Binding> entry : bindingsMap.entrySet()) {
                    // 1) 获取到绑定对象,判定对应的队列是否存在
                    Binding binding = entry.getValue();
                    MSGQueue queue = memoryDataCenter.getQueue(binding.getQueueName());
                    if(queue == null) {
                        //此处不抛异常了,因为又多个这样的队列
                        //希望不要因为一个队列匹配失败,影响到其他队列
                    System.out.println("[VirtualHost] basicPublish 发送消息时,发现队列不存在!queueName=" + binding.getQueueName());
                    }
                    // 2) 构造消息对象
                    Message message = Message.createMessageWithId(routingKey, basicProperties, body);
                    // 3) 判定这个消息是否能转发给该队列
                    // 如果是 fanout。所有绑定的队列都要转发
                    // 如果是 topic,还需要判定下,bindingKey 和 routingKey 是不是匹配
                    if(!router.route(exchange.getType(), binding, message)) {
                        continue;
                    }
                    sendMessage(queue, message);
                }
            }
            return true;
        } catch (Exception e) {
            System.out.println("[VirtualHost] 消息发送失败!exchangeName=" + exchangeName +
                    ", routingKey=" + routingKey);
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 发送消息
     * 实际上就是把消息写道 硬盘 和 内存 上
     * @param queue
     * @param message
     */
    private void sendMessage(MSGQueue queue, Message message) throws IOException, MqException {
        //判断当前消息是否要进行持久化
        //deliverMode 为 1 表示不持久化,deliverMode 为 2 表示要持久化
        int deliverMode = message.getDeliverMode();
        if(deliverMode == 1) {
            diskDataCenter.sendMessage(queue, message);
        }
        //写内存
        memoryDataCenter.sendMessage(queue, message);
        //TODO 此处还需要补充一个逻辑,通知消费者可以消费消息了
    }

2.8、补充线程安全问题

锁粒度过大,是否要调整?

这里加了很多锁,同时锁粒度还是挺大的,但也可以做出调整,细化锁粒度,但是影响不大,因为这里创建交换机、创建绑定、创建队列、删除交换机.... 这些都是属于低频操作!

既然是低频操作,所以遇到两个线程都去操作创建队列之类的情况本身概率就很低了,再加上 synchronized 本身也是偏向锁状态,只有真正遇到竞争的时候才真加锁,因此没必要调整锁粒度.

此处加锁还是十分有必要的,为了应对一些少数的极端情况.

既然 VirtualHost 这一层代码加锁了,里面的 MemoryDataCenter 中的操作是否就不需要加锁了?之前加锁是否就没意义了?

咱们也不知道这个类的方法是给哪个类调用的,当前 VirtualHost 自身保证了线程安全的,此时 VirtualHost 内部调用 MemoryDataCenter ,里面的不加锁问题也不大,但是如果是另一个别的类,也多线程调用 MemoryDataCenter,就不可预知了~~

根据源码,模拟实现 RabbitMQ - 虚拟主机设计(5),RabbitMQ,rabbitmq,分布式文章来源地址https://www.toymoban.com/news/detail-671786.html

到了这里,关于根据源码,模拟实现 RabbitMQ - 虚拟主机设计(5)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • Spring RabbitMQ 配置多个虚拟主机(vhost)

    在日常开发中,同时需要用到RabbitMQ多个虚拟机(vhost)。应用场景:需要接收多个交换机的数据,而交换机都在不同的虚拟机(vhost) Docker安装RabbitMQ 【SpringCloud】整合RabbitMQ六大模式应用(入门到精通) 本地模拟发送、接收RabbitMQ数据

    2024年02月21日
    浏览(57)
  • 3.RabbitMQ UI管理界面使用(用户、虚拟主机)

    RabbitMQ专栏目录(点击进入…) 1.服务方式 (1)打开服务 (2)在RabbitMQ Command Prompt中执行命令(方式一) 管理插件包含在RabbitMQ发行版中。与其他任何插件一样,必须先启用它才能使用它 (3)cmd执行命令(方式二) 因为在上面配置了RabbitMQ的sbin环境变量,所以在cmd中执行

    2024年02月05日
    浏览(36)
  • RabbitMQ虚拟主机无法启动的原因和解决方案

    摘要: RabbitMQ是一个广泛使用的开源消息代理系统,但在使用过程中可能会遇到虚拟主机无法启动的问题。本文将探讨可能导致该问题的原因,并提供相应的解决方案,以帮助读者解决RabbitMQ虚拟主机启动失败的困扰。 在RabbitMQ中,虚拟主机(Virtual Host)是一种逻辑分区,用

    2024年02月12日
    浏览(41)
  • Unity制作虚拟主机装机模拟器(课程设计)

    1.设计阶段 1.1需求分析 本虚拟装机系统是为了帮助用户学习计算机的组装过程,提供动手组装、教学模式和零件介绍三种模式。在零件介绍中,用户可以通过语音和文字介绍了解不同电脑零件的功能和名称。在教学模式中,用户可以观看动画短片,了解计算机的发展和组装计

    2024年01月21日
    浏览(44)
  • 虚拟机中docker安装rabbitmq 宿主机不能访问rabbitmq管理界面问题解决

    1, MacOS的操作系统, 通过Vmware Fusion虚拟机软件, 安装了Centos7操作系统, 里面安装了docker engine(1.13.1); 2, 试验rabbitmq, 下载了rabbit:latest镜像 3, 通过如下命令启动rabbitmq 4, 启动之后, 在宿主机浏览器测试访问虚拟机中的rabbitmq http://192.168.88.100:15672/ 试验结果: 拒绝访问 1, 检查centos-l

    2024年02月10日
    浏览(54)
  • Flutter环境搭建【win10虚拟机】+夜神模拟器【主机】

    为了安装和运行 Flutter,你的开发环境必须至少满足以下要求: 操作系统:Windows 10 或更高的版本(基于 x86-64 的 64 位操作系统)。 磁盘空间:除安装 IDE 和一些工具之外还应有至少 2.5 GB 的空间。 工具:要让 Flutter 在你的开发环境中正常使用,依赖于以下的工具: Windows P

    2024年04月23日
    浏览(61)
  • 根据源码,模拟实现 RabbitMQ - 转发规则实现(6)

    目录 一、转发规则实现 1.1、需求分析 1.2、实现 Router 转发规则 1.2.1、bindingKey 和 routingKey 参数校验 1.2.2、消息匹配规则 1.2.3、主题交换机匹配规则 这里主要实现 routingKey 和 bindingKey 参数的校验,以及 TopicExchange 类型绑定规则的实现. 这里重点来看一下 Topic 交换机的转发规则

    2024年02月12日
    浏览(43)
  • 根据源码,模拟实现 RabbitMQ - 内存数据管理(4)

    目录 一、内存数据管理 1.1、需求分析 1.2、实现 MemoryDataCenter 类 1.2.1、ConcurrentHashMap 数据管理 1.2.2、封装交换机操作 1.2.3、封装队列操作 1.2.4、封装绑定操作 1.2.5、封装消息操作 1.2.6、封装未确认消息操作 1.2.7、封装恢复数据操作 当前已经使用 数据库 管理了 交换机、绑定

    2024年02月11日
    浏览(41)
  • VMware、linux虚拟机设置网络实现虚拟机与主机网络互通

    需要配置三个方面才可以,即:WMware网络配置、windows主机网络配置、虚拟机网络配置。 首先,确认VMware虚拟机设置中配置的网络连接方式为:NAT模式 可以在VMware上方的菜单中找到:虚拟机----设置,然后找到 网络适配器,设置网络连接方式为:NAT模式,如下图: 一、配置

    2024年02月02日
    浏览(45)
  • 根据源码,模拟实现 RabbitMQ - 从需求分析到实现核心类(1)

    目录 一、需求分析 1.1、对 Message Queue 的认识 1.2、消息队列核心概念 1.3、Broker Server 内部关键概念 1.4、Broker Server 核心 API (重点实现) 1.5、交换机类型 Direct 直接交换机 Fanout 扇出交换机 Topic 主题交换机 1.6、持久化 1.7、网络通信 通信流程 远程调用设计思想 1.8、模块设计图

    2024年02月12日
    浏览(43)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包