Spring5源碼分析5-ConfigurationClassPostProcessor (上)

接上回，咱們講到了refresh()方法中的invokeBeanFactoryPostProcessors(beanFactory)方法主要在執行BeanFactoryPostProcessor和其子接口BeanDefinitionRegistryPostProcessor的方法。

在建立AnnotationConfigApplicationContext對象時Spring就添加了一個很是重要的BeanFactoryPostProcessor接口實現類：ConfigurationClassPostProcessor。注意，這裏說的添加只是添加到容器的beanDefinitionMap中，尚未建立真正的實例Bean。

簡單回顧一下ConfigurationClassPostProcessor是在何時被添加到容器中的：在AnnotationConfigApplicationContext的無參構造器中建立AnnotatedBeanDefinitionReader對象時會向傳入的BeanDefinitionRegistry中註冊解析註解配置類相關的processors的BeanDefinition，ConfigurationClassPostProcessor就是在此處被添加到容器中的。

---

ConfigurationClassPostProcessor

先看一些ConfigurationClassPostProcessor的繼承體系：

ConfigurationClassPostProcessor實現了BeanDefinitionRegistryPostProcessor接口，也就擁有了在Spring容器啓動時，往容器中註冊BeanDefinition的能力。

咱們知道，ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry方法是在refresh();方法中的invokeBeanFactoryPostProcessors(beanFactory);中被執行的，下面咱們就一塊兒來看一下該方法。

ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    int registryId = System.identityHashCode(registry);
    if (this.registriesPostProcessed.contains(registryId)) {
        throw new IllegalStateException(
                "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
    }
    if (this.factoriesPostProcessed.contains(registryId)) {
        throw new IllegalStateException(
                "postProcessBeanFactory already called on this post-processor against " + registry);
    }
    this.registriesPostProcessed.add(registryId);

    processConfigBeanDefinitions(registry);
}

主要的邏輯在processConfigBeanDefinitions(registry);中，點開源碼：

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    //獲取全部的BeanDefinitionName
    String[] candidateNames = registry.getBeanDefinitionNames();

    for (String beanName : candidateNames) {
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);

        // https://docs.spring.io/spring/docs/5.1.8.RELEASE/spring-framework-reference/core.html#beans-java-basic-concepts
        // Full @Configuration vs 「lite」 @Bean mode
        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
                ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
            }
        }

        // 校驗是否爲配置類
        // 配置類分爲兩種 Full @Configuration vs 「lite」 @Bean mode
        // 校驗以後在 BeanDefinition 中添加標誌屬性
        // 若是知足條件則加入到configCandidates
        else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
            // 若是是配置類,就放到 configCandidates 變量中
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
    }

    // Return immediately if no @Configuration classes were found
    if (configCandidates.isEmpty()) {
        return;
    }

    // Sort by previously determined @Order value, if applicable
    configCandidates.sort((bd1, bd2) -> {
        int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
        int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
        return Integer.compare(i1, i2);
    });

    // Detect any custom bean name generation strategy supplied through the enclosing application context
    SingletonBeanRegistry sbr = null;
    // 傳入的 registry 是 DefaultListableBeanFactory
    if (registry instanceof SingletonBeanRegistry) {
        sbr = (SingletonBeanRegistry) registry;
        if (!this.localBeanNameGeneratorSet) {
            //獲取自定義BeanNameGenerator,通常狀況下爲空
            BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
            if (generator != null) {
                this.componentScanBeanNameGenerator = generator;
                this.importBeanNameGenerator = generator;
            }
        }
    }

    if (this.environment == null) {
        this.environment = new StandardEnvironment();
    }

    // Parse each @Configuration class
    // new ConfigurationClassParser,用來解析 @Configuration 類
    ConfigurationClassParser parser = new ConfigurationClassParser(
            this.metadataReaderFactory, this.problemReporter, this.environment,
            this.resourceLoader, this.componentScanBeanNameGenerator, registry);

    // 將 configCandidates 轉成 set  candidates , 去重
    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
    do {
        // 解析配置類
        parser.parse(candidates);
        parser.validate();

        Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
        configClasses.removeAll(alreadyParsed);

        // Read the model and create bean definitions based on its content
        if (this.reader == null) {
            this.reader = new ConfigurationClassBeanDefinitionReader(
                    registry, this.sourceExtractor, this.resourceLoader, this.environment,
                    this.importBeanNameGenerator, parser.getImportRegistry());
        }
        // Import類,@Bean,@ImportResource 轉化爲 BeanDefinition
        this.reader.loadBeanDefinitions(configClasses);
        alreadyParsed.addAll(configClasses);

        candidates.clear();
        // 再獲取一下容器中BeanDefinition的數據,若是發現數量增長了,說明有新的BeanDefinition被註冊了
        if (registry.getBeanDefinitionCount() > candidateNames.length) {
            String[] newCandidateNames = registry.getBeanDefinitionNames();
            Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
            Set<String> alreadyParsedClasses = new HashSet<>();
            for (ConfigurationClass configurationClass : alreadyParsed) {
                alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
            }
            for (String candidateName : newCandidateNames) {
                if (!oldCandidateNames.contains(candidateName)) {
                    BeanDefinition bd = registry.getBeanDefinition(candidateName);
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                            !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                        candidates.add(new BeanDefinitionHolder(bd, candidateName));
                    }
                }
            }
            candidateNames = newCandidateNames;
        }
    }
    while (!candidates.isEmpty());

    // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
    if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
        sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
    }

    if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
        // Clear cache in externally provided MetadataReaderFactory; this is a no-op
        // for a shared cache since it'll be cleared by the ApplicationContext.
        ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
    }
}

獲取全部的BeanDefinitionNames，而後循環這個數組，判斷其是否爲配置類。

前5個是Spring註冊的內置processor，最後一個是傳入給AnnotationConfigApplicationContext的配置類AppConfig.class。

在Spring中存在兩種ConfigurationClass，一種是FullConfigurationClass另外一種是LiteConfigurationClass。關於這二者的區別，能夠參看筆者文章以前關於Full @Configuration 和 lite @Bean mode的文章。

ConfigurationClassUtils#checkConfigurationClassCandidate方法內部就是在判斷屬於哪一種配置類，並在BeanDefinition中標記判斷結果。其具體的判斷邏輯以下：

public static boolean isFullConfigurationCandidate(AnnotationMetadata metadata) {
    return metadata.isAnnotated(Configuration.class.getName());
}
private static final Set<String> candidateIndicators = new HashSet<>(8);

static {
    candidateIndicators.add(Component.class.getName());
    candidateIndicators.add(ComponentScan.class.getName());
    candidateIndicators.add(Import.class.getName());
    candidateIndicators.add(ImportResource.class.getName());
}

public static boolean isLiteConfigurationCandidate(AnnotationMetadata metadata) {
    // Do not consider an interface or an annotation...
    if (metadata.isInterface()) {
        return false;
    }

    // Any of the typical annotations found?
    for (String indicator : candidateIndicators) {
        if (metadata.isAnnotated(indicator)) {
            return true;
        }
    }

    // Finally, let's look for @Bean methods...
    try {
        return metadata.hasAnnotatedMethods(Bean.class.getName());
    } catch (Throwable ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("Failed to introspect @Bean methods on class [" + metadata.getClassName() + "]: " + ex);
        }
        return false;
    }
}

判斷configCandidates變量中存放的

配置類是否爲空，若是不爲空，則對其進行排序。

建立ConfigurationClassParser對象，用於解析@Configuration類，完成包的掃描、BeanDefinition的註冊。主要經過執行parser.parse(candidates);方法來完成。

執行parser.parse(candidates)方法前 ：

執行parser.parse(candidates)方法後 ：

解析完配置類以後，緊接着又執行了this.reader.loadBeanDefinitions(configClasses);方法。這個方法主要是用來處理Import類、@Bean和@ImportResource註解。關於這兩個方法的具體細節，咱們下次再講。

最後又加了入了對ImportAware接口支持所須要的Bean。

// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
    sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}

關於對ImportAware接口的使用，咱們也下次再講。

---

未完待續......

源碼學習筆記：https://github.com/shenjianen...

我的公衆號：