dubbo源码分析：服务暴露

服务暴露以一个demo为例：

Provider：
public interface ProviderExport {

    String providerExport(String name);

}

public class ProviderExportImpl implements ProviderExport {

    @Override
    public String providerExport(String name) {
        System.out.println("providerExport 。。。");
        return "providerExport 。。。";
    }
}

dubbo.xml：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        ">

  <!-- 必须要有的：提供方应用信息，用于计算依赖关系 -->
  <dubbo:application name="dubbo-spi" />

  <!-- 使用zookeeper注册中心暴露服务地址 -->
  <dubbo:registry address="zookeeper://127.0.0.1:2181" />

  <!-- 用dubbo协议在20880端口暴露服务 -->
  <dubbo:protocol name="dubbo" port="20880" />

  <bean id="providerExportImpl" class="com.kl.dubbotest.provider.export.ProviderExportImpl"/>

  <!-- 声明需要暴露的服务接口 -->
  <dubbo:service interface="com.kl.dubbotest.provider.export.ProviderExport" ref="providerExportImpl" retries="0"/>

</beans>

服务暴露有两个入口：
（1）在ServiceBean类的onApplicationEvent()方法，在容器初始化完成后，执行暴露逻辑
（2）ServiceBean类的afterPropertiesSet()方法，当前servicebean属性构造完成后，执行暴露逻辑

ServiceBean#afterPropertiesSet：服务暴露入口

/**
* 当前servicebean属性构造完成后，执行暴露逻辑
* 整体逻辑：
* （1）校验配置是否为空
* （2）不是延迟暴露的情况下暴露服务export()
* @throws Exception
*/
@SuppressWarnings({ "unchecked", "deprecation" })
public void afterPropertiesSet() throws Exception {
    //Spring启动后，ProviderConfig不可能为空，因为dubbo配置文件已经解析完成，如果为空则重新设置一次
       if (getProvider() == null) {
           Map<String, ProviderConfig> providerConfigMap = applicationContext == null ? null  : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ProviderConfig.class, false, false);
           if (providerConfigMap != null && providerConfigMap.size() > 0) {
               Map<String, ProtocolConfig> protocolConfigMap = applicationContext == null ? null  : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ProtocolConfig.class, false, false);
               if ((protocolConfigMap == null || protocolConfigMap.size() == 0)
                       && providerConfigMap.size() > 1) { // 兼容旧版本
                   List<ProviderConfig> providerConfigs = new ArrayList<ProviderConfig>();
                   for (ProviderConfig config : providerConfigMap.values()) {
                       if (config.isDefault() != null && config.isDefault().booleanValue()) {
                           providerConfigs.add(config);
                       }
                   }
                   if (providerConfigs.size() > 0) {
                       setProviders(providerConfigs);
                   }
               } else {
                   ProviderConfig providerConfig = null;
                   for (ProviderConfig config : providerConfigMap.values()) {
                       if (config.isDefault() == null || config.isDefault().booleanValue()) {
                           if (providerConfig != null) {
                               throw new IllegalStateException("Duplicate provider configs: " + providerConfig + " and " + config);
                           }
                           providerConfig = config;
                       }
                   }
                   if (providerConfig != null) {
                       setProvider(providerConfig);
                   }
               }
           }
       }

       //Spring启动后，ApplicationConfig不可能为空，因为dubbo配置文件已经解析完成，如果为空则重新设置一次
       if (getApplication() == null
               && (getProvider() == null || getProvider().getApplication() == null)) {
           Map<String, ApplicationConfig> applicationConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ApplicationConfig.class, false, false);
           if (applicationConfigMap != null && applicationConfigMap.size() > 0) {
               ApplicationConfig applicationConfig = null;
               for (ApplicationConfig config : applicationConfigMap.values()) {
                   if (config.isDefault() == null || config.isDefault().booleanValue()) {
                       if (applicationConfig != null) {
                           throw new IllegalStateException("Duplicate application configs: " + applicationConfig + " and " + config);
                       }
                       applicationConfig = config;
                   }
               }
               if (applicationConfig != null) {
                   setApplication(applicationConfig);
               }
           }
       }

       //Spring启动后，ModuleConfig不可能为空，因为dubbo配置文件已经解析完成，如果为空则重新设置一次
       if (getModule() == null
               && (getProvider() == null || getProvider().getModule() == null)) {
           Map<String, ModuleConfig> moduleConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ModuleConfig.class, false, false);
           if (moduleConfigMap != null && moduleConfigMap.size() > 0) {
               ModuleConfig moduleConfig = null;
               for (ModuleConfig config : moduleConfigMap.values()) {
                   if (config.isDefault() == null || config.isDefault().booleanValue()) {
                       if (moduleConfig != null) {
                           throw new IllegalStateException("Duplicate module configs: " + moduleConfig + " and " + config);
                       }
                       moduleConfig = config;
                   }
               }
               if (moduleConfig != null) {
                   setModule(moduleConfig);
               }
           }
       }

       //Spring启动后，List<RegistryConfig>不可能为空，因为dubbo配置文件已经解析完成，如果为空则重新设置一次
       if ((getRegistries() == null || getRegistries().size() == 0)
               && (getProvider() == null || getProvider().getRegistries() == null || getProvider().getRegistries().size() == 0)
               && (getApplication() == null || getApplication().getRegistries() == null || getApplication().getRegistries().size() == 0)) {
           Map<String, RegistryConfig> registryConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, RegistryConfig.class, false, false);
           if (registryConfigMap != null && registryConfigMap.size() > 0) {
               List<RegistryConfig> registryConfigs = new ArrayList<RegistryConfig>();
               for (RegistryConfig config : registryConfigMap.values()) {
                   if (config.isDefault() == null || config.isDefault().booleanValue()) {
                       registryConfigs.add(config);
                   }
               }
               if (registryConfigs != null && registryConfigs.size() > 0) {
                   super.setRegistries(registryConfigs);
               }
           }
       }

       //同上
       if (getMonitor() == null
               && (getProvider() == null || getProvider().getMonitor() == null)
               && (getApplication() == null || getApplication().getMonitor() == null)) {
           Map<String, MonitorConfig> monitorConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, MonitorConfig.class, false, false);
           if (monitorConfigMap != null && monitorConfigMap.size() > 0) {
               MonitorConfig monitorConfig = null;
               for (MonitorConfig config : monitorConfigMap.values()) {
                   if (config.isDefault() == null || config.isDefault().booleanValue()) {
                       if (monitorConfig != null) {
                           throw new IllegalStateException("Duplicate monitor configs: " + monitorConfig + " and " + config);
                       }
                       monitorConfig = config;
                   }
               }
               if (monitorConfig != null) {
                   setMonitor(monitorConfig);
               }
           }
       }

       //同上
       if ((getProtocols() == null || getProtocols().size() == 0)
               && (getProvider() == null || getProvider().getProtocols() == null || getProvider().getProtocols().size() == 0)) {
           Map<String, ProtocolConfig> protocolConfigMap = applicationContext == null ? null  : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ProtocolConfig.class, false, false);
           if (protocolConfigMap != null && protocolConfigMap.size() > 0) {
               List<ProtocolConfig> protocolConfigs = new ArrayList<ProtocolConfig>();
               for (ProtocolConfig config : protocolConfigMap.values()) {
                   if (config.isDefault() == null || config.isDefault().booleanValue()) {
                       protocolConfigs.add(config);
                   }
               }
               if (protocolConfigs != null && protocolConfigs.size() > 0) {
                   super.setProtocols(protocolConfigs);
               }
           }
       }

       //同上
       if (getPath() == null || getPath().length() == 0) {
           if (beanName != null && beanName.length() > 0 
                   && getInterface() != null && getInterface().length() > 0
                   && beanName.startsWith(getInterface())) {
               setPath(beanName);
           }
       }


       //是否是延迟暴露服务，看dubbo:provider中delay属性的配置，默认为立即暴露
       if (! isDelay()) {
           export();
       }
   }

ServiceConfig#export：服务的暴露

/**
 * 服务暴露整体逻辑：
 * （1）<dubbo:provider> export属性， 判断是否要暴露服务，export=false代表不暴露
 * （2）<dubbo:provider> delay属性，delay>0延迟暴露，否则为立即暴露
 */
public synchronized void export() {
    if (provider != null) {
        if (export == null) {
            //<dubbo:provider> export="false"
            export = provider.getExport();
        }
        if (delay == null) {
            delay = provider.getDelay();
        }
    }

    // 如果 export 为 false，则不暴露服务
    if (export != null && ! export.booleanValue()) {
        return;
    }

    //delay > 0，延迟暴露，启动一个线程延迟暴露
    if (delay != null && delay > 0) {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(delay);
                } catch (Throwable e) {
                }
                doExport();
            }
        });
        thread.setDaemon(true);
        thread.setName("DelayExportServiceThread");
        thread.start();
    }
    // 立即暴露服务
    else {
        doExport();
    }
}

ServiceConfig#doExport：服务的暴露

ServiceConfig#doExport：
protected synchronized void doExport() {
    if (unexported) {
        throw new IllegalStateException("Already unexported!");
    }
    //如果已经暴露过服务了，就不需要再次操作了
    if (exported) {
        return;
    }
    exported = true;
    //<dubbo:service interface="" /> 接口名必须配置
    if (interfaceName == null || interfaceName.length() == 0) {
        throw new IllegalStateException("<dubbo:service interface=\"\" /> interface not allow null!");
    }
    // 检测 provider 是否为空，为空则新建一个，并通过系统变量为其初始化
    checkDefault();
    //以下为if判空，为空则从对应实例中获取一次
    if (provider != null) {
        if (application == null) {
            application = provider.getApplication();
        }
        if (module == null) {
            module = provider.getModule();
        }
        if (registries == null) {
            registries = provider.getRegistries();
        }
        if (monitor == null) {
            monitor = provider.getMonitor();
        }
        if (protocols == null) {
            protocols = provider.getProtocols();
        }
    }
    if (module != null) {
        if (registries == null) {
            registries = module.getRegistries();
        }
        if (monitor == null) {
            monitor = module.getMonitor();
        }
    }
    if (application != null) {
        if (registries == null) {
            registries = application.getRegistries();
        }
        if (monitor == null) {
            monitor = application.getMonitor();
        }
    }

    //ref为GenericService，标识generic=true，interfaceClass=GenericService.class(通用服务接口)
    if (ref instanceof GenericService) {
        interfaceClass = GenericService.class;
        generic = true;
    }
    //ref非GenericService
    else {
        try {
            //反射获取interfaceClass
            interfaceClass = Class.forName(interfaceName, true, Thread.currentThread()
                    .