0 前言

Dubbo是阿里巴巴開源的基於Java實現的高效能、透明化的RPC框架。深入瞭解Dubbo原始碼，有助於快速定位問題、高效實現自定義擴充。本文以Dubbo服務端初始化過程為例，分析Dubbo怎麼從配置轉化成可被呼叫的服務。

以典型的服務端結合Spring配置為例：

<!-- 提供方應用資訊，用於計算依賴關係 -->  
<dubbo:application name="demo-provider"/>  
<!-- 用dubbo協議在20880埠暴露服務 -->  
<dubbo:protocol name="dubbo" port="20880"/>  
<!-- 使用zookeeper註冊中心暴露服務地址 -->  
<dubbo:registry address="zookeeper://127.0.0.1:1234" id="registry"/>  
<!-- 預設的服務端配置 -->  
<dubbo:provider registry="registry" retries="0" timeout="5000"/>  
<!-- 和本地bean一樣實現服務 -->  
<bean id="demoService" class="com.alibaba.dubbo.demo.provider.DemoServiceImpl"/>  
<!-- 宣告需要暴露的服務介面 -->  
<dubbo:service interface="com.alibaba.dubbo.demo.DemoService" ref="demoService"/>  
複製程式碼

在Dubbo名稱空間下定義了一系列XML節點，如：application、protocol、registry、provider、service 等，Dubbo通過實現Spring提供的 NamespaceHandler 介面，向Spring註冊 BeanDefinition 解析器，使Spring能識別Dubbo名稱空間下的節點，並且通過實現 BeanDefinitionParser 介面，使Spring能解析各節點的具體配置。

DubboNamespaceHandler#init() ，原始碼如下：

public void init() {  
    registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
    registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
    registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
    registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
    registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
    registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
    registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
    registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
    registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
    registerBeanDefinitionParser("annotation", new DubboBeanDefinitionParser(AnnotationBean.class, true));
}
複製程式碼

由以上程式碼可以看出，各個節點最終被轉化為各種Bean，配置的各種屬性也被轉化為Bean的屬性。從Bean的型別可以看出，大部分Bean只用於提供Dubbo的執行引數，只有 ServiceBean 才是本文服務釋出分析入口。

備註：DubboNamespaceHandler.java & DubboBeanDefinitionParser.java 原始碼分析，請參考《☆聊聊Dubbo（四）：核心原始碼-切入Spring》一文。

1 ServiceBean 核心入口

Dubbo服務提供者由 dubbo:service 來定義的，從前面可以看到，Spring把 dubbo:service 解析成一個ServiceBean，ServiceBean實現了 ApplicationListener 和 InitializingBean 介面，ServiceBean有個核心方法 export，在這個方法中初始化服務提供者並且暴露遠端服務。這個方法在bean初始化或容器中所有bean重新整理完畢時被呼叫，根據 provider 的延遲設定決定，如果設定了延遲（ delay 屬性）則在bean初始化結束之後呼叫，否則在重新整理事件中被呼叫，預設會延遲 export，即在所有bean的重新整理結束被呼叫。

在 com.alibaba.dubbo.config.spring.ServiceBean 類，原始碼如下：

public class ServiceBean<T> extends ServiceConfig<T> implements InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener, BeanNameAware {  
    ...
    public void afterPropertiesSet() {}
    ...
    public void onApplicationEvent(ApplicationEvent event) {}
    ...
    public void destroy() {}
}
複製程式碼

ServiceBean 實現了Spring的 InitializingBean、DisposableBean、 ApplicationListener 等介面，實現了 afterPropertiesSet()、 destroy()、 onApplicationEvent() 等典型方法，這裡便是Dubbo和Spring整合的關鍵，一般第三方框架基本都是通過這幾個介面和Spring整合的。

afterPropertiesSet() 主要用來注入各種 ConfigBean，便於服務註冊過程中各種引數的獲取，注意看最後關於延遲釋出的幾行程式碼，大意是如果不延遲，就立即註冊和暴露服務。

ServiceBean#afterPropertiesSet()，原始碼如下：

    public void afterPropertiesSet() throws Exception {
        // @ step1
        if (getProvider() == null) { 
            // BeanFactoryUtils.beansOfTypeIncludingAncestors 究竟做了什麼？
            // 返回指定型別和子型別的所有bean，若該bean factory 是一個繼承型別的beanFactory，這個方法也會獲取祖宗factory中定義的指定型別的bean。
            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) { // backward compatibility
                    List<ProviderConfig> providerConfigs = new ArrayList<ProviderConfig>();
                    for (ProviderConfig config : providerConfigMap.values()) {
                        if (config.isDefault() != null && config.isDefault()) {
                            providerConfigs.add(config);
                        }
                    }
                    if (!providerConfigs.isEmpty()) {
                        setProviders(providerConfigs);
                    }
                } else {
                    ProviderConfig providerConfig = null;
                    for (ProviderConfig config : providerConfigMap.values()) {
                        if (config.isDefault() == null || config.isDefault()) {
                            if (providerConfig != null) {
                                throw new IllegalStateException("Duplicate provider configs: " + providerConfig + " and " + config);
                            }
                            providerConfig = config;
                        }
                    }
                    if (providerConfig != null) {
                        setProvider(providerConfig);
                    }
                }
            }
        }
        // @ step2
        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()) {
                        if (applicationConfig != null) {
                            throw new IllegalStateException("Duplicate application configs: " + applicationConfig + " and " + config);
                        }
                        applicationConfig = config;
                    }
                }
                if (applicationConfig != null) {
                    setApplication(applicationConfig);
                }
            }
        }
        // @ step3
        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()) {
                        if (moduleConfig != null) {
                            throw new IllegalStateException("Duplicate module configs: " + moduleConfig + " and " + config);
                        }
                        moduleConfig = config;
                    }
                }
                if (moduleConfig != null) {
                    setModule(moduleConfig);
                }
            }
        }
        // @ step4
        if ((getRegistries() == null || getRegistries().isEmpty())
                && (getProvider() == null || getProvider().getRegistries() == null || getProvider().getRegistries().isEmpty())
                && (getApplication() == null || getApplication().getRegistries() == null || getApplication().getRegistries().isEmpty())) {
            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()) {
                        registryConfigs.add(config);
                    }
                }
                if (!registryConfigs.isEmpty()) {
                    super.setRegistries(registryConfigs);
                }
            }
        }
        // @ step5
        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()) {
                        if (monitorConfig != null) {
                            throw new IllegalStateException("Duplicate monitor configs: " + monitorConfig + " and " + config);
                        }
                        monitorConfig = config;
                    }
                }
                if (monitorConfig != null) {
                    setMonitor(monitorConfig);
                }
            }
        }
        // @ step6
        if ((getProtocols() == null || getProtocols().isEmpty())
                && (getProvider() == null || getProvider().getProtocols() == null || getProvider().getProtocols().isEmpty())) {
            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()) {
                        protocolConfigs.add(config);
                    }
                }
                if (!protocolConfigs.isEmpty()) {
                    super.setProtocols(protocolConfigs);
                }
            }
        }
        // @ step7
        if (getPath() == null || getPath().length() == 0) {
            if (beanName != null && beanName.length() > 0
                    && getInterface() != null && getInterface().length() > 0
                    && beanName.startsWith(getInterface())) {
                setPath(beanName);
            }
        }
        // @ step8
        if (!isDelay()) {
            export();
        }
    }
複製程式碼

Step1：如果 provider 為空，說明 dubbo:service 標籤未設定 provider 屬性，則嘗試從 BeanFactory 中查詢 dubbo:provider 例項，如果存在一個 dubbo:provider 標籤，則取該例項，如果存在多個 dubbo:provider 配置則 provider 屬性不能為空，否則丟擲異常：“Duplicate provider configs”。

Step2：如果 application 為空，說明 dubbo:service 標籤未設定 application 屬性，則嘗試從 BeanFactory 中查詢 dubbo:application 例項，如果存在一個 dubbo:application 標籤，則取該例項，如果存在多個 dubbo:application 配置，則丟擲異常：“Duplicate application configs”。

Step3：如果 module 為空，說明 dubbo:service 標籤未設定 module 屬性，則嘗試從 BeanFactory 中查詢 dubbo:module 例項，如果存在一個 dubbo:module 標籤，則取該例項，如果存在多個 dubbo:module，則丟擲異常：“Duplicate module configs”。

Step4：（邏輯同上）嘗試從 BeanFactory 中載入所有的註冊中心，注意 ServiceBean 的 List registries 屬性，為註冊中心集合。

Step5：（邏輯同上）嘗試從 BeanFacotry 中載入一個監控中心，填充 ServiceBean 的 MonitorConfig monitor 屬性，如果存在多個 dubbo:monitor 配置，則丟擲”Duplicate monitor configs: “。

Step6：（邏輯同上）嘗試從 BeanFactory 中載入所有的協議，注意： ServiceBean 的 List protocols 是一個集合，也即一個服務可以通過多種協議暴露給消費者。

Step7：（邏輯同上）設定 ServiceBean 的 path 屬性，path 屬性存放的是 dubbo:service 的 beanName（dubbo:service id)。

Step8：如果為啟用延遲暴露機制，則呼叫 export 暴露服務。首先看一下 isDelay 的實現，然後重點分析 export 的實現原理（服務暴露的整個實現原理）。

ServiceBean#isDelay()，原始碼如下：

    private boolean isDelay() {
        Integer delay = getDelay();
        ProviderConfig provider = getProvider();
        if (delay == null && provider != null) {
            delay = provider.getDelay();
        }
        return supportedApplicationListener && (delay == null || delay == -1);
    }
複製程式碼

先從 ServiceConfig 獲取 delay 屬性，如果為 null，則獲取 ProviderConfig 的 delay 屬性，最後如果還是 null 或配置為 -1 表示延遲暴露服務。可見Dubbo獲取執行引數的層級，便於更精確化的配置各種引數。

通過 supportedApplicationListener 可以猜到服務延遲暴露是通過Spring容器的監聽器觸發的。個人更傾向於明確設定 delay=-1 或者所有層級都不配置，因為如果提早暴露服務，此時其他的Spring bean可能還未初始化完成，而暴露出去的服務大部分情況下依賴於Spring的其他bean來實現業務功能，如果提早接收到客戶端的請求，難免會出現各種異常。

ServiceBean#onApplicationEvent()，原始碼如下：

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (isDelay() && !isExported() && !isUnexported()) {
            if (logger.isInfoEnabled()) {
                logger.info("The service ready on spring started. service: " + getInterface());
            }
            export();
        }
    }
複製程式碼

如果有設定 dubbo:service 或 dubbo:provider 的屬性 delay，或配置 delay 為 -1，都表示啟用延遲機制，單位為毫秒，設定為 -1，表示等到Spring容器初始化後再暴露服務。

從這裡也可以看出，Dubbo暴露服務的處理入口為：ServiceBean#export --> ServiceConfig#export。

2 ServiceConfig 暴露服務

從前一節程式碼分析可知，最後一步是呼叫 ServiceBean 的父類 ServiceConfig#export方法暴露服務。

2.1 第一步：ServiceConfig#export 暴露服務

呼叫鏈：ServiceBean#afterPropertiesSet --> ServiceConfig#export

    public synchronized void export() {
        if (provider != null) {
            if (export == null) {
                export = provider.getExport();
            }
            if (delay == null) {
                delay = provider.getDelay();
            }
        }
        if (export != null && !export) {   // @ step1
            return;
        }

        if (delay != null && delay > 0) {    // @ step2
            delayExportExecutor.schedule(new Runnable() {
                @Override
                public void run() {
                    doExport();
                }
            }, delay, TimeUnit.MILLISECONDS);
        } else {
            doExport();    // @ step3
        }
    }
複製程式碼

Step1：判斷是否暴露服務，由 dubbo:service export=“true|false” 來指定。

Step2：如果啟用了 delay 機制，如果 delay 大於0，表示延遲多少毫秒後暴露服務，使用 ScheduledExecutorService 延遲排程，最終呼叫 doExport 方法。

Step3：執行具體的暴露邏輯 doExport，需要大家留意：delay=-1 的處理邏輯（ 基於Spring事件機制觸發 ）。

2.2 第二步：ServiceConfig#doExport 暴露服務

呼叫鏈：ServiceBean#afterPropertiesSet --> ServiceConfig#export --> ServiceConfig#doExport

    protected synchronized void doExport() {
        if (unexported) {
            throw new IllegalStateException("Already unexported!");
        }
        if (exported) {
            return;
        }
        exported = true;
        if (interfaceName == null || interfaceName.length() == 0) {
            throw new IllegalStateException("<dubbo:service interface=\"\" /> interface not allow null!");
        }
        checkDefault(); // @ step1
        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();
            }
        }
        if (ref instanceof GenericService) { // @ step2
            interfaceClass = GenericService.class;
            if (StringUtils.isEmpty(generic)) {
                generic = Boolean.TRUE.toString();
            }
        } else {
            try {
                interfaceClass = Class.forName(interfaceName, true, Thread.currentThread()
                        .getContextClassLoader());
            } catch (ClassNotFoundException e) {
                throw new IllegalStateException(e.getMessage(), e);
            }
            checkInterfaceAndMethods(interfaceClass, methods);
            checkRef();
            generic = Boolean.FALSE.toString();
        }
        if (local != null) { // @ step3
            if ("true".equals(local)) {
                local = interfaceName + "Local";
            }
            Class<?> localClass;
            try {
                localClass = ClassHelper.forNameWithThreadContextClassLoader(local);
            } catch (ClassNotFoundException e) {
                throw new IllegalStateException(e.getMessage(), e);
            }
            if (!interfaceClass.isAssignableFrom(localClass)) {
                throw new IllegalStateException("The local implementation class " + localClass.getName() + " not implement interface " + interfaceName);
            }
        }
        if (stub != null) { // @ step4
            if ("true".equals(stub)) {
                stub = interfaceName + "Stub";
            }
            Class<?> stubClass;
            try {
                stubClass = ClassHelper.forNameWithThreadContextClassLoader(stub);
            } catch (ClassNotFoundException e) {
                throw new IllegalStateException(e.getMessage(), e);
            }
            if (!interfaceClass.isAssignableFrom(stubClass)) {
                throw new IllegalStateException("The stub implementation class " + stubClass.getName() + " not implement interface " + interfaceName);
            }
        }
        checkApplication(); // @ step5
        checkRegistry();
        checkProtocol();
        appendProperties(this);

        checkStubAndMock(interfaceClass); // @ step6
        if (path == null || path.length() == 0) {
            path = interfaceName;
        }
        doExportUrls(); // @ step7

        ProviderModel providerModel = new ProviderModel(getUniqueServiceName(), ref, interfaceClass); // @ step8
        ApplicationModel.initProviderModel(getUniqueServiceName(), providerModel);
    }

    private void checkDefault() { // @ step1
        if (provider == null) {
            provider = new ProviderConfig();
        }
        appendProperties(provider);
    }
複製程式碼

Step1：如果 dubbo:servce 標籤也就是 ServiceBean 的 provider 屬性為空，呼叫 appendProperties 方法，填充預設屬性，其具體載入順序：

1. 從系統屬性載入對應引數值，引數鍵：dubbo.provider.屬性名，System.getProperty。 

2. 從屬性配置檔案載入對應引數值，可通過系統屬性指定屬性配置檔案： dubbo.properties.file，如果該值未配置，則預設取 dubbo.properties 屬性配置檔案。
複製程式碼

Step2：校驗 ref 與 interface 屬性。如果 ref 是 GenericService，則為Dubbo的泛化實現，然後驗證 interface 介面與 ref 引用的型別是否一致。

Step3：dubbo:service local機制，已經廢棄，被 stub屬性所替換。

Step4：處理本地存根 Stub。

Step5：校驗 ServiceBean 的 application、registry、protocol 是否為空，並從系統屬性（優先）、資原始檔中填充其屬性。系統屬性、資原始檔屬性的配置如下：

application dubbo.application.屬性名，例如 dubbo.application.name 

registry dubbo.registry.屬性名，例如 dubbo.registry.address 

protocol dubbo.protocol.屬性名，例如 dubbo.protocol.port 

service dubbo.service.屬性名，例如 dubbo.service.stub
複製程式碼

Step6：校驗 stub、mock 類的合理性，是否是 interface 的實現類。

Step7：執行 doExportUrls() 方法暴露服務，接下來會重點分析該方法。

Step8：將服務提供者資訊註冊到 ApplicationModel 例項中。

2.3 第三步：ServiceConfig#doExportUrls 暴露服務

呼叫鏈：ServiceBean#afterPropertiesSet --> ServiceConfig#export --> ServiceConfig#doExport --> ServiceConfig#doExportUrls

private void doExportUrls() {  
    List<URL> registryURLs = loadRegistries(true); // @ step1
    for (ProtocolConfig protocolConfig : protocols) {
        doExportUrlsFor1Protocol(protocolConfig, registryURLs); // @ step2
    }
}
複製程式碼

Step1：首先遍歷 ServiceBean 的 List registries（所有註冊中心的配置資訊），然後將地址封裝成URL物件，關於註冊中心的所有配置屬性，最終轉換成url的屬性(?屬性名=屬性值)，loadRegistries(true)，引數的意思：true，代表服務提供者，false：代表服務消費者，如果是服務提供者，則檢測註冊中心的配置，如果配置了 register=“false”，則忽略該地址，如果是服務消費者，並配置了 subscribe=“false” 則表示不從該註冊中心訂閱服務，故也不返回。

Step2：然後遍歷配置的所有協議，根據每個協議，向註冊中心暴露服務，接下來重點分析 doExportUrlsFor1Protocol 方法的實現細節。

所以，從上面程式碼，可以看出 Dubbo同一個服務支援多種服務協議、支援向多種註冊中心註冊，很方便同一功能由各種不同實現方式的客戶端呼叫。

掃碼入群討論