分布式专题-分布式服务治理03-Dubbo源码分析(上篇)

陀螺仪与加速度计的姿态融合——互补滤波 本篇文章我们来讲讲如何将陀螺仪和加速度计的数据结合起来,获取更准确的姿态数据,使用的是互补滤波的方法。 阅读详情

前言

欢迎关注本套Java系列文章,导航地址:Java架构师成长之路

关于Dubbo,本系列文章主要讲三方面内容。前两讲我们已经了解到Dubbo的基本特性,常用配置以及简单了解了一下Dubbo自适应扩展点源码的内容。这一节,就让我们深入走进Dubbo的源码世界的核心,一探究竟吧~

关于Dubbo 的源码,我想从以下几个方面来介绍:

  1. Dubbo Extension扩展点
  2. 服务端的服务发布与注册过程
  3. 消费端初始化过程
  4. 服务端调用过程
  5. Directory
  6. Cluster
  7. LoadBalance

在Dubbo源码分析这一部分,由于篇幅过长,我这里分上下两节来解析这7个方面内容
那么本节作为dubbo源码的第一篇,我们就来说一下服务发布的过程吧~
(注:1. Dubbo Extension扩展点 在上一小节Dubbo常用配置已讲,这里做一个复习)

Tips:本节文末有Dubbo中文注释版的源码哦~

首先,我们从官方下载dubbo的源码到本地,然后我们会发现它的项目结构如下(目前我使用的是3.5.4版本):
在这里插入图片描述
学习源码,第一点就是了解整体架构,源码结构,然后再找入口,逐层分析~
这里引用一下网友的文章:dubbo源码结构目录分析

Dubbo Extension扩展点

Extension自适应扩展点是贯穿整个Dubbo 源码的一个常见技术,所以很重要~ 在上一节,我们基于这段代码:

//根据指定名称获取扩展点
Protocol myProtocol = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension("myProtocol");
//自适应扩展点
Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class). getAdaptiveExtension();

作为入口进行了简单的分析,这里我整理一下上节getAdaptiveExtension的流程图,当做复习,这里就不重复讲解了,有兴趣的可以看我上一篇的关于Dubbo Extension扩展点的介绍~
在这里插入图片描述

服务发布流程

首先我们要明确的是,我们使用Dubbo这款RPC框架,绕不过最重要的两个对象:

  • 服务端 (发布服务,向注册中心注册服务)
  • 消费端 (订阅服务,与服务端建立连接)
  • 注册中心(协调服务端与消费端的中间成员)
  • 监视器 (RPC调用次数和调用时间监控)
    在这里插入图片描述

那么本节,我们主要讲Provider是怎么暴露服务,并向注册中心注册服务的?
首先我们思考:Dubbo的配置文件自定义的标签在Dubbo源码里如何实现?然后是Dubbo如何解析自定义的配置文件以及调用实现客户端与服务端之间的调用呢?

Spring对外留出的扩展

Dubbo是基于Spring 配置来实现服务的发布的,那么一定是基于Spring的扩展来写了一套自己的标签,那么spring是如何解析这些配置呢?
总的来说,就是可以通过Spring的扩展机制来扩展自己的标签。大家在Dubbo配置文件中看到的 <dubbo:registry>、<dubbo:service>等,就是基于Spring做的自定义扩展标签
在这里插入图片描述
在dubbo-config模块下的dubbo-config-spring模块,就是主要来做Spring扩展标签用的:
在这里插入图片描述

要实现自定义扩展,有三个步骤(在Spring中定义了两个接口,用来实现扩展)

  1. DubboNamespaceHandler接口: 注册一堆BeanDefinitionParser,利用他们来进行解析
    在这里插入图片描述
  2. DubboBeanDefinitionParser接口:用于解析配置文件每个里element的内容
    在这里插入图片描述
  3. Spring默认会加载jar包下的META-INF/spring.handlers文件寻找对应的NamespaceHandler

在这里插入图片描述

Dubbo的接入实现

当我们使用Dubbo给出的xml标签,Spring是如何完成解析的呢?

Dubbo中Spring扩展就是使用Spring的自定义类型,在dubbo-config-spring这一模块有两个类,分别对于Spring进行扩展:

  • DubboNamespaceHandler类对于NamespaceHandlerSupport的扩展
    在这里插入图片描述

这里很好理解,就是我们在dubbo配置文件里使用的自定义标签,将所有对应的标签内容转化为对应的Conifg配置类:
比如用户定义了这样的一个配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <!-- 提供方应用信息,用于计算依赖关系 -->
    <dubbo:application name="hello-world-app"/>
    <!-- 使用multicast广播注册中心暴露服务地址 -->
    <dubbo:registry id="zookeeper" address="zookeeper://192.168.200.111:2181" file="d:/dubbo-server" />

    <!-- 声明需要暴露的服务接口 -->
    <dubbo:reference id="demoService"
                     interface="com.test.dubbo.IGpHello"
                     registry="zookeeper"
                     version="1.0.1"/>
</beans>

这里的每个标签名在源码里对应一个配置类

标签名源码配置类名称
dubbo:applicationApplicationConfig.class
dubbo:registryRegistryConfig.class
…xxx.class

我们以<dubbo:application>为例,然后我们看对应application的配置类ApplicationConfig.class:
在这里插入图片描述
这里我就举一例足可说明问题,其他的字段参数可自行参考源码类比。
所以DubboNamespaceHandler类要做的事情就是根据用户配置的dubbo配置文件<dubbo:XXX>,通过new DubboBeanDefinitionParser(parse里面有一个方法处理element的,这段代码很长,暂不贴出),遍历element元素,将值赋予对应的Config类~
在这里插入图片描述

  • DubboBeanDefinitionParser类对于BeanDefinitionParser的扩展

在这里插入图片描述
BeanDefinitionParser全部都使用了DubboBeanDefinitionParser,如果我们想看<dubbo:service>等标签的配置,就直接看DubboBeanDefinitionParser。这个里面主要做了一件事,把不同的配置分别转化成Spring容器中的bean对象

application对应ApplicationConfig
registry对应RegistryConfig
monitor对应MonitorConfig
provider对应ProviderConfig
consumer对应ConsumerConfig
…

为了在Spring启动的时候,也相应的启动provider发布服务注册服务的过程,而同时为了让客户端在启动的时候自动订阅发现服务,加入了两个BeanServiceBean、ReferenceBean。分别继承了ServiceConfig和ReferenceConfig同时还分别实现了InitializingBean、DisposableBean, ApplicationContextAware, ApplicationListener, BeanNameAware

  • InitializingBean 接口为bean提供了初始化方法的方式,它只包括afterPropertiesSet方法,凡是继承该接口的类,在初始化bean的时候会执行该方法。
  • DisposableBean bean被销毁的时候,spring容器会自动执行destory方法,比如释放资源
  • ApplicationContextAware 实现了这个接口的bean,当spring容器初始化的时候,会自动的将ApplicationContext注入进来
  • ApplicationListener ApplicationEvent事件监听,spring容器启动后会发一个事件通知
  • BeanNameAware 获得自身初始化时,本身的bean的id属性

那么基本的实现思路可以整理出来了~

  1. 利用Spring的解析收集xml中的配置信息,然后把这些配置信息存储到serviceConfig中
  2. 调用ServiceConfig的export方法来进行服务的发布和注册

服务发布流程解析

上面简单的梳理了一下dubbo-config-spring 这个模块的整体模型,接下来我们根据源码的思路,看看如何实现服务发布?
ServiceBean继承了InitializingBean,所以重载父类的afterPropertiesSet方法必然优先执行。
ServiceBean是服务发布的切入点,通过afterPropertiesSet方法,调用export()方法进行发布。
在这里插入图片描述
isDelay是做什么用的?
如果dubbo配置文件配置了这样的字段

<dubbo:provider delay="10" />

ServiceBean这里会判断一下

   private boolean isDelay() {
        Integer delay = getDelay();
        ProviderConfig provider = getProvider();
        if (delay == null && provider != null) {
            delay = provider.getDelay();
        }
        return supportedApplicationListener && (delay == null || delay.intValue() == -1);
    }

回过头来看,export为父类ServiceConfig中的方法,所以跳转到SeviceConfig类中的export方法

public class ServiceBean<T> extends ServiceConfig<T> {}

delay的使用

我们看ServiceBean的父类SeviceConfig.export()

   public synchronized void export() {
        if (provider != null) {
            if (export == null) {
                export = provider.getExport();
            }
            if (delay == null) {
                delay = provider.getDelay();
            }
        }
        if (export != null && ! export.booleanValue()) {
            return;
        }
        if (delay != null && delay > 0) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(delay);
                    } catch (Throwable e) {
                    }
                    doExport();
                }
            });
            thread.setDaemon(true);
            thread.setName("DelayExportServiceThread");
            thread.start();
        } else {
            doExport();
        }
    }

Tips : delay由SeviceConfig的父类AbstractServiceConfig定义的Integer字段
我们发现,delay的作用就是延迟暴露,而延迟的方式也很直截了当 Thread.sleep(delay)

  1. export是synchronized修饰的方法。也就是说暴露的过程是原子操作,正常情况下不会出现锁竞争的问题,毕竟初始化过程大多数情况下都是单一线程操作,这里联想到了Spring的初始化流程,也进行了加锁操作,这里也给我们平时设计一个不错的启示:初始化流程的性能调优优先级应该放的比较低,但是安全的优先级应该放的比较高!
  2. 继续看doExport()方法。同样是一堆初始化代码

export的过程

继续看doExport(),最终会调用到doExportUrls()中:

    private void doExportUrls() {
    	//是不是获得注册中心的配置
        List<URL> registryURLs = loadRegistries(true);
        //是不是支持多协议发布
        for (ProtocolConfig protocolConfig : protocols) {
            doExportUrlsFor1Protocol(protocolConfig, registryURLs);
        }
    }

启动一个服务的时候,做了什么事情?
调用注册中心发布服务到zookeeper,启动一个netty

通过debug到protocols处(我之前在配置文件里只配置了一个注册中心的地址)<dubbo:protocol name="dubbo" port="20888" id="dubbo" />
所以protocols处只有一个地址
protocols也是根据配置装配出来的。接下来让我们进入doExportUrlsFor1Protocol方法看看dubbo具体是怎么样将服务暴露出去的

  private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
       // ...部分代码省略,有兴趣的同学可以参考文末中文版源码
       
        //如果scope没有配置或者配置local、remote,dubbo会将服务export到本地,
        // 意思就是:将服务以injvm协议export出去,如果是同一个jvm的应用可以直接通过jvm发起调用,
        // 而不需要通过网络发起远程调用。
        if ("injvm".equals(protocolConfig.getName())) {
            protocolConfig.setRegister(false);
            map.put("notify", "false");
        }
        // 导出服务
        String contextPath = protocolConfig.getContextpath();
        if ((contextPath == null || contextPath.length() == 0) && provider != null) {
            contextPath = provider.getContextpath();
        }
        URL url = new URL(name, host, port, (contextPath == null || contextPath.length() == 0 ? "" : contextPath + "/") + path, map);

        if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
                .hasExtension(url.getProtocol())) {
            url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
                    .getExtension(url.getProtocol()).getConfigurator(url).configure(url);
        }

        String scope = url.getParameter(Constants.SCOPE_KEY);
        //配置为none不暴露
        if (! Constants.SCOPE_NONE.toString().equalsIgnoreCase(scope)) {

            //配置不是remote的情况下做本地暴露 (配置为remote,则表示只暴露远程服务)
            //发布服务
            if (!Constants.SCOPE_REMOTE.toString().equalsIgnoreCase(scope)) {
                exportLocal(url);
            }
            //如果配置不是local则暴露为远程服务.(配置为local,则表示只暴露本地服务)
            //注册服务
            if (! Constants.SCOPE_LOCAL.toString().equalsIgnoreCase(scope) ){
                if (logger.isInfoEnabled()) {
                    logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
                }
                //核心代码 :开始发布
                if (registryURLs != null && registryURLs.size() > 0
                        && url.getParameter("register", true)) {
                    for (URL registryURL : registryURLs) {//
                        url = url.addParameterIfAbsent("dynamic", registryURL.getParameter("dynamic"));
                        URL monitorUrl = loadMonitor(registryURL);
                        if (monitorUrl != null) {
                            url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString());
                        }
                        if (logger.isInfoEnabled()) {
                            logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
                        }
                        //通过proxyFactory来获取Invoker对象
                        Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
                        //注册服务
                        Exporter<?> exporter = protocol.export(invoker);
                        //将exporter添加到list中
                        exporters.add(exporter);
                    }
                } else {
                    Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, url);
                    Exporter<?> exporter = protocol.export(invoker);
                    exporters.add(exporter);
                }
            }
        }
        this.urls.add(url);
    }

看到这里就比较明白dubbo的工作原理了doExportUrlsFor1Protocol方法,先创建两个URL,分别如下
dubbo://192.168.xx.63:20888/com.test.IGHello;
registry://192.168:20888/com.test.IGHello ;

是不是觉得这个URL很眼熟,没错!在注册中心看到的services的providers信息就是这个在上面这段代码中可以看到Dubbo的比较核心的抽象:Invoker, Invoker是一个代理类,从ProxyFactory中生成。

Tips:

  1. Invoker - 执行具体的远程调用(这块后续单独讲)
  2. Protocol – 服务地址的发布和订阅
  3. Exporter – 暴露服务或取消暴露

注册服务

前面讲了dubbo解析配置文件,赋值到对应的配置类,最终走到核心流程,将携带的URL进行注册服务:

	//注册服务-核心流程
      for (URL registryURL : registryURLs) {
            url = url.addParameterIfAbsent("dynamic", registryURL.getParameter("dynamic"));
            URL monitorUrl = loadMonitor(registryURL);
            if (monitorUrl != null) {
                url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString());
            }
            if (logger.isInfoEnabled()) {
                logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
            }
            //step 1 :通过proxyFactory来获取Invoker对象
            Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
            //step 2 :注册服务
            Exporter<?> exporter = protocol.export(invoker);
            //step 3 :将exporter添加到list中
            exporters.add(exporter);
        }

ok,源码到这里开始分剧情介绍了,这里主要是两个步骤:

  • 通过proxyFactory来获取Invoker对象
  • export 注册服务

我们先说export注册服务部分:
protocol来自ServiceConfig私有成员变量:


    private static final Protocol protocol = ExtensionLoader.
            getExtensionLoader(Protocol.class).
            getAdaptiveExtension(); //Protocol$Adaptive

我们之前提到过,protocol 明显是一个自适应扩展点~
实际上这个Protocol得到的应该是一个Protocol$Adaptive。一个自适应的适配器。这个时候,通过protocol.export(invoker),实际上调用的应该是Protocol$Adaptive这个动态类的export方法。我们再看看这段代码(这段代码,在上一节讲dubbo自适应扩展点时,debug时我曾贴出此段代码):

public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol {
    public void destroy() {
        throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }

    public int getDefaultPort() {
        throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }

    public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) throws com.alibaba.dubbo.rpc.RpcException {
        if (arg1 == null) throw new IllegalArgumentException("url == null");
        com.alibaba.dubbo.common.URL url = arg1;
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
        com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
        return extension.refer(arg0, arg1);
    }

    public com.alibaba.dubbo.rpc.Exporter export(com.alibaba.dubbo.rpc.Invoker arg0) throws com.alibaba.dubbo.rpc.RpcException {
        if (arg0 == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
        if (arg0.getUrl() == null)
            throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
        com.alibaba.dubbo.common.URL url = arg0.getUrl();
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
        Protocol extension = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(extName);
        return extension.export(arg0);
    }
}

上面这段代码做两个事情

  1. 从url中获得protocol的协议地址,如果protocol为空,表示已dubbo协议发布服务,否则根据配置的协议类型来发布服务。
    为什么叫基于适配器的扩展点?原因就在:如果我们请求的URL协议是Hession/RMI/…那么就要改代码
    类似于if(“RMI”== URL),else if(“Hession”== URL)…,每个请求的协议都要加一个else if 判断,所以这里通过适配器,封装成统一的register://XXXd地址,自适应转换URL达成效果~
  2. 调用ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(extName)
    这个方法的主要作用是用来获取ExtensionLoader实例代表的扩展的指定实现。已扩展实现的名字作为参数,结合前面学习getExtension的代码.:
@SuppressWarnings("unchecked")
public T getExtension(String name) {
   if (name == null || name.length() == 0)
       throw new IllegalArgumentException("Extension name == null");
   if ("true".equals(name)) {
       return getDefaultExtension();
   }
//判断是否已经缓存过该扩展点
   Holder<Object> holder = cachedInstances.get(name);
   if (holder == null) {
       cachedInstances.putIfAbsent(name, new Holder<Object>());
       holder = cachedInstances.get(name);
   }
   Object instance = holder.get();
   if (instance == null) {
       synchronized (holder) {
            instance = holder.get();
            if (instance == null) {
//createExtension ,创建扩展点
                instance = createExtension(name);
                holder.set(instance);
            }
        }
   }
   return (T) instance;
}

通过debug看一下,此时invoke的携带的URL。
注:在上一小节,我们演示了dubbo的客户端与服务端的demo,这里我启动的的是dubbo的服务端的main函数debug模式:

   public static void main( String[] args )
    {
        Main.main(new String[]{"spring","log4j"});
    }

在这里插入图片描述
这个地址就是我们之前在zk节点上获取到拼接地址!

我们再回来看指定名称的自适应扩展点,那么这里返回的extension实际上是什么呢?
那就要看这里是什么类型的自适应扩展点了?这里明显是指定名称类型的, 当extName为registry的时候,我们不需要再次去阅读这块代码了,直接可以在扩展点中找到相应的实现扩展点[/dubbo-registry-api/src/main/resources/META-INF/dubbo/internal/com.alibaba.dubbo.rpc.Protocol] 配置如下:在这里插入图片描述
因此,此时的extension就是com.alibaba.dubbo.registry.integration.RegistryProtocol,那么意味着,Protocol$Adaptive在最后返回的extension.export(arg0)就是传入的RegistryProtocol,则在step 2:注册服务后,进入RegistryProtocol方法的export:

 public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
        //export invoker
        final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
        //registry provider
        final Registry registry = getRegistry(originInvoker);
        //得到需要注册到zk上的协议地址,也就是dubbo://
        final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
        registry.register(registedProviderUrl);
        // 订阅override数据
        // FIXME 提供者订阅时,会影响同一JVM即暴露服务,又引用同一服务的的场景,因为subscribed以服务名为缓存的key,导致订阅信息覆盖。
        final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
        final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
        overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
        registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
        //保证每次export都返回一个新的exporter实例
        return new Exporter<T>() {
            public Invoker<T> getInvoker() {
                return exporter.getInvoker();
            }
            public void unexport() {
            	try {
            		exporter.unexport();
            	} catch (Throwable t) {
                	logger.warn(t.getMessage(), t);
                }
                try {
                	registry.unregister(registedProviderUrl);
                } catch (Throwable t) {
                	logger.warn(t.getMessage(), t);
                }
                try {
                	overrideListeners.remove(overrideSubscribeUrl);
                	registry.unsubscribe(overrideSubscribeUrl, overrideSubscribeListener);
                } catch (Throwable t) {
                	logger.warn(t.getMessage(), t);
                }
            }
        };
    }

上面又调用了几个方法,接下来我们分析doLocalExport,之后再回到主线剧情,分别来看:

doLocalExport
本地先启动监听服务

  private <T> ExporterChangeableWrapper<T>  doLocalExport(final Invoker<T> originInvoker){
        String key = getCacheKey(originInvoker);
        ExporterChangeableWrapper<T> exporter = (ExporterChangeableWrapper<T>) bounds.get(key);
        if (exporter == null) {
            synchronized (bounds) {
                exporter = (ExporterChangeableWrapper<T>) bounds.get(key);
                if (exporter == null) {
                    final Invoker<?> invokerDelegete = new InvokerDelegete<T>(originInvoker, getProviderUrl(originInvoker));
                    exporter = new ExporterChangeableWrapper<T>((Exporter<T>)protocol.export(invokerDelegete), originInvoker);
                    bounds.put(key, exporter);
                }
            }
        }
        return (ExporterChangeableWrapper<T>) exporter;
    }

上面代码中,protocol代码是怎么赋值的呢?我们看看代码,熟悉吗?是一个依赖注入的扩展点。不熟悉的话,我们再回想一下,在加载扩展点的时候,有一个injectExtension方法,针对已经加载的扩展点中的扩展点属性进行依赖注入。

private Protocol protocol;

public void setProtocol(Protocol protocol) {
    this.protocol = protocol;
}

protocol.export
因此我们知道protocol是一个自适应扩展点,Protocol A d a p t i v e , 然 后 调 用 这 个 自 适 应 扩 展 点 中 的 e x p o r t 方 法 , 这 个 时 候 传 入 的 协 议 地 址 应 该 是 d u b b o : / / 127.0.0.1 / x x x x … 因 此 在 P r o t o c o l Adaptive,然后调用这个自适应扩展点中的export方法,这个时候传入的协议地址应该是 dubbo://127.0.0.1/xxxx… 因此在Protocol Adaptive,然后调用这个自适应扩展点中的export方法,这个时候传入的协议地址应该是dubbo://127.0.0.1/xxxx…因此在ProtocolAdaptive.export方法中,ExtensionLoader.getExtension(Protocol.class).getExtension。应该就是基于DubboProtocol协议去发布服务了吗?如果是这样,那你们太单纯了。
这里并不是获得一个单纯的DubboProtocol扩展点,而是会通过Wrapper对Protocol进行装饰,装饰器分别为: ProtocolFilterWrapper/ ProtocolListenerWrapper; 至于MockProtocol为什么不在装饰器里面呢?大家再回想一下我们在看ExtensionLoader.loadFile这段代码的时候,有一个判断,装饰器必须要具备一个带有Protocol的构造方法,如下:

public ProtocolFilterWrapper(Protocol protocol){
    if (protocol == null) {
        throw new IllegalArgumentException("protocol == null");
    }
    this.protocol = protocol;
}

截止到这里,我们已经知道,Protocol$Adaptive里面的export方法,会调用ProtocolFilterWrapper以及ProtocolListenerWrapper类的方法
这两个装饰器是用来干嘛的呢?我们来分析下

ProtocolFilterWrapper和ProtocolListenerWrapper

  • ProtocolFilterWrapper
    这个类非常重要,dubbo机制里面日志记录、超时等等功能都是在这一部分实现的
    这个类有3个特点:
  1. 它有一个参数为Protocol protocol的构造函数
  2. 它实现了Protocol接口
  3. 它使用责任链模式,对export和refer函数进行了封装,部分代码如下
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
        return protocol.export(invoker);
    }
    return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));
}
public void destroy() {
    protocol.destroy();
}
//buildInvokerChain函数:它读取所有的filter类,利用这些类封装invoker
private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
    Invoker<T> last = invoker;
    List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);//自动激活扩展点,根据条件获取当前扩展可自动激活的实现
    if (filters.size() > 0) {
        for (int i = filters.size() - 1; i >= 0; i --) {
            final Filter filter = filters.get(i);
            final Invoker<T> next = last;
            last = new Invoker<T>() {
                public Class<T> getInterface() {
                    return invoker.getInterface();
                }
                public URL getUrl() {
                    return invoker.getUrl();
                }
                public boolean isAvailable() {
                    return invoker.isAvailable();
                }
                public Result invoke(Invocation invocation) throws RpcException {
                    return filter.invoke(next, invocation);
                }
                public void destroy() {
                    invoker.destroy();
                }
                @Override
                public String toString() {
                    return invoker.toString();
                }
            };
        }
    }
    return last;
}

我们看如下文件: /dubbo-rpc-api/src/main/resources/METAINF/dubbo/internal/com.alibaba.dubbo.rpc.Filter

其实就是对Invoker,通过如下的Filter组装成一个责任链

echo=com.alibaba.dubbo.rpc.filter.EchoFilter
generic=com.alibaba.dubbo.rpc.filter.GenericFilter
genericimpl=com.alibaba.dubbo.rpc.filter.GenericImplFilter
token=com.alibaba.dubbo.rpc.filter.TokenFilter
accesslog=com.alibaba.dubbo.rpc.filter.AccessLogFilter
activelimit=com.alibaba.dubbo.rpc.filter.ActiveLimitFilter
classloader=com.alibaba.dubbo.rpc.filter.ClassLoaderFilter
context=com.alibaba.dubbo.rpc.filter.ContextFilter
consumercontext=com.alibaba.dubbo.rpc.filter.ConsumerContextFilter
exception=com.alibaba.dubbo.rpc.filter.ExceptionFilter
executelimit=com.alibaba.dubbo.rpc.filter.ExecuteLimitFilter
deprecated=com.alibaba.dubbo.rpc.filter.DeprecatedFilter
compatible=com.alibaba.dubbo.rpc.filter.CompatibleFilter
timeout=com.alibaba.dubbo.rpc.filter.TimeoutFilter

这其中涉及到很多功能,包括权限验证、异常、超时等等,当然可以预计计算调用时间等等应该也是在这其中的某个类实现的;这里我们可以看到export和refer过程都会被filter过滤

  • ProtocolListenerWrapper
    在这里我们可以看到export和refer分别对应了不同的Wrapper;export是对应的ListenerExporterWrapper。这块暂时先不去分析,因为这个地方并没有提供实现类。
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
        return protocol.export(invoker);
    }
    return new ListenerExporterWrapper<T>(protocol.export(invoker), 
            Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(ExporterListener.class)
                    .getActivateExtension(invoker.getUrl(), Constants.EXPORTER_LISTENER_KEY)));
}

public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
    if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
        return protocol.refer(type, url);
    }
    return new ListenerInvokerWrapper<T>(protocol.refer(type, url), 
            Collections.unmodifiableList(
                    ExtensionLoader.getExtensionLoader(InvokerListener.class)
                    .getActivateExtension(url, Constants.INVOKER_LISTENER_KEY)));
}

DubboProtocol.export
通过上面的代码分析完以后,最终我们能够定位到DubboProtocol.export方法。我们看一下dubboProtocol的export方法:openServer(url)

public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    URL url = invoker.getUrl();
    
    // export service.
    String key = serviceKey(url);
    DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
    exporterMap.put(key, exporter);
    
    //export an stub service for dispaching event
    Boolean isStubSupportEvent = url.getParameter(Constants.STUB_EVENT_KEY,Constants.DEFAULT_STUB_EVENT);
    Boolean isCallbackservice = url.getParameter(Constants.IS_CALLBACK_SERVICE, false);
    if (isStubSupportEvent && !isCallbackservice){
        String stubServiceMethods = url.getParameter(Constants.STUB_EVENT_METHODS_KEY);
        if (stubServiceMethods == null || stubServiceMethods.length() == 0 ){
            if (logger.isWarnEnabled()){
                logger.warn(new IllegalStateException("consumer [" +url.getParameter(Constants.INTERFACE_KEY) +
                        "], has set stubproxy support event ,but no stub methods founded."));
            }
        } else {
            stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
        }
    }
    //暴露服务
    openServer(url);
   
    return exporter;
}

openServer

private void openServer(URL url) {
    // find server.
    String key = url.getAddress();//192.168.11.156:20880
    //client 也可以暴露一个只有server可以调用的服务。
    boolean isServer = url.getParameter(Constants.IS_SERVER_KEY,true);
    if (isServer) {
       ExchangeServer server = serverMap.get(key);
       if (server == null) {//没有的话就是创建服务
          serverMap.put(key, createServer(url));
       } else {
          //server支持reset,配合override功能使用
          server.reset(url);
       }
    }
}

createServer
创建服务,开启心跳检测,默认使用netty。组装url

private ExchangeServer createServer(URL url) {
    //默认开启server关闭时发送readonly事件
    url = url.addParameterIfAbsent(Constants.CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString());
    //默认开启heartbeat
    url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));
    String str = url.getParameter(Constants.SERVER_KEY, Constants.DEFAULT_REMOTING_SERVER);

    if (str != null && str.length() > 0 && ! ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str))
        throw new RpcException("Unsupported server type: " + str + ", url: " + url);

    url = url.addParameter(Constants.CODEC_KEY, Version.isCompatibleVersion() ? COMPATIBLE_CODEC_NAME : DubboCodec.NAME);
    ExchangeServer server;
    try {
        server = Exchangers.bind(url, requestHandler);
    } catch (RemotingException e) {
        throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
    }
    str = url.getParameter(Constants.CLIENT_KEY);
    if (str != null && str.length() > 0) {
        Set<String> supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();
        if (!supportedTypes.contains(str)) {
            throw new RpcException("Unsupported client type: " + str);
        }
    }
    return server;
}

Exchangers.bind

public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    if (url == null) {
        throw new IllegalArgumentException("url == null");
    }
    if (handler == null) {
        throw new IllegalArgumentException("handler == null");
    }
    url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
    return getExchanger(url).bind(url, handler);
}

getExchanger
通过ExtensionLoader获得指定的扩展点,type默认为header

public static Exchanger getExchanger(URL url) {
  //url中获得exchanger, 默认为header
    String type = url.getParameter(Constants.EXCHANGER_KEY, Constants.DEFAULT_EXCHANGER);
    return getExchanger(type);
}

public static Exchanger getExchanger(String type) {
    return ExtensionLoader.getExtensionLoader(Exchanger.class).getExtension(type);
}

HeaderExchanger.bind
调用headerExchanger的bind方法

public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
}

Transporters.bind
通过transporter.bind来进行绑定。

public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
    if (url == null) {
        throw new IllegalArgumentException("url == null");
    }
    if (handlers == null || handlers.length == 0) {
        throw new IllegalArgumentException("handlers == null");
    }
    ChannelHandler handler;
    if (handlers.length == 1) {
        handler = handlers[0];
    } else {
        handler = new ChannelHandlerDispatcher(handlers);
    }
    return getTransporter().bind(url, handler);
}

NettyTransport.bind
通过NettyTranport创建基于Netty的server服务

public Server bind(URL url, ChannelHandler listener) throws RemotingException {
    return new NettyServer(url, listener);
}

new HeaderExchangeServer
在调用HeaderExchanger.bind方法的时候,是先new一个HeaderExchangeServer. 这个server是干嘛呢? 是对当前这个连接去建立心跳机制

public class HeaderExchangeServer implements ExchangeServer {
  private final ScheduledExecutorService scheduled = Executors.
   newScheduledThreadPool(1,new NamedThreadFactory(
   "dubbo-remoting-server-heartbeat", true));
  // 心跳定时器
  private ScheduledFuture<?> heatbeatTimer;
  // 心跳超时,毫秒。缺省0,不会执行心跳。
  private int heartbeat;
  private int heartbeatTimeout;
  private final Server server;
  private volatile boolean closed = false;

  public HeaderExchangeServer(Server server) {
    //..属性赋值
    //心跳
    startHeatbeatTimer();
  }
    private void startHeatbeatTimer() {
      //关闭心跳定时
      stopHeartbeatTimer();
      if (heartbeat > 0) {
         //每隔heartbeat时间执行一次
          heatbeatTimer = scheduled.scheduleWithFixedDelay(
                  new HeartBeatTask( new HeartBeatTask.ChannelProvider() {
                      //获取channels
                      public Collection<Channel> getChannels() {
                          return Collections.unmodifiableCollection(
                                  HeaderExchangeServer.this.getChannels() );
                      }
                  }, heartbeat, heartbeatTimeout),
                  heartbeat, heartbeat,TimeUnit.MILLISECONDS);
      }
      }
      //关闭心跳定时
      private void stopHeartbeatTimer() {
          try {
              ScheduledFuture<?> timer = heatbeatTimer;
              if (timer != null && ! timer.isCancelled()) {
                  timer.cancel(true);
              }
          } catch (Throwable t) {
              logger.warn(t.getMessage(), t);
          } finally {
              heatbeatTimer =null;
          }
      }

心跳线程HeartBeatTask
在超时时间之内,发送数据
在超时时间在外,是客户端的话,重连;是服务端,那么关闭
服务发布总结
直接从官方网站上扒了一个图过来,好这个图显示的很清楚了。
在这里插入图片描述

通过proxyFactory来获取Invoker对象

前面在ServiceConfig主线上剧情:

  • 通过proxyFactory来获取Invoker对象
  • 注册服务

接下来,我们说看一下通过proxyFactory来获取Invoker对象这一过程

	//注册服务-核心流程
      for (URL registryURL : registryURLs) {
            url = url.addParameterIfAbsent("dynamic", registryURL.getParameter("dynamic"));
            URL monitorUrl = loadMonitor(registryURL);
            if (monitorUrl != null) {
                url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString());
            }
            if (logger.isInfoEnabled()) {
                logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
            }
            //step 1 :通过proxyFactory来获取Invoker对象
            Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
            //step 2 :注册服务
            Exporter<?> exporter = protocol.export(invoker);
            //step 3 :将exporter添加到list中
            exporters.add(exporter);
        }

proxyFactory是什么呢?

private static final ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();

明显是一个扩展点,那此时的proxyFactory实际上是?
在这里插入图片描述
定义在方法上的@Adaptice,所以应该是ProxyFactory$Adaptice
在这里插入图片描述
通过ExtensionLoader.createAdaptiveExtensionClass,我们debug一下,拿到了这个
String extName = url.getParameter(“proxy”, “javassist”);

这里的自适应扩展点是根据proxy获取的,如果没有默认是javassist,所以,我们看看配置文件对应的配置
在这里插入图片描述
javassist=com.alibaba.dubbo.rpc.proxy.javassist.JavassistProxyFactory

所以看com.alibaba.dubbo.rpc.proxy.javassist.JavassistProxyFactory
在这里插入图片描述
也就是说:

Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));

这一步,获取Invoker是在JavassistProxyFactory实现的!同样,如果是debug也是证实我们的猜想:
在这里插入图片描述
接下来,看看Wrapper.getWrapper里面做了什么事情?

   public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
        // TODO Wrapper类不能正确处理带$的类名
        final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
        return new AbstractProxyInvoker<T>(proxy, type, url) {
            @Override
            protected Object doInvoke(T proxy, String methodName,
                                      Class<?>[] parameterTypes,
                                      Object[] arguments) throws Throwable {
                return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
            }
        };
    }

在这里插入图片描述这里我们断点看一下,动态生成的Wrapper:
在这里插入图片描述
我这里拿出c3:
在这里插入图片描述
取到服务端的服务了~

接下来回到主线:
在这里插入图片描述
也证实了我们之前的猜想,此时通过动态生成的invoke的对象是JavassistProxyFactory,然后,此时主线剧情就是:
拼装好URL,并且通过代理拿到服务端的实例,接下来export到网络层传输服务~
这一小段总结:
在这里插入图片描述

服务注册流程

前面,我们已经知道,基于Spring这个解析入口,到发布服务的过程,接着基于DubboProtocol去发布,最终调用Netty的api创建了一个NettyServer。
那么继续沿着RegistryProtocol.export这个方法,来看看注册服务的代码

RegistryProtocol.export

public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
    //export invoker
    final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker); //发布本地服务
    //registry provider
    final Registry registry = getRegistry(originInvoker);
    final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
    registry.register(registedProviderUrl);
    // 订阅override数据
    // FIXME 提供者订阅时,会影响同一JVM即暴露服务,又引用同一服务的的场景,因为subscribed以服务名为缓存的key,导致订阅信息覆盖。
    final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
    final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
    overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
    registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
    //保证每次export都返回一个新的exporter实例
    return new Exporter<T>() {
        public Invoker<T> getInvoker() {
            return exporter.getInvoker();
        }
        public void unexport() {
           try {
              exporter.unexport();
           } catch (Throwable t) {
               logger.warn(t.getMessage(), t);
            }
            try {
               registry.unregister(registedProviderUrl);
            } catch (Throwable t) {
               logger.warn(t.getMessage(), t);
            }
            try {
               overrideListeners.remove(overrideSubscribeUrl);
               registry.unsubscribe(overrideSubscribeUrl, overrideSubscribeListener);
            } catch (Throwable t) {
               logger.warn(t.getMessage(), t);
            }
        }
    };
}

Tips:前面我提到的doLocalExport这个方法到这里,算是将服务发布的流程讲完,现在我们回到主线,看看另外一个重要的步骤:服务注册getRegistry~
getRegistry
这个方法是invoker的地址获取registry实例

/**
 * 根据invoker的地址获取registry实例
 * @param originInvoker
 * @return
 */
private Registry getRegistry(final Invoker<?> originInvoker){
    URL registryUrl = originInvoker.getUrl(); //获得registry://192.168.200.111:2181的协议地址
    if (Constants.REGISTRY_PROTOCOL.equals(registryUrl.getProtocol())) {
//得到zookeeper的协议地址
        String protocol = registryUrl.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_DIRECTORY);
        //registryUrl就会变成了zookeeper://192.168.200.111
registryUrl = registryUrl.setProtocol(protocol).removeParameter(Constants.REGISTRY_KEY);
    }
//registryFactory是什么?
    return registryFactory.getRegistry(registryUrl);
}

registryFactory.getRegistry
这段代码很明显了,通过前面这段代码的分析,其实就是把registry的协议头改成服务提供者配置的协议地址,也就是我们配置的

<dubbo:registry address=”zookeeper://192.168.200.111:2181”/>

然后registryFactory.getRegistry的目的,就是通过协议地址匹配到对应的注册中心。那registryFactory是一个什么样的对象呢?,我们找一下这个代码的定义

private RegistryFactory registryFactory;

public void setRegistryFactory(RegistryFactory registryFactory) {
    this.registryFactory = registryFactory;
}

这个代码有点眼熟,再来看看RegistryFactory这个类的定义,我猜想一定是一个扩展点,不信,咱们看
并且,大家还要注意这里面的一个方法上,有一个@Adaptive的注解,说明什么? 这个是一个自适应扩展点。按照我们之前看过代码,自适应扩展点加在方法层面上,表示会动态生成一个自适应的适配器。所以这个自适应适配器应该是RegistryFactory$Adaptive

@SPI("dubbo")
public interface RegistryFactory {

    /**
     * 连接注册中心.
     * 
     * 连接注册中心需处理契约:<br>
     * 1. 当设置check=false时表示不检查连接,否则在连接不上时抛出异常。<br>
     * 2. 支持URL上的username:password权限认证。<br>
     * 3. 支持backup=10.20.153.10备选注册中心集群地址。<br>
     * 4. 支持file=registry.cache本地磁盘文件缓存。<br>
     * 5. 支持timeout=1000请求超时设置。<br>
     * 6. 支持session=60000会话超时或过期设置。<br>
     * 
     * @param url 注册中心地址,不允许为空
     * @return 注册中心引用,总不返回空
     */
    @Adaptive({"protocol"})
    Registry getRegistry(URL url);

}

RegistryFactory$Adaptive

我们拿到这个动态生成的自适应扩展点,看看这段代码里面的实现

  1. 从url中拿到协议头信息,这个时候的协议头是zookeeper://
  2. 通过ExtensionLoader.getExtensionLoader(RegistryFactory.class).getExtension(“zookeeper”)去获得一个指定的扩展点,而这个扩展点的配置在
    dubbo-registry-zookeeper/resources/META-INF/dubbo/internal/com.alibaba.dubbo.registry.RegistryFactory。得到一个ZookeeperRegistryFactory
public class RegistryFactory$Adaptive implements com.alibaba.dubbo.registry.RegistryFactory {
    public com.alibaba.dubbo.registry.Registry getRegistry(com.alibaba.dubbo.common.URL arg0) {
        if (arg0 == null) throw new IllegalArgumentException("url == null");
        com.alibaba.dubbo.common.URL url = arg0;
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.registry.RegistryFactory) " +
                    "name from url(" + url.toString() + ") use keys([protocol])");
        com.alibaba.dubbo.registry.RegistryFactory extension =
                (com.alibaba.dubbo.registry.RegistryFactory)
                        ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.registry.RegistryFactory.class).
                                getExtension(extName);
        return extension.getRegistry(arg0);
    }
}

ZookeeperRegistryFactory
这个方法中并没有getRegistry方法,而是在父类AbstractRegistryFactory

  1. 从缓存REGISTRIES中,根据key获得对应的Registry
  2. 如果不存在,则创建Registry
public Registry getRegistry(URL url) {
   url = url.setPath(RegistryService.class.getName())
         .addParameter(Constants.INTERFACE_KEY, RegistryService.class.getName())
         .removeParameters(Constants.EXPORT_KEY, Constants.REFER_KEY);
   String key = url.toServiceString();
    // 锁定注册中心获取过程,保证注册中心单一实例
    LOCK.lock();
    try {
        Registry registry = REGISTRIES.get(key);
        if (registry != null) {
            return registry;
        }
        registry = createRegistry(url);
        if (registry == null) {
            throw new IllegalStateException("Can not create registry " + url);
        }
        REGISTRIES.put(key, registry);
        return registry;
    } finally {
        // 释放锁
        LOCK.unlock();
    }
}

createRegistry
创建一个注册中心,这个是一个抽象方法,具体的实现在对应的子类实例中实现的,在ZookeeperRegistryFactory中

public Registry createRegistry(URL url) {
       return new ZookeeperRegistry(url, zookeeperTransporter);
   }
通过zkClient,获得一个zookeeper的连接实例
public ZookeeperRegistry(URL url, ZookeeperTransporter zookeeperTransporter) {
    super(url);
    if (url.isAnyHost()) {
      throw new IllegalStateException("registry address == null");
   }
    String group = url.getParameter(Constants.GROUP_KEY, DEFAULT_ROOT);
    if (! group.startsWith(Constants.PATH_SEPARATOR)) {
        group = Constants.PATH_SEPARATOR + group;
    }
    this.root = group; //设置根节点
    zkClient = zookeeperTransporter.connect(url);//建立连接
      zkClient.addStateListener(new StateListener() {
        public void stateChanged(int state) {
           if (state == RECONNECTED) {
           try {
      recover();
   } catch (Exception e) {
      logger.error(e.getMessage(), e);
   }
           }
        }
    });
}

代码分析到这里,我们对于getRegistry得出了一个结论,根据当前注册中心的配置信息,获得一个匹配的注册中心,也就是ZookeeperRegistry

registry.register(registedProviderUrl);
好的,拿到了ZookeeperRegistry我们回到export主线,往下分析:

  public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
        // step 1 : export invoker
        final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
        //step 2 : registry provider
        final Registry registry = getRegistry(originInvoker);
        //得到需要注册到zk上的协议地址,也就是dubbo://
        final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
        registry.register(registedProviderUrl);
        // 订阅override数据
        // FIXME 提供者订阅时,会影响同一JVM即暴露服务,又引用同一服务的的场景,因为subscribed以服务名为缓存的key,导致订阅信息覆盖。
        final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
        final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
        overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
        registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
        //保证每次export都返回一个新的exporter实例
        return new Exporter<T>() {
            public Invoker<T> getInvoker() {
                return exporter.getInvoker();
            }
            public void unexport() {
            	try {
            		exporter.unexport();
            	} catch (Throwable t) {
                	logger.warn(t.getMessage(), t);
                }
                try {
                	registry.unregister(registedProviderUrl);
                } catch (Throwable t) {
                	logger.warn(t.getMessage(), t);
                }
                try {
                	overrideListeners.remove(overrideSubscribeUrl);
                	registry.unsubscribe(overrideSubscribeUrl, overrideSubscribeListener);
                } catch (Throwable t) {
                	logger.warn(t.getMessage(), t);
                }
            }
        };
    }

会调用registry.register去讲dubbo://的协议地址注册到zookeeper上.
这个方法会调用FailbackRegistry类中的register. 为什么呢?因为ZookeeperRegistry这个类中并没有register这个方法,但是他的父类FailbackRegistry中存在register方法,而这个类又重写了AbstractRegistry类中的register方法。所以我们可以直接定位FailbackRegistry这个类中的register方法中

FailbackRegistry.register

  1. FailbackRegistry,从名字上来看,是一个失败重试机制
  2. 调用父类的register方法,讲当前url添加到缓存集合中
  3. 调用doRegister方法,这个方法很明显,是一个抽象方法,会由ZookeeperRegistry子类实现。
@Override
public void register(URL url) {
    super.register(url);
    failedRegistered.remove(url);
    failedUnregistered.remove(url);
    try {
        // Core!!  -> 向服务器端发送注册请求
        doRegister(url);
    } catch (Exception e) {
        Throwable t = e;

        // 如果开启了启动时检测,则直接抛出异常
        boolean check = getUrl().getParameter(Constants.CHECK_KEY, true)
                && url.getParameter(Constants.CHECK_KEY, true)
                && ! Constants.CONSUMER_PROTOCOL.equals(url.getProtocol());
        boolean skipFailback = t instanceof SkipFailbackWrapperException;
        if (check || skipFailback) {
            if(skipFailback) {
                t = t.getCause();
            }
            throw new IllegalStateException("Failed to register " + url + " to registry " + getUrl().getAddress() + ", cause: " + t.getMessage(), t);
        } else {
            logger.error("Failed to register " + url + ", waiting for retry, cause: " + t.getMessage(), t);
        }
        // 将失败的注册请求记录到失败列表,定时重试
        failedRegistered.add(url);
    }
}

ZookeeperRegistry.doRegister
这里才是真正的向服务器端发送注册请求 doRegister(url);
终于找到你了,调用zkclient.create在zookeeper中创建一个节点。

protected void doRegister(URL url) {
    try {
       zkClient.create(toUrlPath(url), url.getParameter(Constants.DYNAMIC_KEY, true));
    } catch (Throwable e) {
        throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
    }
}

后记

欢迎关注本套Java系列文章-地址导航:Java架构师成长之路

Dubbo中文注释版:DubboV2.5.4下载地址

ubuntu20.04升级OpenSSH 业务需求,需要将服务器的OpenSSH版本从8.2升级到最新版本(9.9),由于apt能提供的最新版本就是8.2,所以需要采用源码安装的方式。 阅读详情

相关推荐

聚类教程:cisTopic——来自单细胞表观基因组学数据的顺式调控主题的概率建模

之前运行这步的时候报错了如下: 后来发现原因是Ubuntu自动把R包更新到4.2版本,但是Rstudio版本没有更新,更新Rstudio即可,更新Rstudio的教程看此教程:。

watermel__的博客 1058

Dubbo源码分析

什么是Dubbo? Dubbo一开始是由阿里巴巴开发,后面贡献给了Apache,所以后面我们称之为Apache Dubbo或者直接叫Dubbo。 Dubbo 是一款高性能、轻量级的开源服务框架 。 先纠正读法: 错误读法:diubo、dubo 正确读法:|ˈdʌbəʊ| Dubbo的六大核心能力 面向接口代理的高性能RPC调用 智能容错和负载均衡 服务自动注册和发现 高度可扩展能力 运行期流量调度 可视化的服务治理与运维。 开发中,我们都喜欢把Dubbo简称为RPC开源框架。 什么是R

qfzhaohan的博客 3128

MDT部署实战:除了Office,这些“装机必备”软件也能一键静默安装(含静默参数)

本文详细介绍了如何利用Microsoft Deployment Toolkit(MDT)实现企业级软件的静默安装,包括浏览器、开发工具和系统增强工具等“装机必备”软件的部署方案。通过命令行参数和MSI属性,IT运维团队可以高效构建标准化工作环境,提升部署效率并确保版本一致性。文章还提供了安装顺序控制、结果验证和常见问题排错等高级技巧。

weixin_26985923的博客 172

dubbo源码解析

dubbo源码解析-网络通信 在之前的内容中,我们讲解了消费者端服务发现与提供者端服务暴露的相关内容,同时也知道消费者端通过内置的负载均衡算法获取合适的调用invoker进行远程调用。那么,本章节重点关注的就是远程调用过程即网络通信。 网络通信位于Remoting模块: Remoting 实现是 Dubbo 协议的实现,如果你选择 RMI 协议,整个 Remoting 都不会用上; Remoting 内部再划为 Transport 传输层 和 Exchange 信息交换层; Transport 层

分享Java技术知识,共同成长进步! 3313

Mplus实战:随机截距交叉滞后模型(RI-CLPM)在心理学纵向研究中的进阶应用

本文深入探讨了随机截距交叉滞后模型(RI-CLPM)在心理学纵向研究中的进阶应用,通过Mplus实战演示了模型设定、结果解读及进阶建模策略。RI-CLPM能有效区分个体间差异和个体内变化,适用于追踪青少年手机使用与抑郁症状等研究。文章还提供了样本量规划、模型比较和结果可视化等实用技巧,助力研究者避免常见陷阱。

weixin_29220405的博客 373

FastAPI + LLM 实战:5分钟搞定本地模型API服务部署(含避坑指南)

本文详细介绍了如何使用FastAPI和LLM(大语言模型)快速部署本地API服务,涵盖环境准备、模型集成、性能优化及避坑指南。通过实战示例,帮助开发者在5分钟内完成从零到生产的部署过程,提升AI应用开发效率。

weixin_29062963的博客 116

Dubbo源码解析(一)

在分布式服务架构下,各个服务间的相互rpc 调用会越来越复杂。最终形成网状结构,此时服务的治理极为关键。Dubbo 是一个带有服务治理功能的RPC 框架,提供了一套较为完整的服务治理方案,其底层直接实现了rpc 调用的全过程,并尽力做事rpc 远程对使用者透明。简单的说,Dubbo 就是个服务调用的框架,如果没有分布式的需求,其实是不需要用的,只有在分布式的时候,才有使用Dubbo 这样的分布式服务框架的需求,并且本质上是个服务调用的东西。

qq_40228720的博客 1277

打穿内网之Vulntarget-a靶场实战记录

内容包括:通达OA未授权上传+文件包含RCE、Redis未授权写马、ms17-010永恒之蓝、代理转发内网跳板、CVE-2020-1472 域控杀器Zerologon、wmiexec/smbexec横向移动、cobalt strike与msf的shell传递

tpaer的博客 3036

Dubbo底层源码解析

目录 1、Dubbo核心模块职责介绍 2、源码基础 2.1 SPI自适应 2.2 Netty实现简易Dubbo 3、标签解析 3.1 标签属性配置 3.2 配置渊源 4、服务暴露 4.1 服务暴露启动逻辑 4.2 参数检查 4.3 组装url 4.4 服务暴露分类 4.5 服务暴露 4.6 服务注册 5、服务发现 5.1 服务发现原理 5.2 服务引用入口 5.3 创建代理 5.4 代理调用 1、Dubbo核心模块职责介绍 Dubbo发展到现在,已经有3.0版.

长沙老码农 3948

子图同构之乌尔曼算法Ullmann Algorithm的python实现

给定两个图Ga​(子图)和Gb​(原图),其中Ga​有pa​个点和qa​条边,Gb​有pb​个点和qb​条边,其邻接矩阵分别为A和B。子图同构的关键在于找到一种从Ga​的点到Gb​的点的映射MM是一个pa​行pb​列的矩阵,且满足每行只有一个1(表示Ga​中的一个点唯一地映射到Gb​中的一个点),每列至多一个1(确保Gb​中的点不会被重复映射)。定义Ccij​MMBT,若在图Ga​。

weixin_42822813的博客 1975

YOLOV5 自动刷图脚本实战(十五)之如何找到正确的门

DXF是一个2D游戏,我们所看到的人物移动,其实是后面的背景在移动,我们所看到的画面,不过是一个完整背景中的一个镜头视角而已想要正确找到门的坐标,我们需要对不同的地图中的每个房间做一些配置信息。

qq_38892949的博客 2814

朝花夕拾---dubbo源码分析

dubbo主流程源码解析

qq_39203337的博客 2511

【WorkBuddy专栏53】我的WB为什么变聪明了——SOUL与USER配置管理实战(上)

【WorkBuddy专栏53】我的WB为什么变聪明了——SOUL与USER配置管理实战(上)

AI人人懂 254

第三阶段、分布式架构设计&微服务深入剖析

该阶段为分布式学习提供理论基础,如分布式一致性协议Paxos、远程过程调用RPC等,并对分布式中间件Dubbo和SpringCloud进行深入剖析。 模块一、分布式理论、架构设计(自定义RPC) 本模块会对分布式架构的理论、架构设计、网络通信等进行讲解,并设计一个RPC远程过程调用框架并进行代码编写。 模块二、分布式服务治理、分布式协调服务Zookeeper深入 本模块会对分布式治理中遇到的问题,例如权重、降级、容错路由等进行讲解,并对分布式协调服务Zookeeper进行系统的说明。 模块三、高性能RPC框

qq_42082278的博客 819

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

2020-11-16

目录导航 前言 一、源码分析专题 1.1 设计模式详解 1.2 Mybatis源码分析 1.3 Spring5源码分析 二、分布式架构专题 2.1 漫谈分布式架构 2.2 分布式架构的基础 2.3 分布式通信框架 2.4 分布式协调服务 2.5 分布式服务治理 2.6 分布式消息通信之ActiveMQ 2.7 分布式消息通信之Kafka 2.8 分布式消息通信之RabbitMQ 2.9 分布式缓存技术之Mon

IT的鱼 289

全球国家地区城市数据

MySQL全球国家地区城市数据报。。。。。。。。。。。。

工作一到五年的Java程序员遇到瓶颈应该如何提升自己突破

工作一到五年的Java程序员遇到瓶颈应该如何提升自己突破 具有一到五年开发经验 需要学习内容很多 JVM/分布式/高并发/性能优化/Spring MVC/Spring Boot/Spring Cloud/MyBatis/Netty源码分析等 01、透彻理解Tomcat原理手写动静态资源的实现 02、分享能源领域的分布式监测系统架构 03、分布式系统关键技术Rpc框架详解与实现 04、自己写一...

u014344668的专栏 535

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

【系列文章合集】【全部系列文章合集】

本篇作为一个合集的合集,整理各个系列文章内容(因为有时候我自己也忘了自己写了哪部分内容),仅做合集记录,不定期更新。

猫吻鱼的博客 532

有经验的Java程序员如何提升自己,才能达到年薪30万的水准?

01、透彻理解Tomcat原理手写动静态资源的实现 02、分享能源领域的分布式监测系统架构 03、分布式系统关键技术Rpc框架详解与实现 04、自己写一个SpringMVC框架 05、使用Jsoup实现网页爬虫功能 06、JAVA高级进阶之NIO通信架构原理详解 07、高手必过之路透彻理解Spring容器IOC的原理分析 08、并发编程之深入业务隔离场景原理详解 09、深入浅出Java虚拟机 10...

weixin_34343308的博客 227

五年开发经验

具有一到五年开发经验 需要学习内容很多  JVM/分布式/高并发/性能优化/Spring MVC/Spring Boot/Spring Cloud/MyBatis/Netty源码分析等等等  01、透彻理解Tomcat原理手写动静态资源的实现  02、分享能源领域的分布式监测系统架构  03、分布式系统关键技术Rpc框架详解与实现  04、自己写一个SpringMVC框架  05、使用

yuanshuai1136的博客 594

JAVA高级进阶笔记汇总

11

neeef_se的博客 227

做 Java 六年还在写业务代码做着 CRUD 的工作?该好好反思自己的情况

面临着要面试,为了改变自己的缺点,每天自己会在小房间里,对着镜子,自己做自我介绍,自己去描述学习的知识点,有时候自己跟自己对话等等吧,最终,顺利的走进了IT行业。为此针对以上技术方向我们有自己的高清思维方向导图以及架构师有自己讲解的架构视频分享(包括高可用,高并发,spring源码,mybatis源码,JVM,大数据,Netty等多个技术知识的架构视频资料和各种电子书籍阅读)工作一到五年的java 开发工程师朋友可以关注我----没事想看点书,最近几个月,看的书的类型有管理方面的,有技术方面的。

m0_73256420的博客 521

Java开发程序员必须知道

前言 在这个行业参加工作4年到5年的攻城狮的朋友们,相信你在自己所钻研的领域已经有了自己一定的见解,这个时候,技术上你应该已经遇到瓶颈了。这个时候不要着急提高自己的技术,已经是时候提高你的影响力了,你可以尝试去一些知名的公司去提高你的背景,你可以发表一些文章去影响更多的人。 当然,你也可以去Github创建一个属于你的开源项目,去打造自己的产品。技术学到这个阶段,很容易遇到瓶颈,而且往往达到一...

我...你知道吗? 的博客 1383

一到五年Java开发经验的程序员如何达到年薪40W?

前言在这个行业参加工作4年到5年的攻城狮的朋友们,相信你在自己所钻研的领域已经有了自己一定的见解,这个时候,技术上你应该已经遇到瓶颈了。这个时候不要着急提高自己的技术,已经是时候提高你的影响力了,你可以尝试去一些知名的公司去提高你的背景,你可以发表一些文章去影响更多的人。当然,你也可以去Github创建一个属于你的开源项目,去打造自己的产品。技术学到这个阶段,很容易遇到瓶颈,而且往往达到一定程度后...

weixin_34406796的博客 130
上一篇: 分布式专题-分布式服务治理02-Dubbo常用配置
下一篇: 分布式专题-分布式服务治理04-Dubbo源码分析(中篇)
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址