一起玩Dubbo，万字长文揭秘服务暴露

[[402876]]

日常写组件，最近又接了一个需求，让我负责实现一个rpc组件，提高公司游戏跨服开发的效率，为了写好这个组件，算是将dubbo里里外外研究了一波，目前组件的实现也接近尾声了，因此打算给dubbo的学习做个总结，并穿插说说rpc实现的心路历程，同样需要实现rpc的朋友，或者对dubbo有兴趣的朋友可以关注这个系列。

在写rpc组件之前，我先提了几个灵魂疑问，并从dubbo中找到了答案。

• 服务是啥?

一个模块，一种玩法，只要是需要进行远程调度的都可以用服务的概念进行包装，我这边简单包装了一个副本服务，类情况如下：

 

平平无奇，等等，我们来看看提供方如何标记服务

 

到了这一步，服务已经完成了基本定义。

• 服务最终被注册到了那里?

在xml配置上，我们已经看到了有注册中心的配置

 

没错，最后提供方定义好的服务会注册到注册中心，目前支持的类型有多种

 

具体可以查看里边提供的demo实例，那么注册中心有什么作用呢?

简单点描述就是注册中心就是管理服务的地方，提供方将服务放到了这个管理处，而订阅方要用的话则从这个管理处将服务拿过来用，通过注册中心实现了服务的感知。

• 服务谁来消费?

消费方来使用，我们可以看到

 

同样也是平平无奇的代码，就是消费方拿到boss接口后，直接调用对应接口即可。

对应提供方有xml去定义服务的注册，同样消费方也是有xml去定义服务的订阅信息，可以看到

 

简单来说就是，提供方将服务放到注册中心，订阅方从注册中心拿来用。

接下来会涉及到源码部分，以下源码的示例接来自dubbo2.6x，源码方面的注释都已经提交到github上，有需要的可以clone：

https://github.com/wiatingpub/dubbo/tree/2.6.x

什么时候触发的服务暴露

在设计rpc组件的时候，不得不面对这个问题，本着抄dubbo的想法，研究了下dubbo的实现方案

dubbo采用了比较经典的xml配置，并理所当然的使用了NamespaceHandlerSupport将xml中的节点配置映射成了对应对象

可以看到在dubbo-config-spring包底下有个spring.handlers的配置，通过该配置指定了DubboNamespaceHandler

 

DubboNamespaceHandler会将xml配置对应标签的配置映射成对象，比如service

 

 

看看ServiceBean在映射成对象后做了啥，先看看ServiceBean结构

 

自身是一个监听器，再通过CTRL+F12看看有哪些方法

 

看到export暴露这个方法后，ALT+F7反调下发现除了注解Annoatition外有两个地方调用，分别是

 

第一种是在属性被设置后调用，可以看到如果是延迟函数则不会调用。

 

第二种是看到isDelay的时候才会调用export，也就是说延迟暴露的服务是在监听到ContextRefreshedEvent事件后进行调用的。

在export方法内可以看到

 

可以针对不同的服务配置配置delay延迟时间，具体的肯定是在xml上配置了。

触发机制到这里基本就结束了，总结一下dubbo的触发机制就是建立在NamespaceHandlerSupport上，将xml中的标签实例化，并通过在afterPropertiesSet或者在监听到Spring容器抛出的容器刷新事件后，触发服务的暴露。

画个流程图总结下

 

由于我司这边的服务配置最终落地在使用yaml方案上，不引入xml，最终我并没有使用NamespaceHandlerSupport去实例化，而是模仿dubbo3.0的方案包装了一个ServiceBootstrap对象，依赖SmartLifeCycle的生命周期，在start的时候取到yaml的配置，遍历进行服务暴露。dubbo3.0做了比较大调整，后续会专门讲，有兴趣的持续关注该系列。

提一波URL

在说服务暴露之前必须先提一波URL，否则主线没了，后续不好讲。

在我没有接触到dubbo之前，我对URL的定位是指网络地址，而在dubbo中，可以认为是一种约定，几乎dubbo的所有模块都是通过URL来传参，这有什么好处呢?

我们可以想想，如果没有约定好，那么不同的接口之间进行交互的参数便会乱掉，一会是字符串，一会是map，而有了统一的约定后，代码便会更加的规范和统一，我们在看代码的时候也会比较清晰，也容易拓展，比如如果你想拓展什么东西，直接往URL上拼接参数就可以了。

我们可以看到，除了几个基础的参数外，很多参数其实最终都放到了parameters中。

而在我司项目中，我们参考了URL的设计，构建了元数据的结构，也就是map，将服务的部分动态参数通过map进行传递。

服务暴露过程

在深入源码之前先大概总结下服务暴露的几个步骤，分别是：

1. 配置的构建、合并、检查。
2. URL的组装。
3. 服务的暴露、注册。

我将这三个主要的过程放入流程图内

继续跟进服务暴露的具体逻辑，也就是doExport后

protected synchronized void doExport() { 
    if (unexported) { 
        throw new IllegalStateException("Already unexported!"); 
    } 
    if (exported) { 
        return; 
    } 
    exported = true; 
    if (interfaceName == null || interfaceName.length() == 0) { 
        throw new IllegalStateException("<dubbo:service interface=\"\" /> interface not allow null!"); 
    } 
    // TODO: 2021/5/27 检查provider是否为空，为空则创建一个，并通过系统变量为其初始化 
    checkDefault(); 
 
    /** 各种初始值的设置 **/ 
     
    // TODO: 2021/5/27 检查Application是否为空 
    checkApplication(); 
    // TODO: 2021/5/27 检查注册中心是否为空 
    checkRegistry(); 
    // TODO: 2021/5/27 检查protocols是否为空 
    checkProtocol(); 
    // TODO: 2021/5/27 补充各种参数 
    appendProperties(this); 
    // TODO: 2021/5/27 Stub合法性检查 
    checkStub(interfaceClass); 
    // TODO: 2021/5/27 mock合法性检查 
    checkMock(interfaceClass); 
    if (path == null || path.length() == 0) { 
        path = interfaceName; 
    } 
    // TODO: 2021/5/27 多协议多注册中心暴露服务 
    doExportUrls(); 
    ProviderModel providerModel = new ProviderModel(getUniqueServiceName(), this, ref); 
    ApplicationModel.initProviderModel(getUniqueServiceName(), providerModel); 
} 

总结下来不外乎两步：

• 对各类配置进行校验，并且更新部分配置;
• 多协议多注册中心暴露服务;

其中检查的细节暂时不铺开，因为服务暴露整个过程才是重点，后续服务治理了再重新讲这块，接下来继续讲重点doExportUrls方法

@SuppressWarnings({"unchecked", "rawtypes"}) 
private void doExportUrls() { 
    // TODO: 2021/5/27 加载注册中心URL  
    List<URL> registryURLs = loadRegistries(true); 
    for (ProtocolConfig protocolConfig : protocols) { 
        // TODO: 2021/5/27 根据不同协议进行服务暴露  
        doExportUrlsFor1Protocol(protocolConfig, registryURLs); 
    } 
} 

loadRegistries也很简单，其实就是根据注册中心的配置组装成URL，这里多个注册中心比较好理解，多个protocols是什么鬼呢?

其实是这样的，一个服务如果有多个协议那么就都需要暴露，比如同时支持 dubbo 协议和 hessian 协议，那么需要将这个服务用两种协议分别向多个注册中心暴露注册。

参考了这块逻辑，在我司项目中，我们规范了注册中心的接口，允许注册中心有多种实现， 甚至是本地注册中心，但是并不允许有多个注册中心，目前来说是没有这种需求，而要选择哪个注册中心，只需要在yaml文件上进行配置即可

接下来看doExportUrlsFor1Protocol方法

在分析服务暴露流程之前便有提到过，dubbo内部使用URL来携带各类数据，从而贯穿整个生命周期的，而入口其实就是从这个方法开始的，等下我们便可以看到该方法可以分为两个步骤，前个步骤是组装URL的逻辑，后个步骤是真正实现暴露dubbo服务等逻辑的地方，不说了，继续code

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) { 
    /**组装服务的URL开始**/ 
    // TODO: 2021/5/27 获取协议名 
    String name = protocolConfig.getName(); 
    // TODO: 2021/5/27 如果为空，则默认是dubbo 
    if (name == null || name.length() == 0) { 
        name = "dubbo"; 
    } 
 
    // TODO: 2021/5/27 设置map等各种参数 
    Map<String, String> map = new HashMap<String, String>(); 
    map.put(Constants.SIDE_KEY, Constants.PROVIDER_SIDE); 
    map.put(Constants.DUBBO_VERSION_KEY, Version.getProtocolVersion()); 
    map.put(Constants.TIMESTAMP_KEY, String.valueOf(System.currentTimeMillis())); 
    if (ConfigUtils.getPid() > 0) { 
        map.put(Constants.PID_KEY, String.valueOf(ConfigUtils.getPid())); 
    } 
    // TODO: 2021/5/27 添加application、module、provider等信息到map中 
    appendParameters(map, application); 
    appendParameters(map, module); 
    appendParameters(map, provider, Constants.DEFAULT_KEY); 
    appendParameters(map, protocolConfig); 
    appendParameters(map, this); 
    // TODO: 2021/5/27 如果methods的配置列表不为空，则遍历methods配置列表 
    if (methods != null && !methods.isEmpty()) { 
        for (MethodConfig method : methods) { 
            // TODO: 2021/5/27 把方法名加入map 
            appendParameters(map, method, method.getName()); 
            // TODO: 2021/5/27 添加methodconfig对象的字段信息到map中 
            String retryKey = method.getName() + ".retry"; 
            if (map.containsKey(retryKey)) { 
                String retryValue = map.remove(retryKey); 
                if ("false".equals(retryValue)) { 
                    map.put(method.getName() + ".retries", "0"); 
                } 
            } 
            // TODO: 2021/5/27 添加ArgumentConfig列表 
            List<ArgumentConfig> arguments = method.getArguments(); 
            if (arguments != null && !arguments.isEmpty()) { 
                for (ArgumentConfig argument : arguments) { 
                    // convert argument type 
                    if (argument.getType() != null && argument.getType().length() > 0) { 
                        // TODO: 2021/5/27 利用反射拿到接口类的所有方法 
                        Method[] methods = interfaceClass.getMethods(); 
                        if (methods != null && methods.length > 0) { 
                            // TODO: 2021/5/27 遍历methods 
                            for (int i = 0; i < methods.length; i++) { 
                                String methodName = methods[i].getName(); 
                                // TODO: 2021/5/27 找到目标方法 
                                if (methodName.equals(method.getName())) { 
                                    // TODO: 2021/5/27 通过反射拿到方法参数类型 
                                    Class<?>[] argtypes = methods[i].getParameterTypes(); 
                                    // TODO: 2021/5/27 如果下表为-1 
                                    if (argument.getIndex() != -1) { 
                                        // TODO: 2021/5/27 检测argtypes的名称与ArgumentConfig中的type是否一致 
                                        if (argtypes[argument.getIndex()].getName().equals(argument.getType())) { 
                                            appendParameters(map, argument, method.getName() + "." + argument.getIndex()); 
                                        } else { 
                                            // TODO: 2021/5/27 不一致则抛出异常 
                                            throw new IllegalArgumentException("argument config error : the index attribute and type attribute not match :index :" + argument.getIndex() + ", type:" + argument.getType()); 
                                        } 
                                    } else { 
                                        // TODO: 2021/5/27 遍历参数，查找argument.type的类型 
                                        for (int j = 0; j < argtypes.length; j++) { 
                                            Class<?> argclazz = argtypes[j]; 
                                            // TODO: 2021/5/27 如果找得到则将ArgumentConfig字段添加map中 
                                            if (argclazz.getName().equals(argument.getType())) { 
                                                appendParameters(map, argument, method.getName() + "." + j); 
                                                if (argument.getIndex() != -1 && argument.getIndex() != j) { 
                                                    throw new IllegalArgumentException("argument config error : the index attribute and type attribute not match :index :" + argument.getIndex() + ", type:" + argument.getType()); 
                                                } 
                                            } 
                                        } 
                                    } 
                                } 
                            } 
                        } 
                    } else if (argument.getIndex() != -1) { 
                        // TODO: 2021/5/27 用户未配置type属性，但配置了index属性，且index != -1，则直接添加到map中 
                        appendParameters(map, argument, method.getName() + "." + argument.getIndex()); 
                    } else { 
                        throw new IllegalArgumentException("argument config must set index or type attribute.eg: <dubbo:argument index='0' .../> or <dubbo:argument type=xxx .../>"); 
                    } 
 
                } 
            } 
        } // end of methods for 
    } 
 
    // TODO: 2021/5/27 如果是泛化调用，则在map中设置generic和methods 
    if (ProtocolUtils.isGeneric(generic)) { 
        map.put(Constants.GENERIC_KEY, generic); 
        map.put(Constants.METHODS_KEY, Constants.ANY_VALUE); 
    } else { 
        // TODO: 2021/5/27 获得版本号 
        String revision = Version.getVersion(interfaceClass, version); 
        // TODO: 2021/5/27 放入map中 
        if (revision != null && revision.length() > 0) { 
            map.put("revision", revision); 
        } 
 
        // TODO: 2021/5/27 获得方法集合 
        String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames(); 
        if (methods.length == 0) { 
            logger.warn("NO method found in service interface " + interfaceClass.getName()); 
            // TODO: 2021/5/27 设置方法为* 
            map.put(Constants.METHODS_KEY, Constants.ANY_VALUE); 
        } else { 
            // TODO: 2021/5/27 否则加入方法集合中 
            map.put(Constants.METHODS_KEY, StringUtils.join(new HashSet<String>(Arrays.asList(methods)), ",")); 
        } 
    } 
    // TODO: 2021/5/27 将token加入map 
    if (!ConfigUtils.isEmpty(token)) { 
        if (ConfigUtils.isDefault(token)) { 
            map.put(Constants.TOKEN_KEY, UUID.randomUUID().toString()); 
        } else { 
            map.put(Constants.TOKEN_KEY, token); 
        } 
    } 
    if (Constants.LOCAL_PROTOCOL.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(); 
    } 
 
    // TODO: 2021/5/27 获得地址、端口号 
    String host = this.findConfigedHosts(protocolConfig, registryURLs, map); 
    Integer port = this.findConfigedPorts(protocolConfig, name, map); 
    // TODO: 2021/5/27 组装生成URL 
    URL url = new URL(name, host, port, (contextPath == null || contextPath.length() == 0 ? "" : contextPath + "/") + path, map); 
 
    /**组装服务的URL结束**/ 
  
    /* 
  * 后续讲解服务暴露 
  */ 
} 

这个方法实在是又臭又长，我特意分成两部分，目前这部分是组装服务的URL部分，其实简单点说就是：

先将provider、applicaiton、module等各种基础配置直接放入map中，再针对method配置等进行校验，查看该配置是否有配置方法存在，并进行方法签名的校验，如果是才放入map中，然后还额外将一些多余数据，比如泛化调用、版本号等加入map中，最终根据host和port，结合map组装成URL，貌似还是有点长。

总归就是结合服务自身的各种配置放入map中，然后根据host和port以及map等生成URL就是了。

接下来看看后续服务暴露部分

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) { 
     /* 
  * 前面URL组装 
  */ 
     
    // TODO: 2021/5/27 加载ConfiguratorFactory，并生成Configurator实例，判断是否有该协议的实现存在 
    if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class) 
            .hasExtension(url.getProtocol())) { 
        // TODO: 2021/5/27 通过SPI机制配置URL 
        url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class) 
                .getExtension(url.getProtocol()).getConfigurator(url).configure(url); 
    } 
 
    String scope = url.getParameter(Constants.SCOPE_KEY); 
    // TODO: 2021/5/27 如果scope为none，则什么都不做 
    if (!Constants.SCOPE_NONE.toString().equalsIgnoreCase(scope)) { 
 
        // TODO: 2021/5/27 如果scope不是远程，则暴露到本地 
        if (!Constants.SCOPE_REMOTE.toString().equalsIgnoreCase(scope)) { 
            /** 本地服务暴露 **/ 
            exportLocal(url); 
        } 
        // TODO: 2021/5/27 如果不是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.isEmpty()) { 
                // TODO: 2021/5/27 遍历注册中心 
                for (URL registryURL : registryURLs) { 
                    url = url.addParameterIfAbsent(Constants.DYNAMIC_KEY, registryURL.getParameter(Constants.DYNAMIC_KEY)); 
                    // TODO: 2021/5/27 加载监视器连接 
                    URL monitorUrl = loadMonitor(registryURL); 
                    if (monitorUrl != null) { 
                        // TODO: 2021/5/27 如果没有则添加一个 
                        url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString()); 
                    } 
                    if (logger.isInfoEnabled()) { 
                        logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL); 
                    } 
 
                    // TODO: 2021/5/27 根据URL拿到代理方式 
                    String proxy = url.getParameter(Constants.PROXY_KEY); 
                    if (StringUtils.isNotEmpty(proxy)) { 
                        // TODO: 2021/5/27 给注册中心的URL添加代理方式 
                        registryURL = registryURL.addParameter(Constants.PROXY_KEY, proxy); 
                    } 
 
                    // TODO: 2021/5/24 通过SPI机制拿到对应的proxyFactory 
                    /** 根据proxyFactory拿到Invoker **/ 
                    Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString())); 
                    DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this); 
 
                    // TODO: 2021/5/24 通过SPI机制拿到对应的protocol,先是RegistryProtocol，再被AOP强化 
                    /** 服务暴露 **/ 
                    Exporter<?> exporter = protocol.export(wrapperInvoker); 
                    exporters.add(exporter); 
                } 
            } else { 
                // TODO: 2021/5/24 通过SPI机制拿到对应的proxyFactory 
                /** 根据proxyFactory拿到Invoker **/ 
                Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, url); 
                DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this); 
 
                // TODO: 2021/5/24 通过SPI机制拿到对应的protocol 
                /** 服务暴露 **/ 
                Exporter<?> exporter = protocol.export(wrapperInvoker); 
                exporters.add(exporter); 
            } 
        } 
    } 
    this.urls.add(url); 
} 

后续重要的地方可以认为其实就是遍历注册中心进行服务暴露，只是会根据服务配置域scope来针对性做一些暴露处理，比如如果scope不是远程，则暴露到本地，如果不是local，则暴露到远程。

该方法中又包含了几个核心的拓展实现，包括：

1. 本地服务暴露
2. 根据proxyFactory拿到Invoker
3. 远程服务暴露、注册

继续补充流程图，整理思路

 

首先第1点，看看本地服务暴露逻辑

private void exportLocal(URL url) { 
    if (!Constants.LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) { 
        URL local = URL.valueOf(url.toFullString()) 
                .setProtocol(Constants.LOCAL_PROTOCOL) 
                .setHost(LOCALHOST) 
                .setPort(0); 
        StaticContext.getContext(Constants.SERVICE_IMPL_CLASS).put(url.getServiceKey(), getServiceClass(ref)); 
        // TODO: 2021/5/27 根据SPI拿到了InjvmProtocol调用了export方 
        Exporter<?> exporter = protocol.export( 
                proxyFactory.getInvoker(ref, (Class) interfaceClass, local)); 
        // 放入集合中缓存 
        exporters.add(exporter); 
        logger.info("Export dubbo service " + interfaceClass.getName() + " to local registry"); 
    } 
} 

@Override 
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException { 
    return new InjvmExporter<T>(invoker, invoker.getUrl().getServiceKey(), exporterMap); 
} 

暴露到本地的大致逻辑其实就是根据SPI机制拿到了InjvmProtocol生成了InjvmExporter，之后放入集合缓存中，至于SPI机制，后续需要开个文章专门讲讲，有兴趣持续关注该系列。

• 为啥要有本地服务暴露?

大致原因应该是因为可能存在同一个 JVM 内部引用自身服务的情况，因此暴露的本地服务在内部调用的时候可以直接消费同一个 JVM 的服务避免了网络间的通信。

继续看第2点，根据proxyFactory拿到Invoker部分，首先我们看ProxyFactory类名就大概可以猜到该类具备生成代理对象的能力，我们看proxyFactory的生成模式

 

可以看到，该对象也是通过SPI机制生成的，由于SPI机制也是比较庞大的，为了避免混淆，后续再开篇文章讲解，有兴趣的持续关注。

通过SPI机制拿到了ProxyFactory的实现对象JavassisProxyFactory，最终调用的代码

@Override 
public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) { 
    // TODO: 2021/5/23 为目标类创建Wrapper 
    final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type); 
    // TODO: 2021/5/23 创建匿名的Invoker对象，并实现doInvoker方法 
    return new AbstractProxyInvoker<T>(proxy, type, url) { 
        @Override 
        protected Object doInvoke(T proxy, String methodName, 
                                  Class<?>[] parameterTypes, 
                                  Object[] arguments) throws Throwable { 
            // TODO: 2021/5/23 调用Wrapper的invokeMethod方法，invokeMethod最终会调用目标方法 
            return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments); 
        } 
    }; 
} 

该方法就是创建了一个匿名的Inovker对象，在doInvker方法中调用wrapper.invokeMethod方法，invokeMethod最终会调用目标方法。

• 那么wrapper又是啥?

Wrapper是一个抽象类，在调用Wrapper.getWrapper创建子类的时候，会根据目标Class对象进行解析，拿到各种方法、类成员变量等信息，以及生成invokeMethod方法等代码，在代码生成完毕后，通过Javassist生成Class对象，可以理解为该Class对象就是BossServiceImpl的代理实例，有兴趣了解生成过程的可以看Wrapper.makeWrapper方法。

• 为啥一定要封装Invoker?

其实就是为了屏蔽本地调用或者远程调用或者集群调用的细节，统一暴露出一个可执行体，方便调用者调用，而不管怎么封装，其实最终都是调向目标方法。

• 为啥要封装Exporter?

这个涉及到后续服务被具体调用，后面会开一篇文章专门讲这个，有兴趣的可以持续关注。

在我司的rpc框架中，倒是没有使用Javassist去生成代理对象，而是选择了使用jdk提供的Proxy生成机制。

继续补充流程图，整理思路

 

接下来说说远程服务暴露

远程服务暴露要比本地复杂的多，在doExportUrlsFor1Protocol后半部分，通过proxyFactory生成Inovker后，就需要调用protocol.export做真的服务暴露了，我们可以看到protocol是如何实例化的

又是通过SPI实例化的，通过断点可以看到会先被AOP切面拦截额外做了一些其他的操作，不过最终走向的RegisterProtocol，AOP这块后续再分析，有兴趣的持续关注。

接下来继续看RegisterProtocol.export做了啥

@Override 
public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException { 
    // TODO: 2021/5/29 服务暴露 
    final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker); 
    // TODO: 2021/5/23 获得注册中心的URL 
    URL registryUrl = getRegistryUrl(originInvoker); 
 
    final Registry registry = getRegistry(originInvoker); 
    // TODO: 2021/5/23 获得已经注册的服务提供者URL 
    final URL registeredProviderUrl = getRegisteredProviderUrl(originInvoker); 
 
    boolean register = registeredProviderUrl.getParameter("register", true); 
 
    ProviderConsumerRegTable.registerProvider(originInvoker, registryUrl, registeredProviderUrl); 
    if (register) { 
        // TODO: 2021/5/29 真正做服务注册的地方 
        register(registryUrl, registeredProviderUrl); 
        ProviderConsumerRegTable.getProviderWrapper(originInvoker).setReg(true); 
    } 
 
    // TODO: 2021/5/23 获取override订阅URL 
    final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registeredProviderUrl); 
    // TODO: 2021/5/23 创建override的监听器 
    final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker); 
    // TODO: 2021/5/23 缓存监听器到集合中 
    overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener); 
    // TODO: 2021/5/23 向注册中心订阅override数据 
    registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener); 
    // TODO: 2021/5/23 创建并返回DestroyableExporter 
    return new DestroyableExporter<T>(exporter, originInvoker, overrideSubscribeUrl, registeredProviderUrl); 
} 

从代码上看，该方法其实做了两件事情，分别是服务暴露和注册：

• 执行了doLocalExport进行服务暴露
• 加载注册中心实现类，向注册中心注册服务
• 向注册中心订阅override数据
• 创建并返回DestroyableExporter

接下来继续看看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) { 
                // TODO: 2021/5/24 创建Invoker为委托对象 
                final Invoker<?> invokerDelegete = new InvokerDelegete<T>(originInvoker, getProviderUrl(originInvoker)); 
                // TODO: 2021/5/24 调用protocol的export方法暴露服务 
                exporter = new ExporterChangeableWrapper<T>((Exporter<T>) protocol.export(invokerDelegete), originInvoker); 
                bounds.put(key, exporter); 
            } 
        } 
    } 
    return exporter; 
} 

看逻辑比较简单，主要是根据不同协议配置，根据SPI调用不同的protocol实现，跟暴露到本地时实现的InjvmPortocol一样，默认这里调用的是DubboProtocol.export

public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException { 
    URL url = invoker.getUrl(); 
 
    // TODO: 2021/5/29 得到服务key,格式：group+"/"+serviceName+":"+serviceVersion+":"+port 
    String key = serviceKey(url); 
    // TODO: 2021/5/29 创建exporter  
    DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap); 
    exporterMap.put(key, exporter); 
 
    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); 
        } 
    } 
 
    // TODO: 2021/5/24 开启服务器 
    openServer(url); 
    // TODO: 2021/5/29 序列化  
    optimizeSerialization(url); 
    return exporter; 
} 

可以到export先是new了一个DubboExporter对象， 后续打开了服务，接下来继续看openServer做了啥

private void openServer(URL url) { 
    String key = url.getAddress(); 
    boolean isServer = url.getParameter(Constants.IS_SERVER_KEY, true); 
    if (isServer) { 
        ExchangeServer server = serverMap.get(key); 
        if (server == null) { 
            // TODO: 2021/5/24 启动一个服务实例 
            serverMap.put(key, createServer(url)); 
        } else { 
            // server supports reset, use together with override 
            server.reset(url); 
        } 
    } 
} 
 
private ExchangeServer createServer(URL url) { 
    // TODO: 2021/5/29 服务器关闭是发送readonly时间  
    url = url.addParameterIfAbsent(Constants.CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString()); 
    // TODO: 2021/5/29 心跳默认时间  
    url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT)); 
    // TODO: 2021/5/29 获得远程通讯服务端实现方式  
    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); 
    // TODO: 2021/5/29 添加编解码器DubboCodec实现  
    url = url.addParameter(Constants.CODEC_KEY, DubboCodec.NAME); 
    ExchangeServer server; 
    try { 
        // TODO: 2021/5/29 启动服务器  
        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; 
} 

可以看到最终还是依赖URL携带的远程通讯实现方法创建了一个服务器对象。

总结一下：doLocalExport最终其实就是根据URL开启了服务器，并返回了Exporter。

接下来继续看注册服务部分

public void register(URL registryUrl, URL registedProviderUrl) { 
    // TODO: 2021/5/29 获取注册中心实例 
    Registry registry = registryFactory.getRegistry(registryUrl); 
    // TODO: 2021/5/29 调用register 
    registry.register(registedProviderUrl); 
} 

Regsitry的生成最终也是依赖了SPI机制，最终走向FailbackRegistry.register

@Override 
public void register(URL url) { 
    super.register(url); 
    // TODO: 2021/5/24 从失败的集合中移除 
    failedRegistered.remove(url); 
    failedUnregistered.remove(url); 
    try { 
        // TODO: 2021/5/24 向注册中心发起注册请求 
        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); 
        } 
 
        // TODO: 2021/5/29 发生异常则放入failedRegistered 
        failedRegistered.add(url); 
    } 
} 

可以看到注册的核心实现是在doRegister中，不过通过代码机制我们也可以看出，在注册报错的时候会被trycatch拦截，然后放入failedRegistered容器中，结合FailbackRegistry该类名可以推测应该是有个重试机制存在，看看构造方法

// TODO: 2021/5/24 从url中获取重试频率参数，启动定时器进行重试逻辑 
public FailbackRegistry(URL url) { 
    super(url); 
    this.retryPeriod = url.getParameter(Constants.REGISTRY_RETRY_PERIOD_KEY, Constants.DEFAULT_REGISTRY_RETRY_PERIOD); 
    this.retryFuture = retryExecutor.scheduleWithFixedDelay(new Runnable() { 
        @Override 
        public void run() { 
            try { 
                // TODO: 2021/5/29 定时重试  
                retry(); 
            } catch (Throwable t) { // Defensive fault tolerance 
                logger.error("Unexpected error occur at failed retry, cause: " + t.getMessage(), t); 
            } 
        } 
    }, retryPeriod, retryPeriod, TimeUnit.MILLISECONDS); 
} 

果不其然，最终如果注册发生了异常，则会进行定时重试。

关于重试机制也是要有的，在我司的rpc框架中，我们将重试时间放在yaml上去配置，不过定时器并没有采用Executor机制，而是模仿了dubbo3.0的写法，也就是时间轮的机制，性能更好。

接下来看注册核心部分doRegister，可以看到该方法是一个抽象方法，由于我在xml配置中配置的注册中心是Zookeeper，因而最终走向ZookeeperRegistry

@Override 
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); 
    } 
} 

服务注册走到这里基本到头了，再深入便是看注册中心的实现了。

接下来看看向注册中心订阅override数据部分

上面有说过registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener)最终走向的方法是FailbackRegistry.subscribe

public void subscribe(URL url, NotifyListener listener) { 
    super.subscribe(url, listener); 
    removeFailedSubscribed(url, listener); 
    try { 
        // TODO: 2021/5/29 真正做订阅的地方  
        doSubscribe(url, listener); 
    } catch (Exception e) { 
        Throwable t = e; 
 
        List<URL> urls = getCacheUrls(url); 
        if (urls != null && !urls.isEmpty()) { 
            notify(url, listener, urls); 
            logger.error("Failed to subscribe " + url + ", Using cached list: " + urls + " from cache file: " + getUrl().getParameter(Constants.FILE_KEY, System.getProperty("user.home") + "/dubbo-registry-" + url.getHost() + ".cache") + ", cause: " + t.getMessage(), t); 
        } else { 
            // If the startup detection is opened, the Exception is thrown directly. 
            boolean check = getUrl().getParameter(Constants.CHECK_KEY, true) 
                    && url.getParameter(Constants.CHECK_KEY, true); 
            boolean skipFailback = t instanceof SkipFailbackWrapperException; 
            if (check || skipFailback) { 
                if (skipFailback) { 
                    t = t.getCause(); 
                } 
                throw new IllegalStateException("Failed to subscribe " + url + ", cause: " + t.getMessage(), t); 
            } else { 
                logger.error("Failed to subscribe " + url + ", waiting for retry, cause: " + t.getMessage(), t); 
            } 
        } 
 
        // TODO: 2021/5/29 订阅失败，则放入失败容器中  
        addFailedSubscribed(url, listener); 
    } 
} 

同样，订阅失败后也是放入失败容器中，定时重试进行订阅。

再看看核心实现方法doSubscribe方法，最终走向ZookeeperRegistry.doSubscribe中

@Override 
protected void doSubscribe(final URL url, final NotifyListener listener) { 
    try { 
        // TODO: 2021/5/29 处理URL参数中interface为*的订阅，例如监控中心的订阅 
        if (Constants.ANY_VALUE.equals(url.getServiceInterface())) { 
            /** 先无视 **/ 
        } else { 
            List<URL> urls = new ArrayList<URL>(); 
            // TODO: 2021/5/29 遍历分类数组 
            for (String path : toCategoriesPath(url)) { 
                // TODO: 2021/5/29 获得监听器集合 
                ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.get(url); 
                // TODO: 2021/5/29 如果没有则创建 
                if (listeners == null) { 
                    zkListeners.putIfAbsent(url, new ConcurrentHashMap<NotifyListener, ChildListener>()); 
                    listeners = zkListeners.get(url); 
                } 
                // TODO: 2021/5/29 获得监听器 
                ChildListener zkListener = listeners.get(listener); 
                if (zkListener == null) { 
                    listeners.putIfAbsent(listener, new ChildListener() { 
                        @Override 
                        public void childChanged(String parentPath, List<String> currentChilds) { 
                            // TODO: 2021/5/29 通知服务变化，回调NotifyListener 
                            ZookeeperRegistry.this.notify(url, listener, toUrlsWithEmpty(url, parentPath, currentChilds)); 
                        } 
                    }); 
                    zkListener = listeners.get(listener); 
                } 
                // TODO: 2021/5/29 创建节点，如:/dubbo/com.alibaba.dubbo.demo.DemoService/providers 
                zkClient.create(path, false); 
                List<String> children = zkClient.addChildListener(path, zkListener); 
                if (children != null) { 
                    urls.addAll(toUrlsWithEmpty(url, path, children)); 
                } 
            } 
            // TODO: 2021/5/29 通知数据变更，如RegistryDirectory 
            notify(url, listener, urls); 
        } 
    } catch (Throwable e) { 
        throw new RpcException("Failed to subscribe " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e); 
    } 
} 

这个方法主要做了订阅和监听触发逻辑，具体逻辑就是订阅了某个服务的URL，在服务变更的时候触发逻辑变化。其实此处已经是可以归纳入服务治理模块了，后续会有专门的文章分享服务治理，有兴趣可以持续关注。

画个流程图，整理下思路

 

看到这里服务暴露流程基本理完了，还是有点东西在里面的，并且还需要掌握 Dubbo SPI，不然有些点例如自适应什么的还是很难理解的，为了写这篇文章，我前前后后也是花了不少的时间。

最后我再来一张完整的流程图带大家再过一遍，具体还是有很多细节，不过不是主干我就不做分析了，不然文章散掉了。

后续服务治理、APO、SPI机制也会在该流程图上进行拓展，有兴趣的也可以关注流程图链接：

https://www.processon.com/view/link/60b25f275653bb3c7e646934

总结

虽然看完了该篇文章，但是还是建议大家自己打断点过一遍，可以更加清晰，而如果是为了应付面试官提问的话，基本上记住上面流程图的内容就差不多了，当你研究完了dubbo后，其实会发现dubbo有很多东西可以写，比如服务应用、SPI、dubbo中的AOP机制、服务治理等好几个模块，最后就是带大家撸一个RPC框架了，还是那句话，想学dubbo的可以持续关注这一系列。

本文转载自微信公众号「 稀饭下雪」，可以通过以下二维码关注。转载本文请联系 稀饭下雪公众号。

原文链接：https://mp.weixin.qq.com/s/gsPa2KHS1ZqxU6z3_wI46w