（转)Spring 工具类 ConfigurationClassParser 分析得到配置类 -- springboot一样处理过程

简介

Spring的工具类ConfigurationClassParser用于分析@Configuration注解的配置类，产生一组ConfigurationClass对象。它的分析过程会接受一组种子配置类(调用者已知的配置类，通常很可能只有一个)，从这些种子配置类开始分析所有关联的配置类，分析过程主要是递归分析配置类的注解@Import，配置类内部嵌套类，找出其中所有的配置类，然后返回这组配置类。

该工具主要由ConfigurationClassPostProcessor使用，而ConfigurationClassPostProcessor是一个BeanDefinitionRegistryPostProcessor/BeanFactoryPostProcessor,它会在容器启动过程中，应用上下文上执行各个BeanFactoryPostProcessor时被执行。

ConfigurationClassParser 所在包 : org.springframework.context.annotation。

这个工具类自身的逻辑并不注册bean定义，它的主要任务是发现@Configuration注解的所有配置类并将这些配置类交给调用者(调用者会通过其他方式注册其中的bean定义)，而对于非@Configuration注解的其他bean定义，比如@Component注解的bean定义，该工具类使用另外一个工具ComponentScanAnnotationParser扫描和注册它们。

该工具类对@ComponentScans,@ComponentScan注解的处理使用了ComponentScanAnnotationParser，ComponentScanAnnotationParser在扫描到bean定义时会直接将其注册到容器，而不是采用和ConfigurationClassParser类似的方式交由调用者处理。

一般情况下一个@Configuration注解的类只会产生一个ConfigurationClass对象，但是因为@Configuration注解的类可能会使用注解@Import引入其他配置类，也可能内部嵌套定义配置类，所以总的来看，ConfigurationClassParser分析一个@Configuration注解的类，可能产生任意多个ConfigurationClass对象。

主要功能分析

以下源代码基于 Spring 4.3.12.RELEASE

parse() : 外部调用入口

parse()方法的主体工作流程 :

接收外部提供的参数 configCandidates , 是一组需要被分析的候选配置类的集合，每个元素使用类型BeanDefinitionHolder包装 ;
parse() 方法针对每个候选配置类元素BeanDefinitionHolder，执行以下逻辑 :
　　1.将其封装成一个ConfigurationClass
　　2.调用processConfigurationClass(ConfigurationClass configClass)
　　　> 分析过的每个配置类都被保存到属性 this.configurationClasses 中。

/**
 * @参数 configCandidates : 外部指定需要被分析的一组候选配置类
 **/
public void parse(Set<BeanDefinitionHolder> configCandidates) {
    this.deferredImportSelectors = new LinkedList<DeferredImportSelectorHolder>();

    for (BeanDefinitionHolder holder : configCandidates) {
        BeanDefinition bd = holder.getBeanDefinition();
        try {
            // 这里根据Bean定义的不同类型走不同的分支，但是最终都会调用到方法
            //  processConfigurationClass(ConfigurationClass configClass)
            if (bd instanceof AnnotatedBeanDefinition) {
                // bd 是一个 AnnotatedBeanDefinition
                parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
            }
            else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
                // bd 是一个 AbstractBeanDefinition,并且指定 beanClass 属性
                parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
            }
            else {
                // 其他情况
                parse(bd.getBeanClassName(), holder.getBeanName());
            }
        }
        catch (BeanDefinitionStoreException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanDefinitionStoreException(
                    "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
        }
    }

    // 执行找到的 DeferredImportSelector 
    //  DeferredImportSelector 是 ImportSelector 的一个变种。
    // ImportSelector 被设计成其实和@Import注解的类同样的导入效果，但是实现 ImportSelector
    // 的类可以条件性地决定导入哪些配置。
    // DeferredImportSelector 的设计目的是在所有其他的配置类被处理后才处理。这也正是
    // 该语句被放到本函数最后一行的原因。
    processDeferredImportSelectors();
}

processConfigurationClass() 分析一个配置类

processConfigurationClass()对配置的处理并不是真正自己处理，而是开始一个基于doProcessConfigurationClass()的处理循环，该循环从参数配置类开始遍历其所有需要处理的父类(super)，每个类都使用doProcessConfigurationClass()来处理。每处理一个类，processConfigurationClass()将其记录到this.configurationClasses。

/**
 *  用于分析一个 ConfigurationClass，分析之后将它记录到已处理配置类记录
 **/
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
        return;
    }

    ConfigurationClass existingClass = this.configurationClasses.get(configClass);
    if (existingClass != null) {
        if (configClass.isImported()) {
            if (existingClass.isImported()) {
                //如果要处理的配置类configClass在已经分析处理的配置类记录中已存在，
                //合并二者的importedBy属性
                existingClass.mergeImportedBy(configClass);
            }
            // Otherwise ignore new imported config class; existing non-imported class overrides it.
            return;
        }
        else {
            // Explicit bean definition found, probably replacing an import.
            // Let's remove the old one and go with the new one.
            this.configurationClasses.remove(configClass);
            for (Iterator<ConfigurationClass> it = this.knownSuperclasses.values().iterator(); it.hasNext();) {
                if (configClass.equals(it.next())) {
                    it.remove();
                }
            }
        }
    }

    // Recursively process the configuration class and its superclass hierarchy.
    // 从当前配置类configClass开始向上沿着类继承结构逐层执行doProcessConfigurationClass,
    // 直到遇到的父类是由Java提供的类结束循环
    SourceClass sourceClass = asSourceClass(configClass);
    do {            
        // 循环处理配置类configClass直到sourceClass变为null
        // doProcessConfigurationClass的返回值是其参数configClass的父类，
        // 如果该父类是由Java提供的类或者已经处理过，返回null
        sourceClass = doProcessConfigurationClass(configClass, sourceClass);
    }
    while (sourceClass != null);

    // 需要被处理的配置类configClass已经被分析处理，将它记录到已处理配置类记录
    this.configurationClasses.put(configClass, configClass);
}

processDeferredImportSelectors() 处理需要延迟处理的ImportSelector

    /**
      * 对属性deferredImportSelectors中记录的DeferredImportSelector进行处理
      **/
    private void processDeferredImportSelectors() {
        List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
        this.deferredImportSelectors = null;
        Collections.sort(deferredImports, DEFERRED_IMPORT_COMPARATOR);
        
        // 循环处理每个DeferredImportSelector
        for (DeferredImportSelectorHolder deferredImport : deferredImports) {
            ConfigurationClass configClass = deferredImport.getConfigurationClass();
            try {
                //调用DeferredImportSelector的方法selectImports,获取需要被导入的类的名称
                String[] imports = deferredImport.getImportSelector().selectImports(configClass.getMetadata());
                // 处理任何一个 @Import 注解
                processImports(configClass, asSourceClass(configClass), asSourceClasses(imports), false);
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                        "Failed to process import candidates for configuration class [" +
                        configClass.getMetadata().getClassName() + "]", ex);
            }
        }
    }

doProcessConfigurationClass()对一个配置类执行真正的处理

doProcessConfigurationClass()会对一个配置类执行真正的处理：

1. 一个配置类的成员类(配置类内嵌套定义的类)也可能适配类，先遍历这些成员配置类，调用processConfigurationClass处理它们;
2. 处理配置类上的注解@PropertySources,@PropertySource
3. 处理配置类上的注解@ComponentScans,@ComponentScan
4. 处理配置类上的注解@Import
5. 处理配置类上的注解@ImportResource
6. 处理配置类中每个带有@Bean注解的方法
7. 处理配置类所实现接口的缺省方法
8. 检查父类是否需要处理，如果父类需要处理返回父类，否则返回null

       返回父类表示当前配置类处理尚未完成，调用者processConfigurationClass会继续处理其父类；返回null才表示该配置类的处理完成。从这里可以推断一旦一个配置类被processConfigurationClass处理完成，表示其自身，内部嵌套类，各个实现接口以及各级父类都被处理完成。

/**
 * Apply processing and build a complete ConfigurationClass by reading the
 * annotations, members and methods from the source class. This method can be called
 * multiple times as relevant sources are discovered.
 * @param configClass the configuration class being build
 * @param sourceClass a source class
 * @return the superclass, or null if none found or previously processed
 */
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
        throws IOException {

    // Recursively process any member (nested) classes first，首先递归处理嵌套类
    processMemberClasses(configClass, sourceClass);

    // Process any @PropertySource annotations，处理每个@PropertySource注解
    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), PropertySources.class,
            org.springframework.context.annotation.PropertySource.class)) {
        if (this.environment instanceof ConfigurableEnvironment) {
            processPropertySource(propertySource);
        }
        else {
            logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                    "]. Reason: Environment must implement ConfigurableEnvironment");
        }
    }

    // Process any @ComponentScan annotations，处理每个@ComponentScan注解
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    if (!componentScans.isEmpty() &&
            !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
        for (AnnotationAttributes componentScan : componentScans) {
            // 该配置类上注解了@ComponentScan,现在执行扫描，获取其中的Bean定义
            // this.componentScanParser 是一个 ComponentScanAnnotationParser，在当前对象的构造函数中
            // 被创建
            Set<BeanDefinitionHolder> scannedBeanDefinitions =
                    this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
            // 对Component scan得到的Bean定义做检查，看看里面是否有需要处理的配置类，
            // 有的话对其做分析处理
            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(
                        holder.getBeanDefinition(), this.metadataReaderFactory)) {
                    // 如果该Bean定义是一个配置类，它进行分析
                    parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
                }
            }
        }
    }

    // Process any @Import annotations，处理每个@Import注解        
    // 注意这里调用到了getImports()方法，它会搜集sourceClass上所有的@Import注解的value值，
    // 具体搜集的方式是访问sourceClass直接注解的@Import以及递归访问它的注解中隐含的所有的@Import    
    processImports(configClass, sourceClass, getImports(sourceClass), true);

    // Process any @ImportResource annotations，处理每个@ImportResource注解
    if (sourceClass.getMetadata().isAnnotated(ImportResource.class.getName())) {
        AnnotationAttributes importResource =
                AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
        String[] resources = importResource.getStringArray("locations");
        Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
        for (String resource : resources) {
            String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
            configClass.addImportedResource(resolvedResource, readerClass);
        }
    }

    // Process individual @Bean methods,处理配置类中每个带有@Bean注解的方法
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }

    // Process default methods on interfaces，处理接口上的缺省方法
    processInterfaces(configClass, sourceClass);

    // Process superclass, if any
    // 如果父类superclass存在，并且不是`java`包中的类，并且尚未处理处理，
    // 则才返回它以便外层循环继续
    if (sourceClass.getMetadata().hasSuperClass()) {
        String superclass = sourceClass.getMetadata().getSuperClassName();
        if (!superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
            this.knownSuperclasses.put(superclass, configClass);
            // Superclass found, return its annotation metadata and recurse
            return sourceClass.getSuperClass();
        }
    }

    // No superclass -> processing is complete，没找到需要处理的父类，处理结果
    return null;// 用返回null告诉外层循环结束
}

processImports()处理配置类上搜集到的@Import注解

/**
  * 处理配置类上搜集到的@Import注解
  * 参数 configuClass 配置类
  * 参数 currentSourceClass 当前源码类
  * 参数 importCandidates, 所有的@Import注解的value
  * 参数 checkForCircularImports, 是否检查循环导入
  **/
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
        Collection<SourceClass> importCandidates, boolean checkForCircularImports) throws IOException {

    if (importCandidates.isEmpty()) {
    // 如果配置类上没有任何候选@Import，说明没有需要处理的导入，则什么都不用做，直接返回
        return;
    }
                
    if (checkForCircularImports && isChainedImportOnStack(configClass)) {
    // 如果要求做循环导入检查，并且检查到了循环依赖，报告这个问题
        this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
    }
    else {
        // 开始处理配置类configClass上所有的@Import importCandidates
        this.importStack.push(configClass);
        try {
            // 循环处理每一个@Import,每个@Import可能导入三种类型的类 :
            // 1. ImportSelector
            // 2. ImportBeanDefinitionRegistrar
            // 3. 其他类型，都当作配置类处理，也就是相当于使用了注解@Configuration的配置类
            // 下面的for循环中对这三种情况执行了不同的处理逻辑
            for (SourceClass candidate : importCandidates) {
                if (candidate.isAssignable(ImportSelector.class)) {
                    // Candidate class is an ImportSelector -> delegate to it to determine imports
                    Class<?> candidateClass = candidate.loadClass();
                    ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
                    ParserStrategyUtils.invokeAwareMethods(
                            selector, this.environment, this.resourceLoader, this.registry);
                    if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
                        this.deferredImportSelectors.add(
                                new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
                    }
                    else {
                        String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                        Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
                        processImports(configClass, currentSourceClass, importSourceClasses, false);
                    }
                }
                else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                    // Candidate class is an ImportBeanDefinitionRegistrar ->
                    // delegate to it to register additional bean definitions
                    Class<?> candidateClass = candidate.loadClass();
                    ImportBeanDefinitionRegistrar registrar =
                            BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
                    ParserStrategyUtils.invokeAwareMethods(
                            registrar, this.environment, this.resourceLoader, this.registry);
                    configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
                }
                else {
                    // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
                    // process it as an @Configuration class
                    this.importStack.registerImport(
                            currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                    processConfigurationClass(candidate.asConfigClass(configClass));
                }
            }
        }
        catch (BeanDefinitionStoreException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanDefinitionStoreException(
                    "Failed to process import candidates for configuration class [" +
                    configClass.getMetadata().getClassName() + "]", ex);
        }
        finally {
            this.importStack.pop();
        }
    }
}

版权声明：本文为CSDN博主「安迪源文」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/andy_zhang2007/article/details/78549773