Dubbo之Cluster目录服务

最新推荐文章于 2024-08-06 21:36:54 发布
最新推荐文章于 2024-08-06 21:36:54 发布
阅读量42 收藏
点赞数
文章标签： dubbo windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usagoole/article/details/132986467
版权
目录

dubbo版本

  1. dubbo版本2.6.7

目录服务

  1. 目录服务(Directory service):是一个储存、组织和提供信息访问服务的软件系统。一个目录是指一组名字和值的映射。它允许根据一个给出的名字来查找对应的值，与词典相似。像词典中每一个词也许会有多个词义，在一个目录中，一个名字也许会与多个不同的信息相关联。

  2. 目录一般只提供范围非常小的节点类型和数值类型，也可能对任意的或可扩展的一组类型提供支持。比如在一个电话目录中，节点就是姓名而数值项就是电话号码

  3. 在Dubbo中目录服务存储了一些和服务提供者有关的信息，通过服务目录，服务消费者可获取到服务提供者的信息。Dubbo中目录服务其实就是Invoker对象的集合，这个集合中的元素会随注册中心的变化而进行动态调整。

  4. Directory既提供静态的Invoker列表(用户设置)，也提供了动态的Invoker列表(注册中心动态变化)

    Directory

AbstractDirectory

  1. AbstractDirectory是模板类，封装了通用的流程

    • 检查Directory是否已经销毁
    • 子类实现获取Invoker列表
    • 获取路由Router列表，过滤Invoker列表
    @Override
public List<Invoker<T>> list(Invocation invocation) throws RpcException {
    if (destroyed) {
        throw new RpcException("Directory already destroyed .url: " + getUrl());
    }
    //子类实现获取Invoker列表
    List<Invoker<T>> invokers = doList(invocation);
    // 获取路由 Router 列表
    List<Router> localRouters = this.routers; // local reference
    if (localRouters != null && !localRouters.isEmpty()) {
        for (Router router : localRouters) {
            try {
                //runtime参数决定了是否在每次调用服务时都执行路由规则。
                //如果runtime为true，那么每次调用服务前，都需要进行服务路由。
                if (router.getUrl() == null || router.getUrl().getParameter(Constants.RUNTIME_KEY, false)) {
                    invokers = router.route(invokers, getConsumerUrl(), invocation);
                }
            } catch (Throwable t) {
                logger.error("Failed to execute router: " + getUrl() + ", cause: " + t.getMessage(), t);
            }
        }
    }
    return invokers;
}

StaticDirectory

  1. StaticDirectory#doList逻辑非常简单，不做任何处理，直接返回Invoker列表

    @Override
protected List<Invoker<T>> doList(Invocation invocation) throws RpcException {

    return invokers;
}

RegistryDirectory

  1. RegistryDirectory 可根据配置变更信息刷新 Invoker 列表。RegistryDirectory的重要逻辑

    • 列举Invoker列表
    • 接收服务配置变更的逻辑
    • 刷新 Invoker 列表

  2. RegistryDirectory是一种动态目录服务，实现了NotifyListener，当注册中心服务配置发生变化后，RegistryDirectory 可收到与当前服务相关的变化。收到变更通知后，RegistryDirectory 可根据配置变更信息刷新 Invoker 列表

  3. 列举Invoker列表：doList本质就是对methodInvokerMap的读取操作

    @Override
public List<Invoker<T>> doList(Invocation invocation) {
    // 服务提供者关闭或禁用了服务，此时抛出 No provider 异常
    if (forbidden) {
        // 1. No service provider 2. Service providers are disabled
        throw new RpcException(RpcException.FORBIDDEN_EXCEPTION,
                "No provider available from registry " + getUrl().getAddress() + " for service " + getConsumerUrl().getServiceKey() + " on consumer " + NetUtils.getLocalHost()
                        + " use dubbo version " + Version.getVersion() + ", please check status of providers(disabled, not registered or in blacklist).");
    }
    List<Invoker<T>> invokers = null;
    // 获取 Invoker 本地缓存，这里其实赋值本地变量是没有必要的
    Map<String, List<Invoker<T>>> localMethodInvokerMap = this.methodInvokerMap; // local reference
    if (localMethodInvokerMap != null && localMethodInvokerMap.size() > 0) {
        //获取方法名和第一个参数
        String methodName = RpcUtils.getMethodName(invocation);
        Object[] args = RpcUtils.getArguments(invocation);
        // 检测参数列表的第一个参数是否为 String 或 enum 类型
        if (args != null && args.length > 0 && args[0] != null
                && (args[0] instanceof String || args[0].getClass().isEnum())) {
            // 通过 方法名 + 第一个参数名称 查询 Invoker 列表，具体的使用场景不太清楚
            invokers = localMethodInvokerMap.get(methodName + "." + args[0]); // The routing can be enumerated according to the first parameter
        }
        if (invokers == null) {
            // 通过方法名获取 Invoker 列表
            invokers = localMethodInvokerMap.get(methodName);
        }
        if (invokers == null) {
            // 通过星号 * 获取 Invoker 列表(泛化调用)
            invokers = localMethodInvokerMap.get(Constants.ANY_VALUE);
        }
        // 冗余逻辑，pull request #2861 移除了下面的 if 分支代码
        // https://github.com/apache/dubbo/pull/2861
        //provider没有方法，但是consumer依然能获取到invoker
        if (invokers == null) {
            Iterator<List<Invoker<T>>> iterator = localMethodInvokerMap.values().iterator();
            if (iterator.hasNext()) {
                invokers = iterator.next();
            }
        }
    }
    return invokers == null ? new ArrayList<Invoker<T>>(0) : invokers;
}

订阅与动态更新

  1. 订阅与动态更新主要涉及subscribe、notify、refreshInvoker三个方法

  2. RegistryDirectory#subscribe 就是调用注册中心的subscribe方法，RegistryDirectory实现了NotifyListener，所以传入的就是自己

    public void subscribe(URL url) {
    //设置consumer url
    setConsumerUrl(url);
    //调用注册中心订阅消息消息消费者URL,listener就是自己
    registry.subscribe(url, this);
}

  3. NotifyListener是一个通知接口，当收到服务变更通知时触发。

    public interface NotifyListener {

    /**
     * 当收到服务变更通知时触发。
     * 通知需处理契约：
     * 1. 总是以服务接口和数据类型为维度全量通知，即不会通知一个服务的同类型的部分数据，用户不需要对比上一次通知结果。<br>
     * 2. 订阅时的第一次通知，必须是一个服务的所有类型数据的全量通知。<br>
     * 3. 中途变更时，允许不同类型的数据分开通知，比如：providers, consumers, routers, overrides，允许只通知其中一种类型，但该类型的数据必须是全量的，不是增量的。<br>
     * 4. 如果一种类型的数据为空，需通知一个empty协议并带category参数的标识性URL数据。<br>
     * 5. 通知者(即注册中心实现)需保证通知的顺序，比如：单线程推送，队列串行化，带版本对比。<br>
     */
    void notify(List<URL> urls);

}

  4. RegistryDirectory#notify是在注册中心providers、configurators、routers目录下的节点发生变化后，通知RegistryDirectory，从而实现动态发现机制

    @Override
 public synchronized void notify(List<URL> urls) {
     List<URL> invokerUrls = new ArrayList<URL>();
     List<URL> routerUrls = new ArrayList<URL>();
     List<URL> configuratorUrls = new ArrayList<URL>();
     //根据通知的URL的前缀，分别添加到：
     // invokerUrls(提供者url)、routerUrls(路由信息)、configuratorUrls (配置url)。
     for (URL url : urls) {
         //获取URL协议字段，例如condition://、route://、script://、override://等
         String protocol = url.getProtocol();
         //获取url的category,providers、configurators、routers
         String category = url.getParameter(Constants.CATEGORY_KEY, Constants.DEFAULT_CATEGORY);
         //routers或者route
         if (Constants.ROUTERS_CATEGORY.equals(category)
                 || Constants.ROUTE_PROTOCOL.equals(protocol)) {
             routerUrls.add(url);
          //configurators和override
         } else if (Constants.CONFIGURATORS_CATEGORY.equals(category)
                 || Constants.OVERRIDE_PROTOCOL.equals(protocol)) {
             configuratorUrls.add(url);
             //providers
         } else if (Constants.PROVIDERS_CATEGORY.equals(category)) {
             invokerUrls.add(url);
         } else {
             logger.warn("Unsupported category " + category + " in notified url: " + url + " from registry " + getUrl().getAddress() + " to consumer " + NetUtils.getLocalHost());
         }
     }
     // configurators
     if (configuratorUrls != null && !configuratorUrls.isEmpty()) {
         this.configurators = toConfigurators(configuratorUrls);
     }
     // routers
     if (routerUrls != null && !routerUrls.isEmpty()) {
         List<Router> routers = toRouters(routerUrls);
         if (routers != null) { // null - do nothing
             setRouters(routers);
         }
     }
     List<Configurator> localConfigurators = this.configurators; // local reference
     // merge override parameters
     this.overrideDirectoryUrl = directoryUrl;
     if (localConfigurators != null && !localConfigurators.isEmpty()) {
         for (Configurator configurator : localConfigurators) {
             this.overrideDirectoryUrl = configurator.configure(overrideDirectoryUrl);
         }
     }
     // providers
     refreshInvoker(invokerUrls);
 }

  5. refreshInvoker 方法首先会根据入参 invokerUrls 的数量和协议头判断是否禁用所有的服务，如果禁用，则将 forbidden 设为 true，并销毁所有的 Invoker。若不禁用，则将 url 转成 Invoker，得到 的映射关系。然后进一步进行转换，得到 映射关系。之后进行多组 Invoker 合并操作，并将合并结果赋值给 methodInvokerMap。methodInvokerMap 变量在 doList 方法中会被用到，doList 会对该变量进行读操作，在这里是写操作。当新的 Invoker 列表生成后，还要一个重要的工作要做，就是销毁无用的 Invoker，避免服务消费者调用已下线的服务的服务。

    rivate void refreshInvoker(List<URL> invokerUrls) {
    // invokerUrls 仅有一个元素，且 url 协议头为 empty，此时表示禁用所有服务
    if (invokerUrls != null && invokerUrls.size() == 1 && invokerUrls.get(0) != null
            && Constants.EMPTY_PROTOCOL.equals(invokerUrls.get(0).getProtocol())) {
        this.forbidden = true; // Forbid to access
        this.methodInvokerMap = null; // Set the method invoker map to null
        // 销毁所有 Invoker
        destroyAllInvokers(); // Close all invokers
    } else {
        this.forbidden = false; // Allow to access
        Map<String, Invoker<T>> oldUrlInvokerMap = this.urlInvokerMap; // local reference
        if (invokerUrls.isEmpty() && this.cachedInvokerUrls != null) {
            // 添加缓存 url 到 invokerUrls 中
            invokerUrls.addAll(this.cachedInvokerUrls);
        } else {
            this.cachedInvokerUrls = new HashSet<URL>();
            // 缓存 invokerUrls
            this.cachedInvokerUrls.addAll(invokerUrls);//Cached invoker urls, convenient for comparison
        }
        if (invokerUrls.isEmpty()) {
            return;
        }
        // 将 url 转成 Invoker
        Map<String, Invoker<T>> newUrlInvokerMap = toInvokers(invokerUrls);// Translate url list to Invoker map
        // 将 newUrlInvokerMap 转成方法名到 Invoker 列表的映射
        Map<String, List<Invoker<T>>> newMethodInvokerMap = toMethodInvokers(newUrlInvokerMap); // Change method name to map Invoker Map
        // state change
        // If the calculation is wrong, it is not processed.
        // 转换出错，直接打印异常，并返回
        if (newUrlInvokerMap == null || newUrlInvokerMap.size() == 0) {
            logger.error(new IllegalStateException("urls to invokers error .invokerUrls.size :" + invokerUrls.size() + ", invoker.size :0. urls :" + invokerUrls.toString()));
            return;
        }
        // 合并多个组的 Invoker
        this.methodInvokerMap = multiGroup ? toMergeMethodInvokerMap(newMethodInvokerMap) : newMethodInvokerMap;
        this.urlInvokerMap = newUrlInvokerMap;
        try {
            // 销毁无用 Invoker
            destroyUnusedInvokers(oldUrlInvokerMap, newUrlInvokerMap); // Close the unused Invoker
        } catch (Exception e) {
            logger.warn("destroyUnusedInvokers error. ", e);
        }
    }
}
jannals
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
源码分析Dubbo服务注册与发现机制RegistryDirectory)，mongodb面试题目
m0_65485530的博客
12-24 616
private static final Cluster cluster = ExtensionLoader.getExtensionLoader(Cluster.class).getAdaptiveExtension(); 集群策略，默认为failover。 private static final RouterFactory routerFactory = ExtensionLoader.getExtensionLoader (RouterFactory.class).getAdaptiveEx.
基于Dubbo框架构建分布式服务
02-26
比如，在实时性要求很高的应用场景下，可能希望来自消费方（Consumer）的调用响应时间最短，只需要选择Dubbo的ForkingCluster模式配置，就可以对一个调用请求并行发送到多台对等的提供方（Provider）服务所在的节点...
5-dubbo服务字典
sinat_38195280的博客
05-09 146
1. 简介 本篇文章，将开始分析 Dubbo 集群容错方面的源码。集群容错源码包含四个部分，分别是服务目录 Directory、服务路由 Router、集群 Cluster 和负载均衡 LoadBalance。这几个部分的源码逻辑相对比较独立，我们将会分四篇文章进行分析。本篇文章作为集群容错的开篇文章，将和大家一起分析服务目录相关的源码。在进行深入分析之前，我们先来了解一下服务目录是什么。服务目...
由Dubbo路由引发的一言不合就看源码
iteye_69的博客
06-30 259
由Router引入 由于业务上的需要，很早之前就想自己扩展Dubbo的路由功能。But，之前试了一下，发现好像并没有找到正确的打开方式，而且由于时间不是很充足，加上自己心浮气躁浅尝辄止，于是乎就放弃了这块的研究。 不过今日，在手头上一块比较忙的事情告一段落了之后，又开始漫漫的research之路。。 好了，下面先来说说之前被困在了什么地方。 首先吐槽一下，官方文档对于这一块的用法写得非常...
Dubbo/Dubbox的服务消费（二）- 服务发现
weiythi的Blog
11-23 1960
上文书整理了dubbo是如何生成服务代理的，并且留了个尾巴，这一文主要介绍dubbo是如何实现服务发现的，继续前文的脚步，看一下dubbo如何完成传说中的服务自动发现 打开com.alibaba.dubbo.config.ReferenceConfig 类，只关注@SuppressWarnings({ "unchecked", "rawtypes", "deprecation" }) pr
源码分析Dubbo服务注册与发现机制RegistryDirectory)
热门推荐
中间件兴趣圈
06-18 1万+
RegistryDirectory，基于注册中心的服务发现，本文将重点探讨Dubbo是如何实现服务的自动注册与发现。从上篇文章，得知在消息消费者在创建服务调用器(Invoker)【消费者在初始时】时需要根据不同的协议，例如dubbo、registry(从注册中心获取服务提供者)来构建，其调用的方法为Protocol#refer，基于注册中心发现服务提供者的实现协议为RegistryProtocol...
Dubbo集群容错之Cluster
程序员小潘
12-25 1531
1. 前言 线上服务很少会单机部署，它不满足互联网三高架构的需求。服务一旦挂了，高可用就无从谈起，另外Dubbo单机默认最大200的并发处理也不满足所谓的高并发、高性能。所以，作为一款优秀的分布式服务框架，Dubbo是支持集群容错的。 ​ Dubbo整个集群容错层的实现在dubbo-cluster模块，它包含很多组件，例如：Cluster、ClusterInvoker、Directory、LoadBalance等等，本文主要分析Cluster以及ClusterInvoker，其它组件会在后面的文章讨论。 2
Dubbo——服务目录
夜勿语的博客
09-10 1348
引言 前面几篇文章分析了Dubbo的核心工作原理，本篇将对之前涉及到但却未细讲的服务目录进行深入分析，在开始之前先结合前面的文章思考下什么是服务目录？它的作用是什么？ 正文 概念及作用 清楚Dubbo的调用过程就知道Dubbo在客户端和服务端都会为服务生成一个Invoker执行体，这个Invoker包含了所有的配置信息，也相当于是一个代理对象，所以这也就引发出几个问题： 怎么管理Invoker？...
Dubbo的Cluster策略与Directory实现
木南曌的博客
06-10 391
Dubbo是一个高性能的Java RPC框架，它提供了丰富的集群容错机制和灵活的路由策略。在Dubbo中，Cluster和Directory是两个核心概念，它们共同工作以实现服务的负载均衡和集群管理。
Dubbo服务目录组件Directory
WannaRunning的博客
04-13 1037
AbstractDirectory中封装了Invoker列举流程，具体的列举逻辑则由子类实现，如AbstractDirectory类定义了doList方法,在StaticDirectory和RegistryDirectory两个子类中重写了doList方法。这是典型的模板模式;
Dubbo服务集群介绍.pptx
11-05
Dubbo服务集群是Dubbo框架中的一个重要特性，它允许开发者构建高可用、高可靠的分布式服务系统。在基于Dubbo的分布式系统架构中，服务集群能够有效地处理服务节点的故障，提高系统的整体稳定性和容错性。本文将详细...
Dubbo服务框架-其他
06-11
看dubbo-cluster/src/test/resources/META-INF/dubbo/internal/org.apache.dubbo.rpc.cluster.RouterFactory 2. 基因调用 默认情况下不会激活本机 Java 反序列化。如果用户仍然想使用它，请设置dubbo.security....
dubbo-cluster-2.8.4.jar
02-24
java运行依赖jar包
SpringBoot基础 第一天
2301_80034662的博客
08-05 603
Person类中利用ConfigurationProperties(prefix=" ")引入配置类中的元素 但是注意Person类中的类的名字必须与application.yaml中一致。如果不是标准的application.properties 是其他的Person类中需要用PropertySource来添加配置文件的路径。给容器中添加组件，将方法的返回值添加到容器中 容器中这个组件的默认ID就是方法名。的配置文件，我们自己编写的配置文件，也不能自动识别；的配置文件，让配置文件里面的内容生效；
使用ollama取代openai的api进行graphRAG失败记录
caoyongsheng的博客
08-06 358
【代码】使用ollama取代openai的api进行graphRAG失败记录。
Linux学习笔记：Linux基础知识汇总（个人复习版）
欢迎相互探讨交流知识呀~
08-05 1645
使用fdisk -l查看分区挂载情况，或者查看/etc/mtab文件，然后找到最接近的挂载点信息。4、创建站点主页 【eg.在/var/www/html内新建index.html】write_enable=YES//ftp可写，即上传权限；下载权限是默认赋予的。将数据同步写入硬盘中的指令，在关机之前输入，可以多输几次。使用df命令，如df -h，查看磁盘分区的挂载点。使用lsblk命令，查看系统的磁盘设备使用情况。-a：显示所有文件（包括隐藏文件），简洁版。-R：显示所有文件以及子目录下文件，简洁版。
【Python】列表元素排序：itertools.permutations()
持续更新中...
08-05 847
This tool returns successive r length permutations of elements in an iterable.If r is not specified or is None, then r defaults to the length of the iterable, and all possible full length permutations are generated.Permutations are printed in a lexicograph
Spring AOP
最新发布
c1tenj2的博客
08-06 784
StudentServiceImpl实现StudentService接口@Service@Override@Override@Override@Override通知类和通知（在里面定义切入点，绑定切入点和通知）@Component@Aspect //让context知道我们这里要用aop//切入点//打印时间。
07.FreeRTOS列表与列表项
L的博客
08-05 915
本文涉及FreeRTOS列表与列表项。包括列表和列表项的简介、列表相关API函数、代码验证。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值