Springboot淺析（三）——容器刷新流程

時間 2020-03-02

原文原文鏈接

1、先了解下各類後置處理器擴展點

(一)BeanFactoryPostProcessor——bean工廠後置處理

BeanFactory 標準初始化完畢後(通過包掃描後全部的 BeanDefinition 已經被註冊)，能夠對這個 BeanFactory 進行後置處理。web

(二)BeanDefinitionRegistryPostProcessor——bean定義註冊表後置處理

BeanFactoryPostProcessor的子接口，多了一個postProcessBeanDefinitionRegistry方法，這個方法容許在Bean實例化以前對BeanDefinitionRegistry（bean定義註冊表）進行後置處理。緩存

(三)BeanPostProcessor——bean後置處理器

提供對實例化後的bean進行後置處理的擴展點。通常用於對將要實例化到容器的bean進行再次加工。app

(四)MergedBeanDefinitionPostProcessor——合併Bean定義後置處理器

BeanPostProcessor的子接口，多一個postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) 方法，用於後置處理合並Bean定義。ide

2、容器刷新流程

（一）主要代碼

//最終調到AbstractApplicationContext的refresh方法
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        // 初始化前的預處理，初始化Environment裏面的PropertySources(猜想是webXML裏面的東西)，debug下沒有什麼用
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        //  獲取BeanFactory,直接返回的是前面初始化的beanFactory,只不過設置了一下SerializationId
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        // 3. BeanFactory的預處理配置
	//(1) 在容器註冊了ApplicationContextAwareProcessor這個Bean後置處理器用於處理實現了XXXAware接口的bean，調用其setXXX方法。
	//(2)忽略一些自動注入，以及添加一些自動注入的支持，爲何要忽略這些自動注入勒，由於當beanDefinition的AutowireMode爲1（按setXXX方法的名稱進行注入）和2（按setXXX方法返回值類型進行自動注入）時，若自動注入生效，該Bean的setXXX方法將被自動注入，那麼爲了不和XXXAware接口衝突，因此進行了忽略。
	//(3) 添加一些自動注入支持，包含BeanFactory，ResourceLoader，ApplicationEventPublisher，ApplicationContext。
	//(4) 在容器註冊了new ApplicationListenerDetector(this)這個Bean後置處理器用於收集全部實現了ApplicationListener接口的bean並收集到容器中的一個集合中。
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            // 4. 準備BeanFactory完成後進行的後置處理
	    //以servlet環境爲例：
	    //(1) 添加了一個bean的後置處理器處理ServletContextAware和ServletConfigAware，用於注入ServletContext和ServletConfig。
	    //(2) 往容器註冊Scope，Scope描述的是Spring容器如何新建Bean實例的，這裏註冊了Request以及Session兩個Scope而且註冊ServletRequest、ServletResponse、HttpSession、WebRequest爲自動裝配。
	    //(3)當判斷容器的basePackages屬性不爲null的時候進行包掃描（但debug下這裏沒執行）。
	    //(4)當判斷容器的annotatedClasses屬性不爲null也進行註冊(debug下沒執行)。
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            // 5. 執行BeanFactory建立後的後置處理器，
			// 這一步裏面會處理ConfigurationClassPostProcessor這個bd後置處理器完成全部的bd註冊
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            // 6. 註冊Bean的後置處理器
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            // 7. 初始化MessageSource
            initMessageSource();

            // Initialize event multicaster for this context.
            // 8. 初始化事件派發器
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            // 9. 子類的多態onRefresh
            onRefresh();

            // Check for listener beans and register them.
            // 10. 註冊監聽器
            registerListeners();
            //到此爲止，BeanFactory已建立完成
            // Instantiate all remaining (non-lazy-init) singletons.
            // 11. 初始化全部剩下的單例Bean
            finishBeanFactoryInitialization(beanFactory);
            // Last step: publish corresponding event.
            // 12. 完成容器的建立工做
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }
            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();
            // Reset 'active' flag.
            cancelRefresh(ex);
            // Propagate exception to caller.
            throw ex;
        }

        finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            // 13. 清除緩存
            resetCommonCaches();
        }
    }
}

(二)核心點

1.prepareBeanFactory(beanFactory)-BeanFactory的預處理配置

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   // Tell the internal bean factory to use the context's class loader etc.
   // 設置BeanFactory的類加載器、表達式解析器等
   beanFactory.setBeanClassLoader(getClassLoader());
   beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

   // Configure the bean factory with context callbacks.
   //  配置一個BeanPostProcessor，這個Bean後處理器將實現瞭如下幾個Aware的bean分別回調對應的方法
   beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	// 配置ignoreDependencyInterface，是的這些類型自動裝配無效，但實測@Autowired注入時仍是能裝配，故這裏的意思是爲了不其餘bd設置了自動注入，即AutowireMode，而不是指使用@Autowired註解進行的依賴注入。
   beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
   beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
   beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

   // BeanFactory interface not registered as resolvable type in a plain factory.
   // MessageSource registered (and found for autowiring) as a bean.
   // 自動注入的支持
   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   beanFactory.registerResolvableDependency(ApplicationContext.class, this);

   // Register early post-processor for detecting inner beans as ApplicationListeners.
   // 配置一個可加載全部監聽器的組件
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

   // Detect a LoadTimeWeaver and prepare for weaving, if found.
   if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
       beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
       // Set a temporary ClassLoader for type matching.
       beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }

   // Register default environment beans.
   // 註冊了默認的運行時環境、系統配置屬性、系統環境的信息
   if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
       beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
   }
   if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
       beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
   }
   if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
       beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
   }
}

這裏主要乾了四件事：post

在容器註冊了ApplicationContextAwareProcessor這個Bean後置處理器用於處理實現了XXXAware接口的bean，調用其setXXX方法。
忽略一些自動注入，以及添加一些自動注入的支持，爲何要忽略這些自動注入勒，由於當beanDefinition的AutowireMode爲1（按setXXX方法的名稱進行注入）和2（按setXXX方法返回值類型進行自動注入）時，若自動注入生效，該Bean的setXXX方法將被自動注入，那麼爲了不和XXXAware接口衝突，因此進行了忽略。
添加一些自動注入支持，包含BeanFactory，ResourceLoader，ApplicationEventPublisher，ApplicationContext。
在容器註冊了new ApplicationListenerDetector(this)這個Bean後置處理器用於收集全部實現了ApplicationListener接口的bean並收集到容器中的一個集合中。

2.postProcessBeanFactory(beanFactory)-準備BeanFactory完成後進行的後置處理

以servlet爲例:這裏的ApplicationContext實現實際上爲AnnotationConfigServletWebServerApplicationContext。在AnnotationConfigServletWebServerApplicationContext類中該方法主要是完成了：this

往容器註冊了一個bean的後置處理器處理ServletContextAware和ServletConfigAware，用於注入ServletContext和ServletConfig。
往容器註冊Scope，Scope描述的是Spring容器如何新建Bean實例的，這裏註冊了Request以及Session兩個Scope而且註冊ServletRequest、ServletResponse、HttpSession、WebRequest爲自動裝配。
當判斷容器的basePackages屬性不爲null的時候進行包掃描（但debug下這裏沒執行）。
當判斷容器的annotatedClasses屬性不爲null也進行註冊(debug下沒執行)。

3.invokeBeanFactoryPostProcessors(beanFactory)-執行BeanFactory建立後的後置處理器

代碼：.net

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 執行BeanFactory後置處理器
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

    // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

進入 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors())：debug

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    //用於存放已經執行了的processedBeans
    Set<String> processedBeans = new HashSet<>();

    // 這裏要判斷BeanFactory的類型，默認SpringBoot建立的BeanFactory是DefaultListableBeanFactory
    // 這個類實現了BeanDefinitionRegistry接口，則此if結構必進
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();
		//遍歷已經註冊到beanFactory的BeanFactoryPostProcessor後置處理器，而後分類爲regularPostProcessors和registryProcessors
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            }
            else {
                regularPostProcessors.add(postProcessor);
            }
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        // Separate between BeanDefinitionRegistryPostProcessors that implement
        // PriorityOrdered, Ordered, and the rest.
     	//這個currentRegistryProcessors變量用於分階段執行方法，由於有PriorityOrdered和Ordered接口的存在
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
  
        // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
        // 首先，調用實現PriorityOrdered接口的BeanDefinitionRegistryPostProcessors並添加到processedBeans
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
		//排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        //添加到registryProcessors
        registryProcessors.addAll(currentRegistryProcessors);
        //執行
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();

        // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
        // 接下來，調用實現Ordered接口的BeanDefinitionRegistryPostProcessors。
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
		//排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        //添加到registryProcessors
		registryProcessors.addAll(currentRegistryProcessors);
		//執行
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();

        // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
        // 最後，調用全部其餘BeanDefinitionRegistryPostProcessor
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }
			//排序添加執行
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();
        }

        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        // 回調全部BeanFactoryPostProcessor的postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        // 先回調BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
        // 再調用BeanFactoryPostProcessor的postProcessBeanFactory方法
    }

    // 若是BeanFactory沒有實現BeanDefinitionRegistry接口，則進入下面的代碼流程
    else {
        // Invoke factory processors registered with the context instance.
        // 調用在上下文實例中註冊的工廠處理器。
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // 下面的部分是回調BeanFactoryPostProcessor，思路與上面的幾乎同樣
  
    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let the bean factory post-processors apply to them!
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // Finally, invoke all other BeanFactoryPostProcessors.
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // Clear cached merged bean definitions since the post-processors might have
    // modified the original metadata, e.g. replacing placeholders in values...
    // 清理緩存
    beanFactory.clearMetadataCache();
}

上面代碼有點長主要幹得事有：rest

第一步獲取已經註冊到容器（與beanDifinitionMap相區別，這裏用了容器內beanFactoryPostProcessors這個變量存的而不是從beanDefinition獲取的）的beanFactoryPostProcessor的beanFactoryPostProcessors，並篩選實現了BeanDefinitionRegistryPostProcessor接口的，執行其postProcessBeanDefinitionRegistry方法.
第二步獲取容器內已註冊的beanDefinition中BeanDefinitionRegistryPostProcessor類型的bean，篩選實現了PriorityOrdered接口的，進行排序，而後回調其postProcessBeanDefinitionRegistry。這裏執行最重要的ConfigurationClassPostProcessor，他會對當前beandifinitonMap中的帶有configraution註解的進行處理，好比處理@Component 、@ComponentScan 、@Import 、@ImportResource、@PropertySource 、@ComponentScan 、@Import 、@ImportResource 、@Bean註解，註冊全部的beanDefinition,等一下展開講這個ConfigurationClassPostProcessor。
第三步獲取容器內已註冊的beanDefinition中BeanDefinitionRegistryPostProcessor類型的bean，會根據是否實現PriorityOrdered接口Ordered接口進行排序（大致順序是PriorityOrdered優先Ordered優先沒實現接口的，同一接口的按方法返回值肯定順序），而後調用其postProcessBeanDefinitionRegistry方法。
第四步執行上面全部beanDefinitionRegistryPostProcessor類型的bean的postBeanFactory方法。
第五步對於ApplicationContext內（與beanDifinitionMap相區別，這裏用了beanFactoryPostProcessors這個變量存而不是beanDefinition存）的beanFactoryPostProcessor，不屬於BeanDefinitionRegistryPostProcessor接口的（即只是BeanFactoryProcessor），調用其postBeanFactory方法。
第六步調用其餘全部BeanFactoryPostProcessor的postBeanFactory方法，也會解析PriorityOrdered及Ordered接口。

接下來重點看一看在第二步執行的ConfigurationClassPostProcessor的源碼，內部就不詳細展開了，大概的流程已經寫入註釋中：code

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

這裏的意思是獲取容器Id,獲取其是否調用過，若是沒有則繼續執行processConfigBeanDefinitions。看一看 processConfigBeanDefinitions(registry)方法：

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    String[] candidateNames = registry.getBeanDefinitionNames();

    // 肯定配置類和組件
	//帶有@Configuration註解的bd的configurationClass值設爲full，
	//帶有@Component 、@ComponentScan 、@Import 、@ImportResource註解或方法中添加了帶@Bean的方法
	//（只是將帶bean的方法收集起來，並無註冊bd）的設爲configurationClass值設爲lite，並加入到configCandidates
    for (String beanName : candidateNames) {
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
                ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
            if (logger.isDebugEnabled()) {
                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));
        }
    }

    // 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
    // 加載獲取BeanNameGenerator
    SingletonBeanRegistry sbr = null;
    if (registry instanceof SingletonBeanRegistry) {
        sbr = (SingletonBeanRegistry) registry;
        if (!this.localBeanNameGeneratorSet) {
            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
    // 初始化配置類解析器
    ConfigurationClassParser parser = new ConfigurationClassParser(
            this.metadataReaderFactory, this.problemReporter, this.environment,
            this.resourceLoader, this.componentScanBeanNameGenerator, registry);
	//須要解析的配置類集合
    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    //已經解析的配置類集合
	Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
    do {
        // 解析配置類，最重要的方法
		//對configCandidates按照@Order進行排序並遍歷進行遞歸一直解析父類，
		//需解析@PropertySource 、@ComponentScan 、@Import 、@ImportResource 、@Bean註解(注這一步尚未對掃描到的組件徹底進行Bd註冊，
		//而只是註冊了包掃描到的bd以及處理@Import註解時實現了ImportBeanDefinitionRegistrar或者ImportSelector接口的bd,
		//而且這裏會先處理一個類的嵌套配置類）
        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，而後註冊到BeanDefinitionMap中。
        this.reader.loadBeanDefinitions(configClasses);
        alreadyParsed.addAll(configClasses);
        candidates.clear();
        if (registry.getBeanDefinitionCount() > candidateNames.length) {
		   //當前的bdNames
            String[] newCandidateNames = registry.getBeanDefinitionNames();
			//上一次解析以前的bdNames
            Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
			//此次解析的bdNames
            Set<String> alreadyParsedClasses = new HashSet<>();
            for (ConfigurationClass configurationClass : alreadyParsed) {
                alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
            }
			//遍歷當前bdNames，若不是之前有的，而且是配置類，而且沒有被解析到，則添加到candidates，下一次循環再解析一次
            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
    // 將ImportRegistry註冊爲Bean，以支持ImportAware 和@Configuration類
    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();
    }
}