- 当前位置：首页 >IT科技类资讯 >一起玩Dubbo，万字长文揭秘服务暴露
一起玩Dubbo，万字长文揭秘服务暴露
发布时间：2025-11-04 14:22:21 来源：创站工坊 作者：域名
日常写组件，起玩最近又接了一个需求，万文揭务暴让我负责实现一个rpc组件，字长提高公司游戏跨服开发的秘服效率，为了写好这个组件，起玩算是万文揭务暴将dubbo里里外外研究了一波，目前组件的字长实现也接近尾声了，因此打算给dubbo的秘服学习做个总结，并穿插说说rpc实现的起玩心路历程，同样需要实现rpc的万文揭务暴朋友，或者对dubbo有兴趣的字长朋友可以关注这个系列。
在写rpc组件之前，秘服我先提了几个灵魂疑问，起玩并从dubbo中找到了答案。万文揭务暴
服务是字长啥?一个模块，一种玩法，只要是需要进行远程调度的都可以用服务的概念进行包装，我这边简单包装了一个副本服务，类情况如下：
平平无奇，等等，我们来看看提供方如何标记服务
到了这一步，服务已经完成了基本定义。
服务最终被注册到了那里?在xml配置上，IT技术网我们已经看到了有注册中心的配置
没错，最后提供方定义好的服务会注册到注册中心，目前支持的类型有多种
具体可以查看里边提供的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进行传递。
服务暴露过程
在深入源码之前先大概总结下服务暴露的几个步骤，分别是：
配置的构建、合并、检查。 URL的组装。 服务的暴露、注册。我将这三个主要的过程放入流程图内
继续跟进服务暴露的具体逻辑，也就是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，则暴露到远程。
该方法中又包含了几个核心的拓展实现，包括：
本地服务暴露 根据proxyFactory拿到Invoker 远程服务暴露、注册继续补充流程图，整理思路
首先第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
- Copyright © 2025 Powered by 一起玩Dubbo，万字长文揭秘服务暴露,创站工坊 滇ICP备2023006006号-44sitemap