dubbo之服务远程暴露

一户董

已于 2022-02-08 18:35:44 修改

阅读量1.7k

点赞数

分类专栏： dubbo 文章标签： dubbo 服务暴漏远程服务暴漏

于 2022-01-21 20:59:34 首次发布

本文链接：https://blog.csdn.net/wang0907/article/details/122629306

版权

dubbo 专栏收录该内容

35 篇文章 4 订阅

订阅专栏

写在前面

在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，这里会为true
            if (!Constants.SCOPE_REMOTE.toString().equalsIgnoreCase(scope)) {
                // 省略本地暴漏逻辑
            }
            // scope="remote"，或者是没有配置scope，此时scope=null，这里会为true
            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()) {
                    // 如：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);
                        }
                        // 服务提供者使用，用来启用使用定制的代理类生成invoker
                        String 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:03
                        Exporter<?> 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:07
            return 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);
        // 是否注册，正常为true
        boolean register = registeredProviderUrl.getParameter("register", true);
        // 2022-02-07 11:16:00
        ProviderConsumerRegTable.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:00
        String 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:59
                exporter = (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:26
                    exporter = 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.DubboMonitorService
        String 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.getRegistryUrl
    private 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...
            // 结果就是zookeeper
            String 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.register
    public void register(URL registryUrl, URL registedProviderUrl) {
        // 2022-02-07 14:17:03
        Registry registry = registryFactory.getRegistry(registryUrl);
        // 2022-02-07 15:51:34
        // 使用zk作为注册中心的话，这里获取的是com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistry
        registry.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.getRegistry
    public Registry getRegistry(URL url) {
        // 1：设置路径为com.alibaba.dubbo.registry.RegistryService
        // 2：设置参数interface=com.alibaba.dubbo.registry.RegistryService
        // 3：删除参数export
        url = 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.RegistryService
        String key = url.toServiceString();
        LOCK.lock();
        try {
            // 缓存获取
            Registry registry = REGISTRIES.get(key);
            // 缓存有，直接return
            if (registry != null) {
                return registry;
            }
            // 2022-02-07 14:58:54
            registry = 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.createRegistry
    protected abstract Registry createRegistry(URL url);
}

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

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

ZookeeperRegistry构造函数如下：

class FakeCls {
    // com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistry.ZookeeperRegistry
    public ZookeeperRegistry(URL url, ZookeeperTransporter zookeeperTransporter) {
        super(url);
        if (url.isAnyHost()) {
            throw new IllegalStateException("registry address == null");
        }
        // dubbo
        String group = url.getParameter(Constants.GROUP_KEY, DEFAULT_ROOT);
        // /dubbo
        if (!group.startsWith(Constants.PATH_SEPARATOR)) {
            group = Constants.PATH_SEPARATOR + group;
        }
        this.root = group;
        // 获取操作zk的客户端对象
        zkClient = zookeeperTransporter.connect(url);
        // 增加状态变化监听器
        zkClient.addStateListener(new StateListener() {
            @Override
            public 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.doRegister
    protected 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:33
        String 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:53
        openServer(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,结果是20826
        int 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:29
        return 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:20826
        return buf.toString();
    }
}

3.2:openServer

源码如下：

class FakeCls {
    private void openServer(URL url) {
        // 使用地址作为唯一标识，如192.168.2.107:20826
        String key = url.getAddress();
        // url正常无该值，而默认值是true，所以这里可以认为是true
        boolean isServer = url.getParameter(Constants.IS_SERVER_KEY, true);
        if (isServer) {
            // ExchangeServer代表了服务器，是Server接口的子接口
            // Map<String, ExchangeServer> serverMap = new ConcurrentHashMap<String, ExchangeServer>();
            // key；host:port value：ExchangeServer
            ExchangeServer server = serverMap.get(key);
            if (server == null) {
                // 2022-02-05 20:26:00
                serverMap.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编解码，即DubboCountCodec
        url = url.addParameter(Constants.CODEC_KEY, DubboCodec.NAME);
        ExchangeServer server;
        try {
            // 2022-02-06 12:45:27
            server = 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;
}