前言
忙的时候，会埋怨学习的时间太少，缺少个人的空间，于是会争分夺秒的工作、学习。而一旦繁忙的时候过去，有时间了之后，整个人又会不自觉的陷入一种懒散的状态中，时间也显得不那么重要了，随便就可以浪费掉几个小时。可见普通人的学习之路要主动地去克服掉很多阻碍，最主要的阻碍还是来自于自身，周期性的不想学习、不自觉的懒散、浅尝辄止的态度、好高骛远贪多的盲目...哎，学习之路，还是要时刻提醒自己，需勤勉致知。
闲话少叙，今天的学习目标是要尽量的了解清楚Dubbo框架中的服务导出功能，先附上Dubbo官网上的一个框架图
本文要说的服务导出，指的就是上图中的动作1-register，即将配置文件/类中服务提供者的信息在注册中心完成注册，以便后续的消费者能发现服务，此外，开放NettyClient用于与消费者通讯。
下面会从服务导出的触发时机、配置项准备、开放通讯client并注册三部分进行服务导出流程的了解。
一、服务导出的触发时机
Dubbo是一个可以完全兼容Spring的服务治理框架，兼容性体现在何处？一是Dubbo的配置可以做到对Spring配置无侵入；二是Dubbo默认是随着Spring容器的启动而启动的，不需要人为的控制。帮助Dubbo实现第二项的类有两个：ReferenceBean和ServiceBean，这两个类在Dubbo中担任了连接Spring的桥梁的作用。与本文相关的类是ServiceBean，此类实现了ApplicationListener接口，这样Spring框架在执行refresh方法完成容器初始化的时候，就会发布容器刷新事件，调用ServiceBean的重写方法onApplicationEvent，触发服务导出。
1 public void onApplicationEvent(ContextRefreshedEvent event) { 2 // 判断是否已经导出 或者是否不应该导出 3 if (!isExported() && !isUnexported()) { 4 if (logger.isInfoEnabled()) { 5 logger.info("The service ready on spring started. service: " + getInterface()); 6 } 7 export(); 8 } 9 }
二、配置项准备
既然有了入口，就顺着一路追溯下去。真正的export导出方法，在ServiceConfig类中。此时需要说明一下Dubbo中的配置类与实际配置项之间的对应关系。此处以Dubbo的xml配置文件为例。
<dubbo:service interface = "com.test.dubboservice.ITestService" ref = "testService" version="1.0"/> 对应 ServiceConfig类，
<dubbo:provider delay="-1" timeout="${DUBBO_TIMEOUT}" retries="0" token="test_demo"/> 对应 ProviderConfig类，此类与ServiceConfig同属于AbstractServiceConfig的实现类
<dubbo:application name = "dubbo_provider"/> 对应ApplicationConfig类，
<dubbo:registry address = "zookeeper://192/168.16.218:10110" check="false" subscribe="false" register=""/> 对应RegistryConfig类，
<dubbo:protocol name = "dubbo"/> 对应ProtocolConfig类，此外监控中心对应的类是 MonitorConfig
播放完插曲，继续往下追溯export方法 ServiceConfig中的 doExportUrls方法：
1 private void doExportUrls() { 2 // 1、Dubbo支持多协议多注册中心 3 List<URL> registryURLs = loadRegistries(true); 4 ///2、多协议导出服务，向多注册中心注册服务 5 for (ProtocolConfig protocolConfig : protocols) { 6 String pathKey = URL.buildKey(getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), group, version); 7 ProviderModel providerModel = new ProviderModel(pathKey, ref, interfaceClass); 8 ApplicationModel.initProviderModel(pathKey, providerModel); 9 doExportUrlsFor1Protocol(protocolConfig, registryURLs); 10 } 11 }
此方法分为两步，第一步是获取配置的注册中心生成的URL，第二步是通过不同协议进行注册。一步一步的看，先看loadRegistries方法。
1、loadRegistries(true)方法
1 protected List<URL> loadRegistries(boolean provider) { 2 // check && override if necessary 3 List<URL> registryList = new ArrayList<URL>(); 4 // 此处registries类型为List<RegistryConfig>，是解析配置文件时完成的注入，类似于Spring对配置文件的解析 5 if (CollectionUtils.isNotEmpty(registries)) { 6 for (RegistryConfig config : registries) { 7 String address = config.getAddress(); 8 if (StringUtils.isEmpty(address)) { 9 address = ANYHOST_VALUE; 10 } 11 // 判断当前注册中心的地址是否为可用地址，不可用地址格式为 N/A 12 if (!RegistryConfig.NO_AVAILABLE.equalsIgnoreCase(address)) { 13 Map<String, String> map = new HashMap<String, String>(); 14 // ！！！此方法极为重要，在拼接URL时经常会看到，是重点需要理解的方法 15 appendParameters(map, application); 16 appendParameters(map, config); 17 map.put(PATH_KEY, RegistryService.class.getName()); 18 appendRuntimeParameters(map); 19 // 如果注册中心配置中没有配置protocol，则默认用dubbo 20 if (!map.containsKey(PROTOCOL_KEY)) { 21 map.put(PROTOCOL_KEY, DUBBO_PROTOCOL); 22 } 23 List<URL> urls = UrlUtils.parseURLs(address, map); 24 // 重新构建URL 25 for (URL url : urls) { 26 url = URLBuilder.from(url) 27 .addParameter(REGISTRY_KEY, url.getProtocol()) 28 .setProtocol(REGISTRY_PROTOCOL) 29 .build(); 30 // 满足两个条件会往里添加：1、是提供者且有配置注册中心；2、不是提供者但是配置了订阅 31 if ((provider && url.getParameter(REGISTER_KEY, true)) 32 || (!provider && url.getParameter(SUBSCRIBE_KEY, true))) { 33 registryList.add(url); 34 } 35 } 36 } 37 } 38 } 39 return registryList; 40 }
此方法逻辑不难理解，先是判断如果为空则设置address的默认值为127的本地地址，再是组装URL参数，最后重新build一下，判断是否添加，最终返回。只是有三个地方需要搞清楚，一个是appendParameters方法的原理及作用，一个是UrlUtils.parseURLs方法的原理，最后是26-29行代码的作用以及为什么还要重新创建（直接将23行的urls返回不行吗？）。下面一个个的来。
1.1 appendParameters方法
源码如下所示：
1 // 第二个参数就是前面传入的配置类 ApplicationConfig、RegistryConfig等 2 protected static void appendParameters(Map<String, String> parameters, Object config, String prefix) { 3 if (config == null) { 4 return; 5 } 6 // 通过反射得到所有的方法 7 Method[] methods = config.getClass().getMethods(); 8 for (Method method : methods) { 9 try { 10 String name = method.getName(); 11 // 是get方法或is方法才进行赋值 12 if (MethodUtils.isGetter(method)) { 13 Parameter parameter = method.getAnnotation(Parameter.class); 14 // 返回值是当前配置类，或者此方法有Parameter注解且excluded参数为true，此时不往map中赋值 15 if (method.getReturnType() == Object.class || parameter != null && parameter.excluded()) { 16 continue; 17 } 18 String key; 19 if (parameter != null && parameter.key().length() > 0) { 20 // 如果Parameter注解中的key不为空，则将它作为往map中put的key 21 key = parameter.key(); 22 } else { 23 // 否则截取get/is后面的字符串,转成application.version格式的key 24 key = calculatePropertyFromGetter(name); 25 } 26 // 通过反射获取value 27 Object value = method.invoke(config); 28 String str = String.valueOf(value).trim(); 29 if (value != null && str.length() > 0) { 30 if (parameter != null && parameter.escaped()) { 31 // 转成utf-8格式 32 str = URL.encode(str); 33 } 34 // 注解中有可拼接配置，则在value前面拼接默认值 35 if (parameter != null && parameter.append()) { 36 String pre = parameters.get(DEFAULT_KEY + "." + key); 37 if (pre != null && pre.length() > 0) { 38 str = pre + "," + str; 39 } 40 pre = parameters.get(key); 41 if (pre != null && pre.length() > 0) { 42 str = pre + "," + str; 43 } 44 } 45 // 如果有前缀则在key上加前缀 46 if (prefix != null && prefix.length() > 0) { 47 key = prefix + "." + key; 48 } 49 // 放入map中 50 parameters.put(key, str); 51 } else if (parameter != null && parameter.required()) { 52 throw new IllegalStateException(config.getClass().getSimpleName() + "." + key + " == null"); 53 } 54 // 如果是getParameters方法 55 } else if ("getParameters".equals(name) 56 && Modifier.isPublic(method.getModifiers()) 57 && method.getParameterTypes().length == 0 58 && method.getReturnType() == Map.class) { 59 Map<String, String> map = (Map<String, String>) method.invoke(config, new Object[0]); 60 if (map != null && map.size() > 0) { 61 String pre = (prefix != null && prefix.length() > 0 ? prefix + "." : ""); 62 // 重新放入parameters中 63 for (Map.Entry<String, String> entry : map.entrySet()) { 64 parameters.put(pre + entry.getKey().replace('-', '.'), entry.getValue()); 65 } 66 } 67 } 68 } catch (Exception e) { 69 throw new IllegalStateException(e.getMessage(), e); 70 } 71 } 72 }
此方法的作用就是获取传入Object的get/is方法，将get/is后面的属性名跟返回的value值作为key-value放入map中，此外该方法还兼容了Dubbo本身的配置项功能。
1.2 UrlUtils.parseURLs方法
此方法最终调用了org.apache.dubbo.common.utils.UrlUtils#parseURL方法，由于代码较长，就不贴出来了。
方法中做的事情为：拆分address，如果配置了多个注册中心地址，则每个地址对应一个URL，然后组装URL的七大基本参数 protocol, username, password, host, port, path, parameters，最后new一个URL并返回。
1.3 26-29行代码的作用
将registry、protocol的值作为key、value放入parameters中，将protocol设置为registry，然后用新七项信息创建一个新的URL，此时的URL就被标记为registry的URL了。
2、遍历协议配置，用每个协议配置往注册中心进行服务导出
其中pathkey字段，获取到的就是要导出的服务的接口全路径名，然后将ProviderModel放入map中缓存起来，最后再调用导出方法。
三、服务导出并注册
此部分代码较长，逻辑复杂，故只贴一下关键地方的代码，需结合代码一起看。
1、服务导出的触发
在ServiceConfig类的上述doExportUrlsFor1Protocol方法的后面，进行了导出的触发。分析如下：
1 String host = this.findConfigedHosts(protocolConfig, registryURLs, map); 2 Integer port = this.findConfigedPorts(protocolConfig, name, map);
上面2.1中获取到的注册中心URL用于提供host地址，在获取到String protocol, String host, int port, String path, Map<String, String> parameters这五项信息后，new一个URL。然后通过proxyFactory（通过SPI机制生成的代理类）来生成invoker对象，包装成一个包装类，然后调用通过SPI机制生成的protocol代理类的export方法进行导出。
1 if (CollectionUtils.isNotEmpty(registryURLs)) { 2 for (URL registryURL : registryURLs) { 3 // 若干无关代码 4 // 通过代理工厂生成invoker 5 Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString())); 6 // 用于持有invoker和ServiceConfig 7 DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this); 8 // 进行服务导出 9 Exporter<?> exporter = protocol.export(wrapperInvoker); 10 exporters.add(exporter); 11 } 12 } else { 13 Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, url); 14 DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this); 15 16 Exporter<?> exporter = protocol.export(wrapperInvoker); 17 exporters.add(exporter); 18}
Dubbo中一般都是这个套路，先将URL等准备好的对象转换成一个Invoker，再将Invoker对象传入目标方法完成特定功能。方便理解，可顾名思义，将Invoker看成一个调用体的抽象。
此处需要说明一点的是上述的if-else分支，if中的逻辑是当存在注册中心时的处理方式，即向注册中心注册，并暴露服务供调用；而else中的逻辑，是不存在注册中心时，只暴露服务。他们二者功能区别的实现，在于第5行跟第13行，getInvoker方法的第三个参数不同，一个是注册中心的URL中带有服务的URL，一个只是服务的URL。前者通过SPI的代理工厂类调用的是RegistryProtocol类，因为RegistryURL的protocol属性为registry；而后者通过代理工厂类调用的是DubboProtocol等具体的协议类，因为此URL的protocol属性是取得配置属性，默认dubbo协议。由此可见，以URL为媒介的配置类与SPI机制结合时的灵活性是很大的。
2、RegistryProtocol中的export方法
1 public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException { 2 URL registryUrl = getRegistryUrl(originInvoker); 3 // url to export locally 4 URL providerUrl = getProviderUrl(originInvoker); 5 // subscription information to cover. 6 final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl); 7 final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker); 8 overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener); 9 10 providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener); 11 //export invoker 12 // *** 导出是指，创建可供客户端通讯的nettyClient，并启动 13 final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl); 14 15 // url to registry 16 final Registry registry = getRegistry(originInvoker); 17 final URL registeredProviderUrl = getRegisteredProviderUrl(providerUrl, registryUrl); 18 ProviderInvokerWrapper<T> providerInvokerWrapper = ProviderConsumerRegTable.registerProvider(originInvoker, 19 registryUrl, registeredProviderUrl); 20 //to judge if we need to delay publish 21 boolean register = registeredProviderUrl.getParameter("register", true); 22 if (register) { 23 // *** 将服务注册到注册中心 24 register(registryUrl, registeredProviderUrl); 25 providerInvokerWrapper.setReg(true); 26 } 27 28 // Deprecated! Subscribe to override rules in 2.6.x or before. 29 registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener); 30 31 exporter.setRegisterUrl(registeredProviderUrl); 32 exporter.setSubscribeUrl(overrideSubscribeUrl); 33 //Ensure that a new exporter instance is returned every time export 34 return new DestroyableExporter<>(exporter); 35 }
此方法中最重要的两个方法我用*号打了标记，其中前者最终执行的是DubboProtocol等类中的export方法，即启动服务端的通讯Client，以进行后续的通讯调用，此方法下面再看。后者register方法的作用，即将服务注册到注册中心。不同的注册中心，注册的实现是不一样的，比如如果用的是ZooKeeper注册，则此处是调用ZooKeeper的相关API，在对应路径上创建节点，一个节点对应一个服务。
3、DubboProtocol中的export方法
此处以默认协议DubboProtocol为例，看它的export方法。
1 public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException { 2 URL url = invoker.getUrl(); 3 4 // export service. 5 String key = serviceKey(url); 6 DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap); 7 exporterMap.put(key, exporter); 8 9 //export an stub service for dispatching event 10 Boolean isStubSupportEvent = url.getParameter(STUB_EVENT_KEY, DEFAULT_STUB_EVENT); 11 Boolean isCallbackservice = url.getParameter(IS_CALLBACK_SERVICE, false); 12 if (isStubSupportEvent && !isCallbackservice) { 13 String stubServiceMethods = url.getParameter(STUB_EVENT_METHODS_KEY); 14 if (stubServiceMethods == null || stubServiceMethods.length() == 0) { 15 if (logger.isWarnEnabled()) { 16 logger.warn(new IllegalStateException("consumer [" + url.getParameter(INTERFACE_KEY) + 17 "], has set stubproxy support event ,but no stub methods founded.")); 18 } 19 20 } else { 21 stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods); 22 } 23 } 24 // 打开服务器，为什么是打开服务器？因为打开了服务端Client，消费者就可以与其进行通讯的交互了 25 openServer(url); 26 optimizeSerialization(url);//序列化的优化 27 28 return exporter; 29 }
此方法最主要的就是openServer方法，追踪下去你会发现，最终创建了某Client并启动（默认是NettyClient，此外还有MinaClient、GrizzlyClient），等待消息的传入。
总结
Dubbo中服务导出的流程，基本如上所述。3.2和3.3中由于有多层类调用代码量较多，所以未详细跟进流程，不过相信以道友们扎实的源码阅读功底，应该不难追溯下去，追溯到最后面就是封装的与其他组件交互的api了，感觉繁琐且陌生。源码阅读，还是要找到一个比较好的框架慢慢研读下去，勿好高骛远，勿心急气躁。一时看不懂的地方，就多研究一下，实在不行则先放放，过两天重看的时候就会有不一样的灵感，一般都很容易就领悟了，如若还不行，上网看看大神们的解读也能豁然开朗。
总之技术的提升没有什么捷径，需要多学习多积累多思考。与各位共勉！