服务暴露

dubbo框架做服务暴露分为两大部分，第一步将持有的服务实例通过代理转换成Invoker，第二步会把Invoker通过具体的协议（比如dubbo）转换成Exporter。

源码分析

1 服务导出的入口方法是 ServiceBean 的 onApplicationEvent。onApplicationEvent 是一个事件响应方法，该方法会在收到 Spring 上下文刷新事件后执行服务导出操作。方法代码如下：

public void onApplicationEvent(ContextRefreshedEvent event) {

    if (isDelay() && !isExported() && !isUnexported()) {

    if (logger.isInfoEnabled()) {

        logger.info("The service ready on spring started. service: " + getInterface());

    }

    export();

}

}

2 框架真正进行服务暴露的入口点在ServiceConfig#doExport中

在导出服务之前，Dubbo 需要检查用户的配置是否合理，或者为用户补充缺省配置。配置检查完成后，接下来需要根据这些配置组装 URL。在 Dubbo 中，URL 的作用十分重要。

checkApplication();

checkRegistry();

checkProtocol();

appendProperties(this);

3 dubbo支持多注册中心同时写，如果配置了服务同时注册多个注册中心，则会在ServiceConfig#doExportUrls中依次暴露。

private void doExportUrls() {

    // 获取当前服务对应的注册中心实例

    List registryURLs = loadRegistries(true);

    // 如果服务指定暴露多个协议（dubbo，rest），则依次暴露服务

    for (ProtocolConfig protocolConfig :protocols) {

        doExportUrlsFor1Protocol(protocolConfig, registryURLs);

    }

}

4 真实暴露服务逻辑是在doExportUrlsFor1Protocol方法中

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List registryURLs) {

        String name = protocolConfig.getName();

        if (name == null || name.length() == 0) {

            name = "dubbo";

        }

        // 读取其他配置信息到map，用于后续构造URL

        appendParameters(map, application);

        appendParameters(map, module);

        // 读取全局配置信息，会自动添加前缀

        appendParameters(map, provider, Constants.DEFAULT_KEY);

        appendParameters(map, protocolConfig);

        appendParameters(map, this);

        // export service

        if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)

                .hasExtension(url.getProtocol())) {

            url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)

                    .getExtension(url.getProtocol()).getConfigurator(url).configure(url);

        }

        String scope = url.getParameter(Constants.SCOPE_KEY);

        // don't export when none is configured

        if (!Constants.SCOPE_NONE.toString().equalsIgnoreCase(scope)) {

            // export to local if the config is not remote (export to remote only when config is remote)

            if (!Constants.SCOPE_REMOTE.toString().equalsIgnoreCase(scope)) {

                // 本地服务暴露

                exportLocal(url);

            }

            // export to remote if the config is not local (export to local only when config is 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()) {

                    for (URL registryURL : registryURLs) {

                        url = url.addParameterIfAbsent(Constants.DYNAMIC_KEY, registryURL.getParameter(Constants.DYNAMIC_KEY));

                        URL monitorUrl = loadMonitor(registryURL);

                        // 如果配置了监控地址，则服务调用信息会上报

                        if (monitorUrl != null) {

                            url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString());

                        }

                         // For providers, this is used to enable custom proxy to generate invoker

                        String proxy = url.getParameter(Constants.PROXY_KEY);

                        if (StringUtils.isNotEmpty(proxy)) {

                            registryURL = registryURL.addParameter(Constants.PROXY_KEY, proxy);

                        }

                        // 通过动态代理转换成Invoker，registryURL存储的是注册中心地址，使用export作为key追加服务元数据信息

                        Invoker invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));

                        DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);

                        // 服务暴露后向注册中心注册服务信息

                        Exporter exporter = protocol.export(wrapperInvoker);

                        exporters.add(exporter);

                    }

                } else {

                    // 处理没有注册中心场景，直接暴露服务

                    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);

    }

有注册中心和无注册中心的URL：

registry://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?application=demo-provider&dubbo=2.0.2&export=dubbo%3A%2F%2F172.17.48.52%3A20880%2Fcom.alibaba.dubbo.demo.DemoService%3Fanyhost%3Dtrue%26application%3Ddemo-provider

dubbo://ip:20880/com.alibaba.dubbo.demo.DemoService?anyhost=true&application=demo-provider&dubbo=2.0.2&generic=false&interface=com.alibaba.dubbo.demo.DemoService&methods=sayHello 

注册中心在做服务暴露时依次做了一下事情：

（1）委托具体协议（dubbo）进行服务暴露，创建NettyServer监听端口和保存服务实例。

（2）创建注册中心对象，与注册中心创建TCP连接。

（3）注册服务元数据到注册中心。

（4）订阅configurators节点，监听服务动态属性变更事件。

（5）服务销毁收尾工作，比如 关闭端口，反注册服务信息等。

6  有注册中心时，通过RegistryProtocol#export进行更细粒度的控制

public Exporter export(final Invoker originInvoker)throws RpcException {

    //export invoker 打开端口，把服务实例存储到map    

    final ExporterChangeableWrapper exporter = doLocalExport(originInvoker);

    URL registryUrl = getRegistryUrl(originInvoker);

    //registry provider  创建注册中心实例

    final Registry registry = getRegistry(originInvoker);

    final URL registeredProviderUrl = getRegisteredProviderUrl(originInvoker);

    //to judge to delay publish whether or not

    boolean register = registeredProviderUrl.getParameter("register",true);

    ProviderConsumerRegTable.registerProvider(originInvoker, registryUrl, registeredProviderUrl);

    if (register) {

    // 服务暴露后，注册服务元数据

        register(registryUrl, registeredProviderUrl);

        ProviderConsumerRegTable.getProviderWrapper(originInvoker).setReg(true);

    }

    // Subscribe the override data

    // FIXME When the provider subscribes, it will affect the scene : a certain JVM exposes the service and call the same service. Because the subscribed is cached key with the name of the service, it causes the subscription information to cover.

    final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registeredProviderUrl);

    final OverrideListener overrideSubscribeListener =new OverrideListener(overrideSubscribeUrl, originInvoker);

    overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);

    // 监听服务接口下configurators节点，用于处理动态配置

    registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);

    //Ensure that a new exporter instance is returned every time export

    return new DestroyableExporter(exporter, originInvoker, overrideSubscribeUrl, registeredProviderUrl);

}

7 服务暴露前，框架会做拦截器初始化，dubbo在加载protocol扩展点时会自动注入ProtocolListenerWrapper 和 ProtocolFilterWrapper。

ProtocolListenerWrapper -》 ProtocolFilterWrapper -》 DubboProtocol

拦截器构造：

public Exporter export(Invoker invoker)throws RpcException {

    if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {

    return protocol.export(invoker);

    }

    // 先构建拦截器链（会过滤provider端分组），然后触发dubbo协议暴露

    return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));

}