spring 启动之解析配置类

配置类分类

配置类分为 FULL配置类和LITE配置类

FULL配置类：@Configuration(proxyBeanMethods=ture) //proxyBeanMethods默认为ture

LITE配置类：方法上有@Bean的或者类上有@Component、@ComponentScan、@Import、@ImportResource

1.LITE配置类

• @Component解析配置类的时候会查看其是否有内部类，有则循环解析其内部类
• @PropertySource，如果配置类上存在该注解，解析得到PropertySource对象，并添加到environment中去
• @ComponentScan会扫描指定路径生成BeanDefinition，然后判断BeanDefinition中是否有配置类，有则进行解析，生成对应的ConfigurationClass
• @Import 判断Import类型：
  1.如果实现了ImportSelector接口，调用行selectImports方法得到类名，将该类作为配置类解析
  2.如果实现了ImportBeanDefinitionRegistrar，生成一个ImportBeanDefinitionRegistrar实例对象，并添加到配置类对象中（ConfigurationClass）的importBeanDefinitionRegistrars属性中
• @ImportResource注解，把导入进来的资源路径存在配置类对象中的importedResources属性中
• @Bean的方法，那么则把这些方法封装为BeanMethod对象，并添加到配置类对象中的beanMethods属性中
• 配置类实现了某些接口，则看这些接口内是否定义了@Bean的默认方法
• 配置类有父类，则把父类当做配置类进行解析
• 解析完配置类后判断是否新增BeanDefinition，再次判断新增的BeanDefinition是否是需要解析的配置类
• @Bean方法生成的bean无法被再次解析为配置类，而通过xml定义的Bean可以被解析为配置类(在判断时，@Bean方法拿不到className，xml方法可以拿的)

2.FULL配置类
FULL配置类会生成当前配置类的代理对象，该代理对象使用Bean时通过代理对象会先判断是否已经生成Bena对象了，如果已经生成则直接使用已经存在的对象，否则则生成。

AnnotationConfigApplicationContext

@Component 和@Component如果存在同名Bean，则抛出异常
@Component和@Bean如果存在同名Bean，则@Bean会覆盖@Component
@Bean和@Bean如果存在同名Bean，则第二个@Bean注解不会生成Bean

当我们 new AnnotationConfigApplicationContext(AppConfig.class) 的时候，AnnotationConfigApplicationContext会先调用自身的无参构造方法，然后通过GenericApplicationContext父类创建DefaultListableBeanFactory

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
    private final AnnotatedBeanDefinitionReader reader;
    private final ClassPathBeanDefinitionScanner scanner;

    public AnnotationConfigApplicationContext() {
        StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
        this.reader = new AnnotatedBeanDefinitionReader(this);
        createAnnotatedBeanDefReader.end();
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
    public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
        this();
        this.register(componentClasses);
        this.refresh();
    }

public GenericApplicationContext() {
    this.customClassLoader = false;
    this.refreshed = new AtomicBoolean();
    this.beanFactory = new DefaultListableBeanFactory();
}

DefaultListableBeanFactory在spring(不是springBoot)容器启动时实例化，后续的beanFactory都是它。

注册ConfigurationClassPostProcessor

new AnnotationConfigApplicationContext–>this()–>new AnnotatedBeanDefinitionReader–>AnnotationConfigUtils.registerAnnotationConfigProcessors–>new RootBeanDefinition(ConfigurationClassPostProcessor.class)

AnnotationConfigUtils.registerAnnotationConfigProcessors会注册一些PostProcesser成为BeanDefinition，注册到DefaultListableBeanFactory.beanDefinitionMap中，此处并没有实例化，后续调用getBean进行实例化和初始化

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {

... ... 中间部分代码省略

    if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalConfigurationAnnotationProcessor")) {
        def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"));
    }

refresh

spring容器启动的主要方法是refresh，代码如下：

public void refresh() throws BeansException, IllegalStateException {
    synchronized(this.startupShutdownMonitor) {
        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
        this.prepareRefresh();
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        this.prepareBeanFactory(beanFactory);

        try {
            this.postProcessBeanFactory(beanFactory);
            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
            this.invokeBeanFactoryPostProcessors(beanFactory);
            this.registerBeanPostProcessors(beanFactory);
            beanPostProcess.end();
            this.initMessageSource();
            this.initApplicationEventMulticaster();
            this.onRefresh();
            this.registerListeners();
            this.finishBeanFactoryInitialization(beanFactory);
            this.finishRefresh();
        } catch (BeansException var10) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);
            }

            this.destroyBeans();
            this.cancelRefresh(var10);
            throw var10;
        } finally {
            this.resetCommonCaches();
            contextRefresh.end();
        }

    }
}

AbstractApplicationContext.invokeBeanFactoryPostProcessors

1. invokeBeanFactoryPostProcessors会调用实现了BeanFactoryPostProcessors接口的postProcessBeanFactory方法
2. invokeBeanFactoryPostProcessors会调用实现BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法
3. BeanDefinitionRegistryPostProcessor接口继承了postProcessBeanFactory接口
4. ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor
5. 在invokeBeanFactoryPostProcessors方法中通过beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false) 获取到ConfigurationClassPostProcessor，通过getBean方法进行初始化和实例化
6. ConfigurationClassPostProcessor会进行配置类解析并生成对应的BeanDefinition对象，使其进入spring容器。
7. invokeBeanFactoryPostProcessors会再次beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false) 获取其他实现该接口的bean(此时已经被加载进spring容器)，执行BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry()
8. 执行BeanFactoryPostProcessors接口的postProcessBeanFactory方法
   ,先执行子接口的该方法，然后执行手动注册的方法(spring支持直接调用context进行注册)，最后执行实现父接口(beanFactory.getBeanNamesForType(BeanDefinitionPostProcessor.class, true, false) )的该方法。

ConfigurationClassPostProcessor加载配置类

new AnnotationConfigApplicationContext–>this()–>refresh()–>AbstractApplicationContext.invokeBeanFactoryPostProcessors–>PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors–>beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false)–>ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry–>currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class))–>invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup())

//调用BeanFactoryPostProcessors接口的postProcessBeanFactory和BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    Set<String> processedBeans = new HashSet();
    ArrayList regularPostProcessors;
    ArrayList registryProcessors;
    int var9;
    ArrayList currentRegistryProcessors;
    String[] postProcessorNames;
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
        regularPostProcessors = new ArrayList();
        registryProcessors = new ArrayList();
        Iterator var6 = beanFactoryPostProcessors.iterator();

        while(var6.hasNext()) {
        	//此处先拿到自己通过context注册的BeanFactoryPostProcessor 
            BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            } else {
                regularPostProcessors.add(postProcessor);
            }
        }

        currentRegistryProcessors = new ArrayList();
        //拿到spring容器中的BeanDefinitionRegistryPostProcessor实现类，ConfigurationClassPostProcessor
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        String[] var16 = postProcessorNames;
        var9 = postProcessorNames.length;

        int var10;
        String ppName;
        for(var10 = 0; var10 < var9; ++var10) {
            ppName = var16[var10];
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            	//获取到ConfigurationClassPostProcessor
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }

        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        //调用ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry方法，将配置类加载，并将需要加载的bean生成beanDefinition
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        currentRegistryProcessors.clear();
        //获取所有的BeanDefinitionRegistryPostProcessor(通过ConfigurationClassPostProcessor加载进来的BeanDefinitionRegistryPostProcessor)
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        var16 = postProcessorNames;
        var9 = postProcessorNames.length;

        for(var10 = 0; var10 < var9; ++var10) {
            ppName = var16[var10];
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
            	//生成bean
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }

        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        //调用postProcessBeanDefinitionRegistry方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        currentRegistryProcessors.clear();
        boolean reiterate = true;

        while(reiterate) {
            reiterate = false;
            //如果调用postProcessBeanDefinitionRegistry后，该方法注册了BeanDefinitionRegistryPostProcessor，则进行获取
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            String[] var19 = postProcessorNames;
            var10 = postProcessorNames.length;

            for(int var26 = 0; var26 < var10; ++var26) {
                String ppName = var19[var26];
                if (!processedBeans.contains(ppName)) {
                	//生成bean
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }

            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
        }

        invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);
        invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
    } else {
        invokeBeanFactoryPostProcessors((Collection)beanFactoryPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
    }

    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    regularPostProcessors = new ArrayList();
    registryProcessors = new ArrayList();
    currentRegistryProcessors = new ArrayList();
    postProcessorNames = postProcessorNames;
    int var20 = postProcessorNames.length;

    String ppName;
    for(var9 = 0; var9 < var20; ++var9) {
        ppName = postProcessorNames[var9];
        if (!processedBeans.contains(ppName)) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                regularPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                registryProcessors.add(ppName);
            } else {
                currentRegistryProcessors.add(ppName);
            }
        }
    }

    sortPostProcessors(regularPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList(registryProcessors.size());
    Iterator var21 = registryProcessors.iterator();

    while(var21.hasNext()) {
        String postProcessorName = (String)var21.next();
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }

    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors((Collection)orderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList(currentRegistryProcessors.size());
    Iterator var24 = currentRegistryProcessors.iterator();

    while(var24.hasNext()) {
        ppName = (String)var24.next();
        nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    }

    invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
    beanFactory.clearMetadataCache();
}

1.ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry

postProcessBeanDefinitionRegistry会通过配置类注册所以bean的beanDifinition

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList();
    //此时candidateNames 中只有spring容器启动时注册的少部分BeanDefinition，其中有ConfigurationClassPostProcessor
    String[] candidateNames = registry.getBeanDefinitionNames();
    String[] var4 = candidateNames;
    int var5 = candidateNames.length;

    for(int var6 = 0; var6 < var5; ++var6) {
        String beanName = var4[var6];
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
        if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
            }
        //参考下面第二点
        } else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
    }

    if (!configCandidates.isEmpty()) {
        configCandidates.sort((bd1, bd2) -> {
            int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
            int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
            return Integer.compare(i1, i2);
        });
        SingletonBeanRegistry sbr = null;
        if (registry instanceof SingletonBeanRegistry) {
            sbr = (SingletonBeanRegistry)registry;
            if (!this.localBeanNameGeneratorSet) {
                BeanNameGenerator generator = (BeanNameGenerator)sbr.getSingleton("org.springframework.context.annotation.internalConfigurationBeanNameGenerator");
                if (generator != null) {
                    this.componentScanBeanNameGenerator = generator;
                    this.importBeanNameGenerator = generator;
                }
            }
        }

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

        ConfigurationClassParser parser = new ConfigurationClassParser(this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, this.componentScanBeanNameGenerator, registry);
        Set<BeanDefinitionHolder> candidates = new LinkedHashSet(configCandidates);
        HashSet alreadyParsed = new HashSet(configCandidates.size());

        do {
            StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
            //解析candidates 参考3
            parser.parse(candidates);
            parser.validate();
            //configClasses 会存储解析并生成出来的配置类
            Set<ConfigurationClass> configClasses = new LinkedHashSet(parser.getConfigurationClasses());
            configClasses.removeAll(alreadyParsed);
            if (this.reader == null) {
                this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor, this.resourceLoader, this.environment, this.importBeanNameGenerator, parser.getImportRegistry());
            }
			//处理配置类中的 importBeanDefinitionRegistrars，importedResources，beanMethods(这三个属性是ConfigurationClass的属性，在下面第二点有解释)
            this.reader.loadBeanDefinitions(configClasses);
            alreadyParsed.addAll(configClasses);
            processConfig.tag("classCount", () -> {
                return String.valueOf(configClasses.size());
            }).end();
            candidates.clear();
            //在解析配置类中BeanDefinition是否增加
            if (registry.getBeanDefinitionCount() > candidateNames.length) {
                String[] newCandidateNames = registry.getBeanDefinitionNames();
                Set<String> oldCandidateNames = new HashSet(Arrays.asList(candidateNames));
                Set<String> alreadyParsedClasses = new HashSet();
                Iterator var13 = alreadyParsed.iterator();

                while(var13.hasNext()) {
                    ConfigurationClass configurationClass = (ConfigurationClass)var13.next();
                    alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
                }

                String[] var24 = newCandidateNames;
                int var25 = newCandidateNames.length;

                for(int var15 = 0; var15 < var25; ++var15) {
                    String candidateName = var24[var15];
                    if (!oldCandidateNames.contains(candidateName)) {
                        BeanDefinition bd = registry.getBeanDefinition(candidateName);
                        //判断新增的BeanDefinition中是否有配置类
                        if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) && !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                        	//加入到candidates集合中，使循环再次解析新的配置类
                            candidates.add(new BeanDefinitionHolder(bd, candidateName));
                        }
                    }
                }

                candidateNames = newCandidateNames;
            }
        } while(!candidates.isEmpty());

        if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
            sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
        }

        if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
            ((CachingMetadataReaderFactory)this.metadataReaderFactory).clearCache();
        }

    }
}

2.ConfigurationClassUtils.checkConfigurationClassCandidate

该方法判断什么是配置类，LITE配置类会在接下来的逻辑中解析，FULL配置类会beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, “full”)，在之后ConfigurationClassPostProcessor.postProcessBeanFactory中处理@Configuration时使用

public static boolean checkConfigurationClassCandidate(BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
    String className = beanDef.getBeanClassName();
    if (className != null && beanDef.getFactoryMethodName() == null) {
        AnnotationMetadata metadata;
        if (beanDef instanceof AnnotatedBeanDefinition && className.equals(((AnnotatedBeanDefinition)beanDef).getMetadata().getClassName())) {
            metadata = ((AnnotatedBeanDefinition)beanDef).getMetadata();
        } else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition)beanDef).hasBeanClass()) {
            Class<?> beanClass = ((AbstractBeanDefinition)beanDef).getBeanClass();
            if (BeanFactoryPostProcessor.class.isAssignableFrom(beanClass) || BeanPostProcessor.class.isAssignableFrom(beanClass) || AopInfrastructureBean.class.isAssignableFrom(beanClass) || EventListenerFactory.class.isAssignableFrom(beanClass)) {
                return false;
            }

            metadata = AnnotationMetadata.introspect(beanClass);
        } else {
            try {
                MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
                metadata = metadataReader.getAnnotationMetadata();
            } catch (IOException var6) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Could not find class file for introspecting configuration annotations: " + className, var6);
                }

                return false;
            }
        }
		
        Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
        //FULL配置类
        if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
            beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, "full");
        } else {
            if (config == null && !isConfigurationCandidate(metadata)) {
                return false;
            }
			//LITE配置类
            beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, "lite");
        }

        Integer order = getOrder(metadata);
        if (order != null) {
            beanDef.setAttribute(ORDER_ATTRIBUTE, order);
        }

        return true;
    } else {
        return false;
    }
}
public static boolean isConfigurationCandidate(AnnotationMetadata metadata) {
    if (metadata.isInterface()) {
        return false;
    } else {
        Iterator var1 = candidateIndicators.iterator();

        String indicator;
        do {
            if (!var1.hasNext()) {
            	//判断方法上是否有@Bean
                return hasBeanMethods(metadata);
            }

            indicator = (String)var1.next();
        //类上有@Component、@ComponentScan、@Import、@ImportResource
        } while(!metadata.isAnnotated(indicator));

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

3.parse 真正进行解析配置类

parse–>this.parse–>processConfigurationClass–>doProcessConfigurationClass
processConfigurationClass会真正进行解析配置类
doProcessConfigurationClass:

@Nullable
protected final ConfigurationClassParser.SourceClass doProcessConfigurationClass(ConfigurationClass configClass, ConfigurationClassParser.SourceClass sourceClass, Predicate<String> filter) throws IOException {
	//判断是否有Component注解
    if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
    	//Component注解的类的内部类是否是配置类并解析
        this.processMemberClasses(configClass, sourceClass, filter);
    }

	//@PropertySource注解
    Iterator var4 = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), PropertySources.class, PropertySource.class).iterator();

    AnnotationAttributes importResource;
    while(var4.hasNext()) {
        importResource = (AnnotationAttributes)var4.next();
        if (this.environment instanceof ConfigurableEnvironment) {
        	//将Property文件内容拿到，加入到Environment中
            this.processPropertySource(importResource);
        } else {
            this.logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() + "]. Reason: Environment must implement ConfigurableEnvironment");
        }
    }

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

        while(var14.hasNext()) {
            AnnotationAttributes componentScan = (AnnotationAttributes)var14.next();
            //componentScanParser.parse 进行扫描 得到BeanDefinition
            Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
            Iterator var8 = scannedBeanDefinitions.iterator();

            while(var8.hasNext()) {
                BeanDefinitionHolder holder = (BeanDefinitionHolder)var8.next();
                BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                if (bdCand == null) {
                    bdCand = holder.getBeanDefinition();
                }
				//检查扫描出来的BeanDefinition是否是配置类
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                    this.parse(bdCand.getBeanClassName(), holder.getBeanName());
                }
            }
        }
    }

	//@Import注解
    this.processImports(configClass, sourceClass, this.getImports(sourceClass), filter, true);
    //@ImportResource注解
    importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
    if (importResource != null) {
        String[] resources = importResource.getStringArray("locations");
        Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
        String[] var20 = resources;
        int var22 = resources.length;

        for(int var23 = 0; var23 < var22; ++var23) {
            String resource = var20[var23];
            String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
            configClass.addImportedResource(resolvedResource, readerClass);
        }
    }
	//	//@Bean注解 方法
    Set<MethodMetadata> beanMethods = this.retrieveBeanMethodMetadata(sourceClass);
    Iterator var18 = beanMethods.iterator();

    while(var18.hasNext()) {
        MethodMetadata methodMetadata = (MethodMetadata)var18.next();
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }
	//实现的接口中默认方法@Bean注解
    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);
            return sourceClass.getSuperClass();
        }
    }

    return null;
}

下面为调用流程代码

public void parse(Set<BeanDefinitionHolder> configCandidates) {
    Iterator var2 = configCandidates.iterator();

    while(var2.hasNext()) {
        BeanDefinitionHolder holder = (BeanDefinitionHolder)var2.next();
        BeanDefinition bd = holder.getBeanDefinition();

        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);
        }
    }

    this.deferredImportSelectorHandler.process();
}
    protected final void parse(Class<?> clazz, String beanName) throws IOException {
    this.processConfigurationClass(new ConfigurationClass(clazz, beanName), DEFAULT_EXCLUSION_FILTER);
}
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
    if (!this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
        ConfigurationClass existingClass = (ConfigurationClass)this.configurationClasses.get(configClass);
        if (existingClass != null) {
            if (configClass.isImported()) {
                if (existingClass.isImported()) {
                    existingClass.mergeImportedBy(configClass);
                }

                return;
            }

            this.configurationClasses.remove(configClass);
            this.knownSuperclasses.values().removeIf(configClass::equals);
        }

        ConfigurationClassParser.SourceClass sourceClass = this.asSourceClass(configClass, filter);

		//循环的作用是循环解析父类
        do {
            sourceClass = this.doProcessConfigurationClass(configClass, sourceClass, filter);
        } while(sourceClass != null);

        this.configurationClasses.put(configClass, configClass);
    }
}

1.ConfigurationClassPostProcessor.postProcessBeanFactory

该方法在ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry处理完所有LITE配置类后使用，进行配置类增强

postProcessBeanFactory --> enhanceConfigurationClasses

    if (!configBeanDefs.isEmpty() && !NativeDetector.inNativeImage()) {
    	//创建代理类
        ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
        Iterator var17 = configBeanDefs.entrySet().iterator();

        while(var17.hasNext()) {
            Entry<String, AbstractBeanDefinition> entry = (Entry)var17.next();
            AbstractBeanDefinition beanDef = (AbstractBeanDefinition)entry.getValue();
            beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
            //找到FULL配置类的类名
            Class<?> configClass = beanDef.getBeanClass();
            //生成代理类
            Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
            if (configClass != enhancedClass) {
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
                }
				//设置代理对象替换原来的beanClass
                beanDef.setBeanClass(enhancedClass);
            }
        }

2.ConfigurationClassEnhancer

调用逻辑：postProcessBeanFactory --> enhanceConfigurationClasses–>ConfigurationClassEnhancer.enhance–>createClass–>Enhancer.registerStaticCallbacks(subclass, CALLBACKS)–>ConfigurationClassEnhancer.BeanMethodInterceptor.intercept
CALLBACKS中的类：

static {
    CALLBACKS = new Callback[]{new ConfigurationClassEnhancer.BeanMethodInterceptor(), new ConfigurationClassEnhancer.BeanFactoryAwareMethodInterceptor(), NoOp.INSTANCE};
    CALLBACK_FILTER = new ConfigurationClassEnhancer.ConditionalCallbackFilter(CALLBACKS);
    logger = LogFactory.getLog(ConfigurationClassEnhancer.class);
    objenesis = new SpringObjenesis();
}

ConfigurationClassEnhancer.BeanMethodInterceptor类的intercept是一个拦截器方法，会拦截ConfigurationClassEnhancer代理对象，判断方法名和beanName是否一致，一致则创建，否则则调用getBean获取Bean(如果该Bean是单例的，getBean获取Bean是该单例的对象)

    @Nullable
    public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs, MethodProxy cglibMethodProxy) throws Throwable {
        ConfigurableBeanFactory beanFactory = this.getBeanFactory(enhancedConfigInstance);
        String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);
        if (BeanAnnotationHelper.isScopedProxy(beanMethod)) {
            String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
            if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
                beanName = scopedBeanName;
            }
        }

        if (this.factoryContainsBean(beanFactory, "&" + beanName) && this.factoryContainsBean(beanFactory, beanName)) {
            Object factoryBean = beanFactory.getBean("&" + beanName);
            if (!(factoryBean instanceof ScopedProxyFactoryBean)) {
                return this.enhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);
            }
        }
		//判断当前方法是否是创建对应Bean的方法
        if (this.isCurrentlyInvokedFactoryMethod(beanMethod)) {
            if (ConfigurationClassEnhancer.logger.isInfoEnabled() && BeanFactoryPostProcessor.class.isAssignableFrom(beanMethod.getReturnType())) {
                ConfigurationClassEnhancer.logger.info(String.format("@Bean method %s.%s is non-static and returns an object assignable to Spring's BeanFactoryPostProcessor interface. This will result in a failure to process annotations such as @Autowired, @Resource and @PostConstruct within the method's declaring @Configuration class. Add the 'static' modifier to this method to avoid these container lifecycle issues; see @Bean javadoc for complete details.", beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName()));
            }

            return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
        //当前方法不是创建对应Bean的方法，调用getBean方法。
        } else {
            return this.resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
        }
    }

具体示例：
以下代码中，创建OrderService的Bean时，新new了一个UserService对象，但是由于该配置类时FULL配置类，会被ConfigurationClassEnhancer.BeanMethodInterceptor拦截，将该UserService对象通过getBean的方式注入，故保证OrderService 的Bean拿到的时UserService的单例Bean

@Configuration
public class AppConfig {

    @Bean
    public UserService userService(){
        return new UserService();
    }

    @Bean
    public OrderService orderService(){
        return new OrderService(new UserService());
    }

}