Dubbo與Spring的整合原理與流程分析

看Dubbo整合Spring的使用，幾個注解就結束了，但是內部運作原理一概不知，框架內部報錯，丟出例外都不知道是怎么回事，最侄訓是決定花點時間看看dubbo的一些流程原始碼，

主要內容

看看Dubbo與Spring是如何做到無縫結合，以及注解類是怎么被加載的，

Dubbo中propertie?件決議以及處理流程原理
Dubbo中@Service注解決議以及處理流程原理
Dubbo中@Reference注解決議以及處理流程原理

啟動類

public class Application {
    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProviderConfiguration.class);
        context.start();
        System.in.read();
    }

    @Configuration
    @EnableDubbo(scanBasePackages = "org.apache.dubbo.demo.provider")
    @PropertySource("classpath:/spring/dubbo-provider.properties")
    static class ProviderConfiguration {
       
    }
}

兩個關鍵的注解：

@EnableDubbo注解：指定我們dubbo服務類的包路徑，這些服務類是使用Dubbo服務的@Service注解修飾的服務類；
@PropertySource注解：用來指定我們Dubbo組態檔的路徑，然后通過@Value注解使用組態檔的內容，類似SpringBoot的application.properties檔案一樣被加載；

1. @EnableDubbo注解

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@EnableDubboConfig
@DubboComponentScan
public @interface EnableDubbo {
	//省略一些方法
}

該注解上面有兩個關鍵的注解：

EnableDubboConfig
讀取properties組態檔，并將配置轉換成一個個的配置Bean；
DubboComponentScan
掃描服務提供者和參考者類（即使用@Service修飾的類）

2. @EnableDubboConfig與@DubboComponentScan

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Import(DubboConfigConfigurationRegistrar.class)
public @interface EnableDubboConfig {

    /**
     * It indicates whether binding to multiple Spring Beans.
     *
     * @return the default value is <code>false</code>
     * @revised 2.5.9
     */
    boolean multiple() default true;

}

通過@Import注解，引入DubboConfigConfigurationRegistrar類，將這個類轉換一個Bean注入容器，另外，還會使用這個類將所有的配置轉換成Bean注入容器；

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(DubboComponentScanRegistrar.class)
public @interface DubboComponentScan {
    String[] value() default {};
    String[] basePackages() default {};
    Class<?>[] basePackageClasses() default {};

}

通過@Import注解，引入DubboComponentScanRegistrar類，將這個類轉換一個Bean注入容器，另外，還會使用這個類掃描所有的服務提供類，轉換成ServiceBean注入容器；

3. DubboConfigConfigurationRegistrar

掃描配置類

public class DubboConfigConfigurationRegistrar implements ImportBeanDefinitionRegistrar {

    //

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
       //...省略部分代碼

        //獲取EnableDubboConfig的屬性值，有一個multiple
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                importingClassMetadata.getAnnotationAttributes(EnableDubboConfig.class.getName()));

        //獲取multiple屬性的值
        boolean multiple = attributes.getBoolean("multiple");

        // Single Config Bindings
        registerBeans(registry, DubboConfigConfiguration.Single.class);

        if (multiple) { // Since 2.6.6 https://github.com/apache/dubbo/issues/3193
            registerBeans(registry, DubboConfigConfiguration.Multiple.class);
        }
    }
}

獲取EnableDubboConfig的所有屬性值；
獲取EnableDubboConfig的Multiple值；
注冊單例系結Bean；
注冊多例系結Bean；

當Spring啟動后，肯定會通過AnnotationBeanDefinitionReader來執行registerBeanDefinitions方法的，（看了挺多博客，都是這么說， Spring原始碼沒了解那么深）；

3.1 DubboConfigConfiguration.Single類

    @EnableDubboConfigBindings({
            @EnableDubboConfigBinding(prefix = "dubbo.application", type = ApplicationConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.module", type = ModuleConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.registry", type = RegistryConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.protocol", type = ProtocolConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.monitor", type = MonitorConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.provider", type = ProviderConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.consumer", type = ConsumerConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.config-center", type = ConfigCenterBean.class),
            @EnableDubboConfigBinding(prefix = "dubbo.metadata-report", type = MetadataReportConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.metrics", type = MetricsConfig.class)
    })
    public static class Single {

    }

Single類通過 @EnableDubboConfigBinding注解可以看出，根據Dubbo的配置前綴進行Bean型別的系結，例如dubbo.application配置，對應的型別是一個ApplicationConfig類的Bean；

3.2 DubboConfigConfiguration.Multiple

    /**
     * Multiple Dubbo {@link AbstractConfig Config} Bean Binding
     */
    @EnableDubboConfigBindings({
            @EnableDubboConfigBinding(prefix = "dubbo.applications", type = ApplicationConfig.class, multiple = true),
            @EnableDubboConfigBinding(prefix = "dubbo.modules", type = ModuleConfig.class, multiple = true),
            @EnableDubboConfigBinding(prefix = "dubbo.registries", type = RegistryConfig.class, multiple = true),
            @EnableDubboConfigBinding(prefix = "dubbo.protocols", type = ProtocolConfig.class, multiple = true),
            @EnableDubboConfigBinding(prefix = "dubbo.monitors", type = MonitorConfig.class, multiple = true),
            @EnableDubboConfigBinding(prefix = "dubbo.providers", type = ProviderConfig.class, multiple = true),
            @EnableDubboConfigBinding(prefix = "dubbo.consumers", type = ConsumerConfig.class, multiple = true),
            @EnableDubboConfigBinding(prefix = "dubbo.config-centers", type = ConfigCenterBean.class, multiple = true),
            @EnableDubboConfigBinding(prefix = "dubbo.metadata-reports", type = MetadataReportConfig.class, multiple = true),
            @EnableDubboConfigBinding(prefix = "dubbo.metricses", type = MetricsConfig.class, multiple = true)
    })
    public static class Multiple {

    }

Multiple類通過 @EnableDubboConfigBinding注解可以看出，根據Dubbo的配置前綴進行Bean型別的系結，例如dubbo.protocols配置多個協議，而且每種協議都會轉換成一個型別為ProtocolConfig類的Bean，
下面的例子，我就理解了：

#dubbo.protocol.name=dubbo
#dubbo.protocol.port=20881
#dubbo.protocol.host=0.0.0.0

dubbo.protocols.p1.name=dubbo
dubbo.protocols.p1.port=20880
dubbo.protocols.p1.host=0.0.0.0

dubbo.protocols.p2.name=dubbo
dubbo.protocols.p2.port=20881
dubbo.protocols.p2.host=0.0.0.0

dubbo.protocol.：會生成單個Bean， Bean的型別是ProtocolConfig
dubbo.protocols：會生成多個Bean， Bean的型別是ProtocolConfig， Bean的名稱與p1, p2有關

3.3 @EnableDubboConfigBindings注解

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(DubboConfigBindingsRegistrar.class)
public @interface EnableDubboConfigBindings {

    /**
     * The value of {@link EnableDubboConfigBindings}
     *
     * @return non-null
     */
    EnableDubboConfigBinding[] value();

}

value值是一個EnableDubboConfigBinding陣列
通過@Import注解，匯入DubboConfigBindingsRegistrar.class類，該類會獲取@EnableDubboConfigBindings注解中的value，也就是多個@EnableDubboConfigBinding注解，然后利用DubboConfigBindingRegistrar去處理這些@EnableDubboConfigBinding注解，

DubboConfigBindingsRegistrar

Spring啟動時， AnnotationBeanDefinitionReader來執行registerBeanDefinitions方法；

public class DubboConfigBindingsRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    private ConfigurableEnvironment environment;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        System.out.println("執行DubboConfigBindingsRegistrar");
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                importingClassMetadata.getAnnotationAttributes(EnableDubboConfigBindings.class.getName()));

        // 拿到多個@EnableDubboConfigBinding注解
        AnnotationAttributes[] annotationAttributes = attributes.getAnnotationArray("value");

        DubboConfigBindingRegistrar registrar = new DubboConfigBindingRegistrar();
        registrar.setEnvironment(environment);

        for (AnnotationAttributes element : annotationAttributes) {

            // 逐個決議@EnableDubboConfigBinding注解，比如@EnableDubboConfigBinding(prefix = "dubbo.application", type = ApplicationConfig.class)
            registrar.registerBeanDefinitions(element, registry);

        }
    }
	//省略無關代碼；
}

獲取EnableDubboConfigBindings所有的屬性值
獲取EnableDubboConfigBindings的value屬性值；
創建配置系結注冊Bean工具類物件，用來注冊一個個的配置Bean
遍歷回圈，逐個決議@EnableDubboConfigBinding注解類；第一個引數事注解類資訊，第二個引數是Spring容器，方便將Bean注入容器；

DubboConfigBindingRegistrar

決議@EnableDubboConfigBinding注解類

public class DubboConfigBindingRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    private final Log log = LogFactory.getLog(getClass());

    private ConfigurableEnvironment environment;

    protected void registerBeanDefinitions(AnnotationAttributes attributes, BeanDefinitionRegistry registry) {

        // prefix = "dubbo.application"
        String prefix = environment.resolvePlaceholders(attributes.getString("prefix"));

        // type = ApplicationConfig.class
        Class<? extends AbstractConfig> configClass = attributes.getClass("type");

        boolean multiple = attributes.getBoolean("multiple");

        registerDubboConfigBeans(prefix, configClass, multiple, registry);

    }
}

作用：

獲取系結注解prefix屬性，即配置的屬性dubbo.application
獲取系結注解type屬性，是每一中配置對應的型別Class資訊；
獲取系結注解multiple屬性
根據prefix, type， multipart生成Bean注入容器registry;

    private void registerDubboConfigBeans(String prefix,
                                          Class<? extends AbstractConfig> configClass,
                                          boolean multiple,
                                          BeanDefinitionRegistry registry) {

        // 從properties檔案中根據前綴拿對應的配置項，比如根據dubbo.application前綴，
        // 就可以拿到：
        // dubbo.application.name=dubbo-demo-provider-application
        // dubbo.application.logger=log4j
        Map<String, Object> properties = getSubProperties(environment.getPropertySources(), prefix);

        // 如果沒有相關的配置項，則不需要注冊BeanDefinition
        if (CollectionUtils.isEmpty(properties)) {
            if (log.isDebugEnabled()) {
                log.debug("There is no property for binding to dubbo config class [" + configClass.getName()
                        + "] within prefix [" + prefix + "]");
            }
            return;
        }

        // 根據配置項生成beanNames，為什么會有多個？
        // 普通情況一個dubbo.application前綴對應一個ApplicationConfig型別的Bean
        // 特殊情況下，比如dubbo.protocols對應了：
//        dubbo.protocols.p1.name=dubbo
//        dubbo.protocols.p1.port=20880
//        dubbo.protocols.p1.host=0.0.0.0

//        dubbo.protocols.p2.name=http
//        dubbo.protocols.p2.port=8082
//        dubbo.protocols.p2.host=0.0.0.0
        // 那么就需要對應兩個ProtocolConfig型別的Bean，那么就需要兩個beanName:p1和p2

        // 這里就是multiple為true或false的區別，名字的區別，根據multiple用來判斷是否從配置項中獲取beanName
        // 如果multiple為false，則看有沒有配置id屬性，如果沒有配置則自動生成一個beanName.
        Set<String> beanNames = multiple ? resolveMultipleBeanNames(properties) :
                Collections.singleton(resolveSingleBeanName(properties, configClass, registry));

        for (String beanName : beanNames) {

            // 為每個beanName,注冊一個空的BeanDefinition
            registerDubboConfigBean(beanName, configClass, registry);

            // 為每個bean注冊一個DubboConfigBindingBeanPostProcessor的Bean后置處理器
            registerDubboConfigBindingBeanPostProcessor(prefix, beanName, multiple, registry);

        }

        // 注冊一個NamePropertyDefaultValueDubboConfigBeanCustomizer的bean
        registerDubboConfigBeanCustomizers(registry);

    }

作業：

getSubProperties：獲取propertis資訊中，包含了系結注解前綴prefix的配置
resolveMultipleBeanNames | resolveSingleBeanName：生成注入容器的Bean的名稱；
遍歷生成的Bean名稱；
3.1 registerDubboConfigBean為每個Bean名稱注入一個空的BeanDefinition物件
3.2 registerDubboConfigBindingBeanPostProcessor為每個Bean注冊一個DubboConfigBindingBeanPostProcessor后置處理器；
registerDubboConfigBeanCustomizers：注冊一個NamePropertyDefaultValueDubboConfigBeanCustomizer的bean

getSubProperties(Iterable<PropertySource<?>> propertySources, String prefix)

	//主要:1. propertySources轉化轉換為AbstractEnvironment 物件
    public static Map<String, Object> getSubProperties(Iterable<PropertySource<?>> propertySources, String prefix) {
        // Non-Extension AbstractEnvironment
        AbstractEnvironment environment = new AbstractEnvironment() {
        };
        MutablePropertySources mutablePropertySources = environment.getPropertySources();
        for (PropertySource<?> source : propertySources) {
            mutablePropertySources.addLast(source);
        }
        return getSubProperties(environment, prefix);
    }
    //1. 獲取所有環境配置
    //2. normalizePrefix生成系結 前綴字串 prefix+"." ， 多了一個點；
    //3. 遍歷回圈所有配置
    //3.1 找到所有前綴字串開頭的 配置項
    //3.2 name.substring(normalizedPrefix.length())截取字串， 前綴字串后面的內容全部截取下來；
    //3.3 獲取前綴字串配置項對應的值；
    //3.4 subProperties.put(subName, value)將結果放入容器中subProperties 
    public static Map<String, Object> getSubProperties(ConfigurableEnvironment environment, String prefix) {

        Map<String, Object> subProperties = new LinkedHashMap<>();

        MutablePropertySources propertySources = environment.getPropertySources();

        String normalizedPrefix = normalizePrefix(prefix);

        for (PropertySource<?> source : propertySources) {
            if (source instanceof EnumerablePropertySource) {
                for (String name : ((EnumerablePropertySource<?>) source).getPropertyNames()) {
                    if (!subProperties.containsKey(name) && name.startsWith(normalizedPrefix)) {
                        String subName = name.substring(normalizedPrefix.length());
                        if (!subProperties.containsKey(subName)) { // take first one
                            Object value = source.getProperty(name);
                            if (value instanceof String) {
                                // Resolve placeholder
                                value = environment.resolvePlaceholders((String) value);
                            }
                            subProperties.put(subName, value);
                        }
                    }
                }
            }
        }

        return Collections.unmodifiableMap(subProperties);

    }

resolveMultipleBeanNames(properties)
獲取Multiple下的bean名稱；

	//1. 創建一個Set集合， 作用是用來去重
	//2. 遍歷前綴對應的所有配置項的Key；
	//3. 獲取"."號出現的問題的位置；
	//4. 將Bean的名稱放入Set集合，相同就去重；
    private Set<String> resolveMultipleBeanNames(Map<String, Object> properties) {

        Set<String> beanNames = new LinkedHashSet<String>();

        // 比如dubbo.protocols.p1.name=dubbo的propertyName為p1.name

        for (String propertyName : properties.keySet()) {

            // propertyName為p1.name
            int index = propertyName.indexOf(".");

            if (index > 0) {

                // 截取beanName名字為p1
                String beanName = propertyName.substring(0, index);

                beanNames.add(beanName);
            }

        }

        return beanNames;
    }

resolveSingleBeanName(properties, configClass, registry)
獲取single配置的Bean名稱；

	//1. 獲取id的值；
	//2. id值為空，自動生成一個Bean的名稱；
	//3. Id值不為空，就用來當作bean的名稱，回傳；
    private String resolveSingleBeanName(Map<String, Object> properties, Class<? extends AbstractConfig> configClass,
                                         BeanDefinitionRegistry registry) {

        // 配置了dubbo.application.id=appl，那么appl就是beanName
        String beanName = (String) properties.get("id");
        // 如果beanName為null，則會進入if分支，由spring自動生成一個beanName,比如org.apache.dubbo.config.ApplicationConfig#0
        if (!StringUtils.hasText(beanName)) {
            BeanDefinitionBuilder builder = rootBeanDefinition(configClass);
            beanName = BeanDefinitionReaderUtils.generateBeanName(builder.getRawBeanDefinition(), registry);
        }

        return beanName;

    }

registerDubboConfigBean(beanName, configClass, registry)
創建一個空的BeanDefinition類，并放入IOC容器

	//1. 創建BeanDefinitionBuilder構造類實體；
	//2. 獲取一個BeanDefinition類的實體；
	//3. 根據已經生成bean名稱，空的BeanDefinition實體， 注入IOC容器中；
    private void registerDubboConfigBean(String beanName, Class<? extends AbstractConfig> configClass,
                                         BeanDefinitionRegistry registry) {

        BeanDefinitionBuilder builder = rootBeanDefinition(configClass);

        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();

        registry.registerBeanDefinition(beanName, beanDefinition);   // ApplicatinoConfig物件

        if (log.isInfoEnabled()) {
            log.info("The dubbo config bean definition [name : " + beanName + ", class : " + configClass.getName() +
                    "] has been registered.");
        }

    }

registerDubboConfigBindingBeanPostProcessor(prefix, beanName, multiple, registry)
創建一個DubboConfigBindingBeanPostProcessor后置處理器，并注入容器；

	//1. 創建DubboConfigBindingBeanPostProcessor的一個BeanDefinitionBuilder構建物件；
	//2. 獲取真實前綴， 如果Multiple為true, 則是dubbo.protocols.p1, 為false, 則是dubbo.protocol;
	//3. 添加兩個構造方法引數；
	//4. 創建一個空的DubboConfigBindingBeanPostProcessor的BeanDefinition物件；
	//5. 生成DubboConfigBindingBeanPostProcessor的bean名稱為key, 空BeanDefinition實體注入容器；
    private void registerDubboConfigBindingBeanPostProcessor(String prefix, String beanName, boolean multiple,
                                                             BeanDefinitionRegistry registry) {

        // 注冊一個DubboConfigBindingBeanPostProcessor的Bean
        // 每個XxConfig的Bean對應一個DubboConfigBindingBeanPostProcessor的Bean
        // 比如，一個ApplicationConfig對應一個DubboConfigBindingBeanPostProcessor，
        // 一個ProtocolConfig也會對應一個DubboConfigBindingBeanPostProcessor
        // 在構造DubboConfigBindingBeanPostProcessor的時候會指定構造方法的值，這樣就可以區別開來了

        Class<?> processorClass = DubboConfigBindingBeanPostProcessor.class;

        BeanDefinitionBuilder builder = rootBeanDefinition(processorClass);

        // 真實的前綴，比如dubbo.registries.r2
        String actualPrefix = multiple ? normalizePrefix(prefix) + beanName : prefix;

        // 添加兩個構造方法引數值，所以會呼叫DubboConfigBindingBeanPostProcessor的兩個引數的構造方法
        builder.addConstructorArgValue(actualPrefix).addConstructorArgValue(beanName);

        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();

        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

        registerWithGeneratedName(beanDefinition, registry);

        if (log.isInfoEnabled()) {
            log.info("The BeanPostProcessor bean definition [" + processorClass.getName()
                    + "] for dubbo config bean [name : " + beanName + "] has been registered.");
        }

    }
    
    public static String registerWithGeneratedName(AbstractBeanDefinition definition, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
        String generatedName = generateBeanName(definition, registry, false);
        registry.registerBeanDefinition(generatedName, definition);
        return generatedName;
    }
    //
    public static String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean) throws BeanDefinitionStoreException {
        //獲取BeanDefinition 的 beanName；
        String generatedBeanName = definition.getBeanClassName();
		//...省略部分代碼
        if (!StringUtils.hasText(generatedBeanName)) {
   		//例外處理
        } else {
            String id = generatedBeanName;
            if (isInnerBean) {
                id = generatedBeanName + "#" + ObjectUtils.getIdentityHexString(definition);
            } else {
            	//判斷存在多少id為generatedBeanName， 如果有count自增1， 最后容器不包含
            	//generatedBeanName + "#" + counter的bean名稱時，就是用這個組合字串作為Bean名稱；
                for(int counter = -1; counter == -1 || registry.containsBeanDefinition(id); id = generatedBeanName + "#" + counter) {
                    ++counter;
                }
            }

            return id;
        }
    }

3. registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry)

注冊各個Dubbo配置Bean到容器中；

 
public class DubboConfigConfigurationRegistrar implements ImportBeanDefinitionRegistrar {

    //

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        System.out.println("執行DubboConfigConfigurationRegistrar");

        //獲取EnableDubboConfig的屬性值，有一個multiple
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                importingClassMetadata.getAnnotationAttributes(EnableDubboConfig.class.getName()));

        //獲取multiple屬性的值
        boolean multiple = attributes.getBoolean("multiple");

        // Single Config Bindings
        registerBeans(registry, DubboConfigConfiguration.Single.class);

        if (multiple) { // Since 2.6.6 https://github.com/apache/dubbo/issues/3193
            registerBeans(registry, DubboConfigConfiguration.Multiple.class);
        }
    }

}

回到開頭的第3步驟；

4. registerBeans(registry, DubboConfigConfiguration.Multiple.class)

Spring中的AnnotatedBeanDefinitionReader來決議annotatedClasses會決議該類上的注解，然后進行處理

	// annotatedClasses 引數值為 ：  DubboConfigConfiguration.Single.class，
	// DubboConfigConfiguration.Multiple.class；
	//作用：
	//1. annotatedClasses轉換為迭代器；
	//2. 遍歷迭代器，判斷容器中是否已經存在這個Bean類
	//如果存在就在這個Bean從迭代器中去掉；
	//isPresentBean(registry, annotatedClass)
	//3. 創建一個AnnotatedBeanDefinitionReader物件實體；
	//4. Spring中的AnnotatedBeanDefinitionReader來決議annotatedClasses，
	//會決議該類上的注解，然后進行處理（Spring的內容）
    public static void registerBeans(BeanDefinitionRegistry registry, Class<?>... annotatedClasses) {
        if (ObjectUtils.isEmpty(annotatedClasses)) {
            return;
        }

        // Remove all annotated-classes that have been registered
        Iterator<Class<?>> iterator = new ArrayList<>(asList(annotatedClasses)).iterator();

        while (iterator.hasNext()) {
            Class<?> annotatedClass = iterator.next();
            if (isPresentBean(registry, annotatedClass)) {
                iterator.remove();
            }
        }

        AnnotatedBeanDefinitionReader reader = new AnnotatedBeanDefinitionReader(registry);

        if (logger.isDebugEnabled()) {
            logger.debug(registry.getClass().getSimpleName() + " will register annotated classes : " + asList(annotatedClasses) + " .");
        }
        // 利用Spring中的AnnotatedBeanDefinitionReader來決議annotatedClasses
        // 會決議該類上的注解，然后進行處理
        reader.register(annotatedClasses);

    }

總結

@EnableDubboConfig注解的作用就是通過DubboConfigConfigurationRegistrar 決議組態檔里面所有的dubbo配置項，

通過AnnotatedBeanDefinitionReader來決議Multiple/Single型別上的EnableDubboConfigBindings的值（是一個@EnableDubboConfigBinding陣列）
讀取組態檔中Dubbo的所有配置項，根據@EnableDubboConfigBinding系結注解的prefix前綴，匹配配置項的key, 然后將單個配置項，或者一組配置項轉換成一個個type型別Class的BeanDefinition的Bean，注入IOC容器；
然后每個XxConfig的Bean會生成對應一個DubboConfigBindingBeanPostProcessor的Bean注入IOC容器

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/437034.html

標籤：其他

上一篇：Hadoop之環境配置

下一篇：精心整理：Spark關鍵字知識點

Dubbo學習記錄(五)-Dubbo與Spring的組態檔決議流程原理分析