写在前面

在dubbo之服务本地暴露 文章中，我们分析了当scope="local"时使用injvm协议的本地服务注册，本文一起来看下实际业务中最常使用的方式，即远端服务暴露，相比于本地暴露，主要是多做如下的几件事：

1：启动通信服务器，绑定服务端口，准备接收服务消费者端的远程请求。
2：注册服务端口信息到注册中心，供服务消费者获取服务调用信息。

下面我们就开始吧！

在dubbo之服务本地暴露 文章基础上从doExportUrlsFor1Protocol，具体参考1.1：doExportUrlsFor1Protocol。

1：远程暴漏

时序图如下：

1.1：doExportUrlsFor1Protocol

源码如下：

// com.alibaba.dubbo.config.ServiceConfig.doExportUrlsFor1Protocol
class FakeCls {private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {// *** 构造需要暴漏的url，如： dubbo://192.168.2.107:20826/dongshi.daddy.service.scoperemote.ScopeRemoteService?anyhost=true&application=dongshidaddy-provider&bean.name=dongshi.daddy.service.scoperemote.ScopeRemoteService&bind.ip=192.168.2.107&bind.port=20826&dubbo=2.0.2&generic=false&interface=dongshi.daddy.service.scoperemote.ScopeRemoteService&methods=sayHi&owner=dongshidaddy&pid=63200&side=provider&timestamp=1643363026148*** //String scope = url.getParameter(Constants.SCOPE_KEY);// 以下只处理非scope="none"的情况if (!Constants.SCOPE_NONE.toString().equalsIgnoreCase(scope)) {// scope="local"，或者是没有配置scope，此时scope=null，这里会为trueif (!Constants.SCOPE_REMOTE.toString().equalsIgnoreCase(scope)) {// 省略本地暴漏逻辑}// scope="remote"，或者是没有配置scope，此时scope=null，这里会为trueif (!Constants.SCOPE_LOCAL.toString().equalsIgnoreCase(scope)) {if (logger.isInfoEnabled()) {logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);}if (registryURLs != null && !registryURLs.isEmpty()) {// 如：registry://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?application=dongshidaddy-provider&dubbo=2.0.2&owner=dongshidaddy&pid=63200&registry=zookeeper&timestamp=1643362790535// 将需要暴漏的服务的url，暴漏到所有的注册中心地址上for (URL registryURL : registryURLs) {// 不清楚做什么用的，先忽略！url = url.addParameterIfAbsent(Constants.DYNAMIC_KEY, registryURL.getParameter(Constants.DYNAMIC_KEY));// 获取监控中心url,监控中心其实也是一个服务提供者，用来统计服务调用信息，次数，耗时等URL monitorUrl = loadMonitor(registryURL);if (monitorUrl != null) {// monitor,添加monitor监控中心地址，其实也是一个服务提供者url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString());}if (logger.isInfoEnabled()) {logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);}// 服务提供者使用，用来启用使用定制的代理类生成invokerString proxy = url.getParameter(Constants.PROXY_KEY);if (StringUtils.isNotEmpty(proxy)) {registryURL = registryURL.addParameter(Constants.PROXY_KEY, proxy);}// 2022-01-31 17:39:34// 通过ProxyFactory生成Invoker// registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()):添加要暴漏的服务地址到注册中心地址// ,key：export 添加后：registry://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?application=dongshidaddy-provider&dubbo=2.0.2&export=dubbo://192.168.2.107:20826/dongshi.daddy.service.monitor.DubboMonitorService...// 返回的invoker，当调用该其invoke方法时，内部会调用对应的服务实现类，即ref的具体方法// 参数ref：具体的服务实现类，即最终被调用的类。 interfaceClass：服务接口Class。registryURL：注册中心地址Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));// 创建封装Invoker和ServiceConfig的DelegateProviderMetaDataInvoker对象DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);// 2022-01-31 15:01:03Exporter<?> exporter = protocol.export(wrapperInvoker);// private final List<Exporter<?>> exporters = new ArrayList<Exporter<?>>();// 添加到exporters集合中，Exporter用于获取invoker，以及取消暴漏等exporters.add(exporter);}} else {// 注册地址是N/A的情况，此时因为没有配置注册中心地址，所以不会向注册中心注册，但是依然监听端口，暴漏服务，一般用于消费者端直连的场景// 服务消费者端想要直连的话需要设置url属性，如下可能配置：/*<dubbo:reference id="providerService"interface="dongshi.daddy.service.ProviderService"url="dubbo://192.168.10.119:20880/dongshi.daddy.service.ProviderService"/>*/// 这里和正常向注册中心注册的方式，差别在第四个参数，这里传入的是null，注册的话传入的是注册中心的url地址Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, url);DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);Exporter<?> exporter = protocol.export(wrapperInvoker);exporters.add(exporter);}}}this.urls.add(url);}
}

2022-01-31 15:01:03处是完成服务的暴漏，在dubbo之服务本地暴露 一文中我们知道Protocol是使用了Wrapper 的自适应扩展类 ，因此在调用真正的Protocol实现类之前，会先调用自动生成的Adaptive类，以及所有的Wrapper类,如下debug图：

以上调用顺序的原因是，保证服务启动后在向注册中心注册服务启动信息，如下伪代码：

class RegistryProtocol {void export() {// 使用DubboProtocol暴漏服务，即启动netty，监听服务端口new DubboProtocol().export();// 完成服务启动后，将服务信息注册到注册中心registerServerInfo();}
}

详细的我们在2：Protocol一起看下。

2：Protocol

2.1:ProtocolFilterWrapper

源码如下：

class FakeCls {public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {// 当是注册中心地址暴漏时为true，即registry://为true，否则为false，此时是正常的服务暴漏，需要添加Filter链if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {// 2022-01-31 16:30:07return protocol.export(invoker);}// 添加Filter链，生成新的Invoker，然后再暴漏return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));}}

2022-01-31 16:30:07处是使用RegistryProtocol暴漏服务，因此这个方法主要做了如下的两件事：

1：注册服务到注册中心启动本地接收远程调用服务->注册服务信息到注册中心
2：暴漏服务

具体参考2.2:RegistryProtocol。

2.2:RegistryProtocol

源码如下：

class FakeCls {public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {// 2022-01-31 16:58:42// 暴漏服务，即启动本地相应的服务端口，准备接收来自网络的请求调用，注意此时服务还没有注册到注册中心final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);// 2022-02-06 16:46:37 URL registryUrl = getRegistryUrl(originInvoker);// 获得注册中心对象，该对象封装了注册和取消注册的相关操作，如zk就是在指定的节点建立相关的子节点final Registry registry = getRegistry(originInvoker);// 获取服务提供者地址，如dubbo://192.168.64.1:20826/dongshi.daddy.service.monitor.DubboMonitorService?...final URL registeredProviderUrl = getRegisteredProviderUrl(originInvoker);// 是否注册，正常为trueboolean register = registeredProviderUrl.getParameter("register", true);// 2022-02-07 11:16:00ProviderConsumerRegTable.registerProvider(originInvoker, registryUrl, registeredProviderUrl);// 注册服务地址到注册中心if (register) {// 2022-02-07 13:05:06// 注册服务地址到注册中心register(registryUrl, registeredProviderUrl);// 设置已经注册ProviderConsumerRegTable.getProviderWrapper(originInvoker).setReg(true);}// 容错相关配置final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registeredProviderUrl);final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);// 保证返回一个新的Exporter，Exporter在取消暴露时会用到return new DestroyableExporter<T>(exporter, originInvoker, overrideSubscribeUrl, registeredProviderUrl);}
}

2022-01-31 16:58:42处是暴漏服务具体参考2.2.1:doLocalExport。2022-02-06 16:46:37处是获取注册中心的地址，因为需要将服务注册到注册中心了，所以这里开始获取注册中心地址，具体参考2.2.2:getRegistryUrl。2022-02-07 11:16:00处是向本地注册表中注册服务，具体参考4:ProviderConsumerRegTable。2022-02-07 13:05:06处是注册服务地址到注册中心,具体参考2.2.3:register。

2.2.1:doLocalExport

该方法只是本地启动服务，而不会向注册中心注册服务。
源码如下：

class FakeCls {private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker) {// 2022-01-31 17:33:00String key = getCacheKey(originInvoker);// private final Map<String, ExporterChangeableWrapper<?>> bounds = new ConcurrentHashMap<String, ExporterChangeableWrapper<?>>(); 从bounds缓存中获取ExporterChangeableWrapper<T> exporter = (ExporterChangeableWrapper<T>) bounds.get(key);if (exporter == null) {// 上🔒synchronized (bounds) {// 2022-02-01 11:31:59exporter = (ExporterChangeableWrapper<T>) bounds.get(key);// 缓存中依然没有if (exporter == null) {// 封装InvokerDelegete对象，主要是增加了getInvoker方法，如下：/*public Invoker<T> getInvoker() {// 递归获取，可能存在invoker属性是InvokerDelegte的情况if (invoker instanceof InvokerDelegete) {return ((InvokerDelegete<T>) invoker).getInvoker();} else {return invoker;}}*/// getProviderUrl(originInvoker):获取服务暴漏地址，如dubbo://192.168.2.107:20826/dongshi.daddy.service.monitor.DubboMonitorService...final Invoker<?> invokerDelegete = new InvokerDelegete<T>(originInvoker, getProviderUrl(originInvoker));// 2022-02-01 17:11:26exporter = new ExporterChangeableWrapper<T>((Exporter<T>) protocol.export(invokerDelegete), originInvoker);bounds.put(key, exporter);}}}return exporter;}
}

2022-01-31 17:33:00处是获取bounds的缓存key，具体参考2.2.1.1:getCacheKey。2022-02-01 11:31:59处是执行DCL检查 ，防止进入同步的条件发生改变。2022-02-01 17:11:26处的protocol.export(invokerDelegete)我们来分析下，其中protocol是Protocol$Adaptive，在dubbo之服务本地暴露 文章中我们分析了Protocol$Adaptive动态生成的代码如下：

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])");com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);return extension.export(arg0);}
}

我们注意export方法中的代码String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());，根据协议来获取目标扩展名称，此时debug可以看到结果如下：

结果是dubbo，再考虑Wrapper 的情况，因此最终的调用顺序是ProtocolAdaptive->ProtocolListenerWrapper->PotocolFilterWrapper->DubboProtocol,具体调用过程参考3:DubboProtocol。

2.2.1.1:getCacheKey

源码如下：

class FakeCls {private String getCacheKey(final Invoker<?> originInvoker) {// 2022-01-31 17:38:19// 获取服务提供者地址URL providerUrl = getProviderUrl(originInvoker);// 删除dynamic，enabled，然后转成字符串作为缓存键，结果如：// dubbo://192.168.2.107:20826/dongshi.daddy.service.monitor.DubboMonitorService...String key = providerUrl.removeParameters("dynamic", "enabled").toFullString();return key;}
}

2022-01-31 17:38:19处是获取服务提供者的URL，源码如下：

class FakeCls {private URL getProviderUrl(final Invoker<?> origininvoker) {// 值在2022-01-31 17:39:34处已经设置，所以这里可以直接获取// 如：registry://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?...&export=// 获取的结果是：dubbo%3A%2F%2F192.168.2.107%3A20826%2Fdongshi.daddy.service.monitor.DubboMonitorServiceString export = origininvoker.getUrl().getParameterAndDecoded(Constants.EXPORT_KEY);// 这里必须有export，不然抛出java.lang.IllegalArgumentException异常if (export == null || export.length() == 0) {throw new IllegalArgumentException("The registry export url is null! registry: " + origininvoker.getUrl());}// 转成com.alibaba.dubbo.common.URL对象URL providerUrl = URL.valueOf(export);return providerUrl;}}

2.2.2:getRegistryUrl

源码如下：

class FakeCls {// com.alibaba.dubbo.registry.integration.RegistryProtocol.getRegistryUrlprivate URL getRegistryUrl(Invoker<?> originInvoker) {// 直接获取注册中心地址，如：registry://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?...URL registryUrl = originInvoker.getUrl();// 如果是"public static final String REGISTRY_PROTOCOL = "registry";"协议，即registry://if (Constants.REGISTRY_PROTOCOL.equals(registryUrl.getProtocol())) {// 获取registry参数的值作为新的协议名称，如我本地使用zk，是registry://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?...&registry=zookeeper...// 结果就是zookeeperString protocol = registryUrl.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_DIRECTORY);// 使用zookeeper作为新的协议名称，registry://127.0.0.1:2181... -> zookeeper://127.0.0.1:2181...registryUrl = registryUrl.setProtocol(protocol).removeParameter(Constants.REGISTRY_KEY);}// 结果如：zookeeper://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?...return registryUrl;}
}

2.2.3:register

源码如下：

class FakeCls {// com.alibaba.dubbo.registry.integration.RegistryProtocol.registerpublic void register(URL registryUrl, URL registedProviderUrl) {// 2022-02-07 14:17:03Registry registry = registryFactory.getRegistry(registryUrl);// 2022-02-07 15:51:34// 使用zk作为注册中心的话，这里获取的是com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistryregistry.register(registedProviderUrl);}
}

2022-02-07 14:17:03处是通过RegistryFactory获取Registry，其中RegistryFactory是一个自适应 的扩展接口，registryFactory是自动生成的自适应扩展类RegistryFactory$Adaptive。
RegistryFactory源码如下：

@SPI("dubbo")
public interface RegistryFactory {@Adaptive({"protocol"})Registry getRegistry(URL url);
}

自动生成代码如下：

package com.alibaba.dubbo.registry;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
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);}
}

执行代码String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );，获取的结果是extName=zookeeper,那么对应的是哪个扩展类呢，可以从META-INF\dubbo\internal\com.alibaba.dubbo.registry.RegistryFactory文件找到答案，内容如下：

dubbo=com.alibaba.dubbo.registry.dubbo.DubboRegistryFactory
multicast=com.alibaba.dubbo.registry.multicast.MulticastRegistryFactory
zookeeper=com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistryFactory
redis=com.alibaba.dubbo.registry.redis.RedisRegistryFactory

最终获取到的扩展类就是ZookeeperRegistryFactory，会调用其getRegistry，因为该方法是在其父类AbstractRegistryFactory中定义的，因此最终调用的方法如下：

class FakeCls {// com.alibaba.dubbo.registry.support.AbstractRegistryFactory.getRegistrypublic Registry getRegistry(URL url) {// 1：设置路径为com.alibaba.dubbo.registry.RegistryService// 2：设置参数interface=com.alibaba.dubbo.registry.RegistryService// 3：删除参数exporturl = url.setPath(RegistryService.class.getName()).addParameter(Constants.INTERFACE_KEY, RegistryService.class.getName()).removeParameters(Constants.EXPORT_KEY, Constants.REFER_KEY);// 缓存键，如zookeeper://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryServiceString key = url.toServiceString();LOCK.lock();try {// 缓存获取Registry registry = REGISTRIES.get(key);// 缓存有，直接returnif (registry != null) {return registry;}// 2022-02-07 14:58:54registry = createRegistry(url);// 不能拿不到if (registry == null) {throw new IllegalStateException("Can not create registry " + url);}// 放入缓存REGISTRIES.put(key, registry);return registry;} finally {LOCK.unlock();}}
}

2022-02-07 14:58:54处是创建Registry,具体参考2.2.4:createRegistry。2022-02-07 15:51:34处是通过对应注册中心的Registry注册服务提供者的url，具体参考2.2.5:注册服务地址到注册中心。

2.2.4:createRegistry

源码如下：

class FakeCls {// com.alibaba.dubbo.registry.support.AbstractRegistryFactory.createRegistryprotected abstract Registry createRegistry(URL url);
}

我们发现这是一个抽象的模板方法，具体调用的是com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistryFactory.createRegistry，源码如下：

class FakeCls {// com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistryFactory.createRegistrypublic Registry createRegistry(URL url) {// 直接new ZookeeperRegistry返回return new ZookeeperRegistry(url, zookeeperTransporter);}
}

ZookeeperRegistry构造函数如下：

class FakeCls {// com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistry.ZookeeperRegistrypublic ZookeeperRegistry(URL url, ZookeeperTransporter zookeeperTransporter) {super(url);if (url.isAnyHost()) {throw new IllegalStateException("registry address == null");}// dubboString group = url.getParameter(Constants.GROUP_KEY, DEFAULT_ROOT);// /dubboif (!group.startsWith(Constants.PATH_SEPARATOR)) {group = Constants.PATH_SEPARATOR + group;}this.root = group;// 获取操作zk的客户端对象zkClient = zookeeperTransporter.connect(url);// 增加状态变化监听器zkClient.addStateListener(new StateListener() {@Overridepublic void stateChanged(int state) {if (state == RECONNECTED) {try {recover();} catch (Exception e) {logger.error(e.getMessage(), e);}}}});}
}

2.2.5:注册服务地址到注册中心

我们这里以ZookeeperRegistry为例来说明，源码如下：

class FakeCls {// com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistry.doRegisterprotected void doRegister(URL url) {try {// toUrlPath(url):要创建的zk路径，如/dubbo/dongshi.daddy.service.monitor.DubboMonitorService/providers/dubbo...version%3D0.0.11// 执行后，对应的路径在zk就建立完毕，服务信息注册到注册中心，消费者可以通过注册中心获取服务提供者的信息了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);}}
}

3:DubboProtocol

源码如下：

class FakeCls {public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {// 获取url对象，如dubbo://192.168.2.107:20826/dongshi.daddy.service.monitor.DubboMonitorService...URL url = invoker.getUrl();// 2022-02-01 18:58:33String key = serviceKey(url);// exporterMap->new ConcurrentHashMap<String, Exporter<?>>();存储暴漏（本地启动服务）的服务DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);//zs 放到map中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);}}/*** 暂时忽略结束 ***/// 2022-02-02 10:10:53openServer(url);// 初始化序列器optimizeSerialization(url);return exporter;}
}

2022-02-01 18:58:33处是生成服务的唯一标识，具体参考3.1:serviceKey。2022-02-02 10:10:53处是启动服务器，具体参考3.2:openServer。

3.1:serviceKey

源码如下：

class FakeCls {protected static String serviceKey(URL url) {// 获取要绑定的端口，public static final String BIND_PORT_KEY = "bind.port";// dubbo://192.168.2.107:20826/dongshi.daddy.service.monitor.DubboMonitorService,结果是20826int port = url.getParameter(Constants.BIND_PORT_KEY, url.getPort());// port：20826，// url.getPath(): dongshi.daddy.service.monitor.DubboMonitorService// url.getParameter(Constants.VERSION_KEY)：如<dubbo:service ... version="0.0.11"/>,值为0.0.11// url.getParameter(Constants.GROUP_KEY): 如<dubbo:service ... group="xxxx"/>,值为xxxx// 2022-02-01 19:51:29return serviceKey(port, url.getPath(), url.getParameter(Constants.VERSION_KEY),url.getParameter(Constants.GROUP_KEY));}
}

2022-02-01 19:51:29处最终调用到方法com.alibaba.dubbo.rpc.support.ProtocolUtils.serviceKey(int, java.lang.String, java.lang.String, java.lang.String)源码如下：

class FakeCls {// com.alibaba.dubbo.rpc.support.ProtocolUtils.serviceKey(int, java.lang.String, java.lang.String, java.lang.String)public static String serviceKey(int port, String serviceName, String serviceVersion, String serviceGroup) {StringBuilder buf = new StringBuilder();// 组名称/if (serviceGroup != null && serviceGroup.length() > 0) {buf.append(serviceGroup);buf.append("/");}// 组名称/服务名称buf.append(serviceName);// 组名称/服务名称:版本号if (serviceVersion != null && serviceVersion.length() > 0 && !"0.0.0".equals(serviceVersion)) {buf.append(":");buf.append(serviceVersion);}// 组名称/服务名称:版本号:端口号buf.append(":");buf.append(port);// 结果如：xxxx/dongshi.daddy.service.monitor.DubboMonitorService:0.0.11:20826return buf.toString();}
}

3.2:openServer

源码如下：

class FakeCls {private void openServer(URL url) {// 使用地址作为唯一标识，如192.168.2.107:20826String key = url.getAddress();// url正常无该值，而默认值是true，所以这里可以认为是trueboolean isServer = url.getParameter(Constants.IS_SERVER_KEY, true);if (isServer) {// ExchangeServer代表了服务器，是Server接口的子接口// Map<String, ExchangeServer> serverMap = new ConcurrentHashMap<String, ExchangeServer>();// key；host:port value：ExchangeServerExchangeServer server = serverMap.get(key);if (server == null) {// 2022-02-05 20:26:00serverMap.put(key, createServer(url));// 当存在多个service时会有不为空的情况} else {// 因为间接继承了com.alibaba.dubbo.common.Resetable接口，所以这里可以重置相关属性server.reset(url);}}}
}

2022-02-05 20:26:00处是利用URL创建Server并添加到serverMap中，具体参考3.3:createServer。

3.3:createServer

源码如下：

class FakeCls {private ExchangeServer createServer(URL url) {// public static final String CHANNEL_READONLYEVENT_SENT_KEY = "channel.readonly.sent";// server关闭时发送READONLY事件 // dubbo://192.168.2.107:20826/dongshi.daddy.service.monitor.DubboMonitorService?...&channel.readonly.sent=true&...url = url.addParameterIfAbsent(Constants.CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString());// public static final int DEFAULT_HEARTBEAT = 60 * 1000;// public static final String HEARTBEAT_KEY = "heartbeat";// 启用心跳，默认心跳时长一分钟// dubbo://192.168.2.107:20826/dongshi.daddy.service.monitor.DubboMonitorService?...&heartbeat=60000&...url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));// public static final String SERVER_KEY = "server";// public static final String DEFAULT_REMOTING_SERVER = "netty";// 检验是否有对应名称的Transporter Dubbo SPI扩展类，Transporter是用于操作netty，mina等框架的接口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);// 使用dubbo codec编解码，即DubboCountCodecurl = url.addParameter(Constants.CODEC_KEY, DubboCodec.NAME);ExchangeServer server;try {// 2022-02-06 12:45:27server = Exchangers.bind(url, requestHandler);} catch (RemotingException e) {throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);}// 检验client扩展类必须存在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;}
}

2022-02-06 12:45:27处Exchangers是Exchanger的门面类 ，用来封装底层系统的细节，简化用户的使用,最后返回的是ExchangeServer，这是Server的一个子接口，定义如下：

public interface ExchangeServer extends Server {Collection<ExchangeChannel> getExchangeChannels();ExchangeChannel getExchangeChannel(InetSocketAddress remoteAddress);
}

bind方法执行输出的日志如下：

[2022-02-0613:06:28][INFO ][jpm-AbstractServer-<init>(65)]- [DUBBO] Start NettyServer bind /0.0.0.0:20826, export /192.168.2.107:20826, dubbo version: 2.6.6, current host: 192.168.2.107

可以看出来是启动了netty服务，并暴漏服务端口了。

4:ProviderConsumerRegTable

该类是用于进行本地服务消费者和服务提供者注册的支持类（工具类）,为了了服务提供者和服务消费者的Invoker，主要用于进行QOS(quality of service)，如上下线，统计等，相关代码如下：

public class ProviderConsumerRegTable {/*** 服务提供者Invoker集合* key：服务提供者URL*/public static ConcurrentHashMap<String, Set<ProviderInvokerWrapper>> providerInvokers = new ConcurrentHashMap<String, Set<ProviderInvokerWrapper>>();/*** 服务消费者Invoker集合* key：服务消费者URL*/public static ConcurrentHashMap<String, Set<ConsumerInvokerWrapper>> consumerInvokers = new ConcurrentHashMap<String, Set<ConsumerInvokerWrapper>>();// .... 省略方法
}

4.1:ProviderInvokerWrapper

provider invoker的wrapper类，主要是增加了一些额外的辅助运维属性，比如标记是否注册的属性isReg,当进行下线操作后就可以修改为false，代表已经下线，主要属性如下：

class FakeCls {/*** Invoker 对象*/private Invoker<T> invoker;/*** 原始 URL*/private URL originUrl;/*** 注册中心 URL*/private URL registryUrl;/*** 服务提供者 URL*/private URL providerUrl;/*** 是否注册*/private volatile boolean isReg;
}

4.2:ConsumerInvokerWrapper

consumer invoker的wrapper类，主要是增加了一些额外的属性，如下：

class FakeCls {/*** Invoker 对象*/private Invoker<T> invoker;/*** 原始 URL*/private URL originUrl;/*** 注册中心 URL*/private URL registryUrl;/*** 消费者 URL*/private URL consumerUrl;/*** 注册中心 Directory*/private RegistryDirectory registryDirectory;
}