ConfigurationClassParser类的parse方法源码解析

spring版本为5.0.11

ConfigurationClassPostProcessor对配置类的解析

public void parse(Set<BeanDefinitionHolder> configCandidates) {
        //List<ConfigurationClassParser.DeferredImportSelectorHolder> deferredImportSelectors 进行初始化 
        this.deferredImportSelectors = new LinkedList();
        Iterator var2 = configCandidates.iterator();
        //循环遍历需要处理的配置类
        while(var2.hasNext()) {
            BeanDefinitionHolder holder = (BeanDefinitionHolder)var2.next();
            BeanDefinition bd = holder.getBeanDefinition();
            //根据BeanDefinition实例判断调用哪个，其实最后还是调用
            //核心方法：processConfigurationClass(ConfigurationClass configClass)
            try {
                if (bd instanceof AnnotatedBeanDefinition) {
                    this.parse(((AnnotatedBeanDefinition)bd).getMetadata(), holder.getBeanName());
                } else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition)bd).hasBeanClass()) {
                    this.parse(((AbstractBeanDefinition)bd).getBeanClass(), holder.getBeanName());
                } else {
                    this.parse(bd.getBeanClassName(), holder.getBeanName());
                }
            } catch (BeanDefinitionStoreException var6) {
                throw var6;
            } catch (Throwable var7) {
                throw new BeanDefinitionStoreException("Failed to parse configuration class [" + bd.getBeanClassName() + "]", var7);
            }
        }
        //字面理解：处理延迟导入的javabean
        //parse方法，把被处理的类实现DeferredImportSelector接口，加入deferredImportSelectors集合中，
        //处理deferredImportSelectors集合种类
        this.processDeferredImportSelectors();
    }

parse调用核心方法processConfigurationClass(ConfigurationClass configClass)解析

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
        //检查当前解析的配置bean是否包含Conditional注解，如果不包含则不需要跳过
        // 如果包含了则进行match方法得到匹配结果，如果是符合的并且设置的配置解析策略是解析阶段不需要调过
        if (!this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
            //在这里处理Configuration重复import
            //如果同一个配置类被处理两次，两次都属于被import的则合并导入类，返回。如果配置类不是被导入的，则移除旧使用新的配置类
            ConfigurationClass existingClass = (ConfigurationClass)this.configurationClasses.get(configClass);
            if (existingClass != null) {
                if (configClass.isImported()) {
                    if (existingClass.isImported()) {
                        existingClass.mergeImportedBy(configClass);
                    }
                    // Otherwise ignore new imported config class; existing non-imported class overrides it.
                    return;
                }
                // Explicit bean definition found, probably replacing an import.
                // Let's remove the old one and go with the new one.
                this.configurationClasses.remove(configClass);
                this.knownSuperclasses.values().removeIf(configClass::equals);
            }
            // Recursively process the configuration class and its superclass hierarchy.
            ConfigurationClassParser.SourceClass sourceClass = this.asSourceClass(configClass);
            //递归解析
            do {
                sourceClass = this.doProcessConfigurationClass(configClass, sourceClass);
            } while(sourceClass != null);
            // 添加到ConfigurationClassParser的configurationClasses中
            this.configurationClasses.put(configClass, configClass);
        }
    }

递归解析，调用doProcessConfigurationClass方法，终于到了解析的地方！！

总结一下：

1.处理内部类

2.处理@PropertySource注解

3.处理@ComponentScan注解

4.处理@Import注解

5.处理@ImportResource注解

6.处理@Bean修饰的方法

7.处理接口定义的方法

8.处理父类

protected final ConfigurationClassParser.SourceClass doProcessConfigurationClass(ConfigurationClass configClass, ConfigurationClassParser.SourceClass sourceClass) throws IOException {
        // Recursively process any member (nested) classes first 处理内部类
        this.processMemberClasses(configClass, sourceClass);
        // Process any @PropertySource annotations
        // 处理@PropertySource注解
        Iterator var3 = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), PropertySources.class, PropertySource.class).iterator();

        AnnotationAttributes importResource;
        while(var3.hasNext()) {
            importResource = (AnnotationAttributes)var3.next();
            if (this.environment instanceof ConfigurableEnvironment) {
                this.processPropertySource(importResource);
            } else {
                this.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)) {
            Iterator var13 = componentScans.iterator();
            // The config class is annotated with @ComponentScan -> perform the scan immediately
            //扫描
            while(var13.hasNext()) {
                AnnotationAttributes componentScan = (AnnotationAttributes)var13.next();
                Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
                Iterator var7 = scannedBeanDefinitions.iterator();
                // Check the set of scanned definitions for any further config classes and parse recursively if necessary
                //遍历扫描到的配置类进行递归解析
                while(var7.hasNext()) {
                    BeanDefinitionHolder holder = (BeanDefinitionHolder)var7.next();
                    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                    if (bdCand == null) {
                        bdCand = holder.getBeanDefinition();
                    }

                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                        this.parse(bdCand.getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }
        // Process any @Import annotations
        // 处理@Import注解
        this.processImports(configClass, sourceClass, this.getImports(sourceClass), true);
        // Process any @ImportResource annotations.
        // 处理@ImportResource 注解
        importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
        if (importResource != null) {
            String[] resources = importResource.getStringArray("locations");
            Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
            String[] var19 = resources;
            int var21 = resources.length;
            // 遍历配置的locations,加入到configClass 中的ImportedResource
            for(int var22 = 0; var22 < var21; ++var22) {
                String resource = var19[var22];
                String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
                configClass.addImportedResource(resolvedResource, readerClass);
            }
        }
        // Process individual @Bean methods
        // 处理@Bean修饰的方法
        Set<MethodMetadata> beanMethods = this.retrieveBeanMethodMetadata(sourceClass);
        Iterator var17 = beanMethods.iterator();

        while(var17.hasNext()) {
            MethodMetadata methodMetadata = (MethodMetadata)var17.next();
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }
        // Process default methods on interfaces
        // 处理接口定义的方法
        this.processInterfaces(configClass, sourceClass);
        if (sourceClass.getMetadata().hasSuperClass()) {
            String superclass = sourceClass.getMetadata().getSuperClassName();
            if (superclass != null && !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;
    }

1.处理内部类（递归解析）

private void processMemberClasses(ConfigurationClass configClass, ConfigurationClassParser.SourceClass sourceClass) throws IOException {
        //读取配置类中所有成员类
        Collection<ConfigurationClassParser.SourceClass> memberClasses = sourceClass.getMemberClasses();
        if (!memberClasses.isEmpty()) {
            List<ConfigurationClassParser.SourceClass> candidates = new ArrayList(memberClasses.size());
            Iterator var5 = memberClasses.iterator();
            //过滤出配置类
            ConfigurationClassParser.SourceClass candidate;
            while(var5.hasNext()) {
                candidate = (ConfigurationClassParser.SourceClass)var5.next();
                if (ConfigurationClassUtils.isConfigurationCandidate(candidate.getMetadata()) && !candidate.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
                    candidates.add(candidate);
                }
            }
            //根据Order进行排序
            OrderComparator.sort(candidates);
            var5 = candidates.iterator();
            //遍历
            while(var5.hasNext()) {
                candidate = (ConfigurationClassParser.SourceClass)var5.next();
                //1）出现配置类循环导入,直接报错
                if (this.importStack.contains(configClass)) {
                    this.problemReporter.error(new ConfigurationClassParser.CircularImportProblem(configClass, this.importStack));
                } else {
                    //将配置类入栈
                    this.importStack.push(configClass);

                    try {
                        //处理配置类
                        this.processConfigurationClass(candidate.asConfigClass(configClass));
                    } finally {
                        //解析完出栈
                        this.importStack.pop();
                    }
                }
            }
        }

    }

2.处理@PropertySource注解

 如果配置类上有@PropertySource注解，则解析加载properties文件，并将属性添加到Spring上下文中。

this.addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, encoding)));

3.处理@ComponentScan注解

获取配置类上的@ComponentScan注解，判断是否需要跳过。循环所有的ComponentScan，立即执行扫描。

// Process any @ComponentScan annotations
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
        if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
            Iterator var13 = componentScans.iterator();

            while(var13.hasNext()) {
                AnnotationAttributes componentScan = (AnnotationAttributes)var13.next();
                // The config class is annotated with @ComponentScan -> perform the scan immediately
                Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
                Iterator var7 = scannedBeanDefinitions.iterator();
                // Check the set of scanned definitions for any further config classes and parse recursively if needed
                while(var7.hasNext()) {
                    BeanDefinitionHolder holder = (BeanDefinitionHolder)var7.next();
                    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                    if (bdCand == null) {
                        bdCand = holder.getBeanDefinition();
                    }
                    //检验扫描获得的BeanDefinition中是否有配置类，如果有配置类,这里的配置类包括FullConfigurationClass和LiteConfigurationClass。
                    //（也就是说只要有@Configuration、@Component、@ComponentScan、@Import、@ImportResource和@Bean中的其中一个注解），则递归调用parse方法，进行解析。
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                        this.parse(bdCand.getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }

4.处理@Import注解

this.processImports(configClass, sourceClass, this.getImports(sourceClass), true);

processImports方法负责对@Import注解进行解析。configClass是配置类，sourceClass又是通过configClass创建的，getImports(sourceClass)从sourceClass获取所有的@Import注解信息

private void processImports(ConfigurationClass configClass, ConfigurationClassParser.SourceClass currentSourceClass, Collection<ConfigurationClassParser.SourceClass> importCandidates, boolean checkForCircularImports) {
        if (!importCandidates.isEmpty()) {
            //循环导入直接报错
            if (checkForCircularImports && this.isChainedImportOnStack(configClass)) {
                this.problemReporter.error(new ConfigurationClassParser.CircularImportProblem(configClass, this.importStack));
            } else {
                //推入栈
                this.importStack.push(configClass);

                try {
                    Iterator var5 = importCandidates.iterator();
                    //循环遍历
                    while(true) {
                        while(true) {
                            while(var5.hasNext()) {
                                ConfigurationClassParser.SourceClass candidate = (ConfigurationClassParser.SourceClass)var5.next();
                                Class candidateClass;
                                //对import的内容进行分类
                                // import导入实现ImportSelector接口的类
                                if (candidate.isAssignable(ImportSelector.class)) {
                                    // Candidate class is an ImportSelector -> delegate to it to determine imports
                                    candidateClass = candidate.loadClass();
                                    // 反射创建这个类的实例对象
                                    ImportSelector selector = (ImportSelector)BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
                                    //是否有实现相关Aware接口,如果有,这调用相关方法
                                    ParserStrategyUtils.invokeAwareMethods(selector, this.environment, this.resourceLoader, this.registry);
                                    // 延迟加载的ImportSelector
                                    if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
                                        //  延迟加载的ImportSelector先放到List中,延迟加载
                                        this.deferredImportSelectors.add(new ConfigurationClassParser.DeferredImportSelectorHolder(configClass, (DeferredImportSelector)selector));
                                    } else {
                                        // 普通的ImportSelector ,执行其selectImports方法,获取需要导入的类的全限定类名数组
                                        String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                                        Collection<ConfigurationClassParser.SourceClass> importSourceClasses = this.asSourceClasses(importClassNames);
                                        // 递归调用
                                        this.processImports(configClass, currentSourceClass, importSourceClasses, false);
                                    }
                                    // 是否为ImportBeanDefinitionRegistrar
                                } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                                    // Candidate class is an ImportBeanDefinitionRegistrar ->
                                    // delegate to it to register additional bean definitions
                                    candidateClass = candidate.loadClass();
                                    ImportBeanDefinitionRegistrar registrar = (ImportBeanDefinitionRegistrar)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
                                    // 普通 @Configuration class
                                    this.importStack.registerImport(currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                                    // 解析导入的@Configuration class
                                    this.processConfigurationClass(candidate.asConfigClass(configClass));
                                }
                            }

                            return;
                        }
                    }
                } catch (BeanDefinitionStoreException var15) {
                    throw var15;
                } catch (Throwable var16) {
                    throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" + configClass.getMetadata().getClassName() + "]", var16);
                } finally {
                    this.importStack.pop();
                }
            }
        }
    }

5.处理@ImportResource注解

@ImportResource注解可以导入xml配置文件。

// Process any @ImportResource annotations
importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
        if (importResource != null) {
            String[] resources = importResource.getStringArray("locations");
            Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
            String[] var19 = resources;
            int var21 = resources.length;

            for(int var22 = 0; var22 < var21; ++var22) {
                String resource = var19[var22];
                String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
                //把配置项提取出来，跟reader一起放入configClass的map中，
                //接下来会在ConfigurationClassPostProcessor类中processConfigBeanDefinitions方法中，解析完，
                //this.reader.loadBeanDefinitions(configClasses)这方法会对@import处理（对ImportBeanDefinitionRegistrars的处理）
                configClass.addImportedResource(resolvedResource, readerClass);
            }
        }

6.处理@Bean修饰的方法

将@Bean方法转化为BeanMethod对象

Set<MethodMetadata> beanMethods = this.retrieveBeanMethodMetadata(sourceClass);
        Iterator var17 = beanMethods.iterator();

        while(var17.hasNext()) {
            MethodMetadata methodMetadata = (MethodMetadata)var17.next();
            //添加到configClass的beanMethods集合中，接下来，会在this.reader.loadBeanDefinitions(configClasses)这方法
            //得到处理
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }

7.处理接口定义的方法

this.processInterfaces(configClass, sourceClass);

8.处理父类

if (sourceClass.getMetadata().hasSuperClass()) {
            String superclass = sourceClass.getMetadata().getSuperClassName();
            if (superclass != null && !superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
                this.knownSuperclasses.put(superclass, configClass);
                return sourceClass.getSuperClass();
            }
        }

如果有父类则返回父类Class对象，继续调用该方法。直到返回null，外层循环结束。

do {
            sourceClass = doProcessConfigurationClass(configClass, sourceClass);
        }
        while (sourceClass != null);