springboot自動掃描新增的BeanDefinition原始碼範例詳解

package com.example.bootargs;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BootargsApplication {

    public static void main(String[] args) {
        SpringApplication.run(BootargsApplication.class, args);
    }

}

	/**
	 * Build and validate a configuration model based on the registry of
	 * {@link Configuration} classes.
	 */
	public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
		String[] candidateNames = registry.getBeanDefinitionNames();
		//在下面的這個for迴圈中，會從beanFactory中已經有的bean的定義中尋找有Configuration註解的設定類。
    //預設這裡獲取到的只有一個包含SpringBootApplication註解的主類
		for (String beanName : candidateNames) {
				......
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}
		
    //如果沒有找到設定類，就直接返回
		// Return immediately if no @Configuration classes were found
		if (configCandidates.isEmpty()) {
			return;
		}

		......
		//在這裡就通過ConfigurationClassParser去解析設定類
		// 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 {
			StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
			//所有bean的定義的查詢都是在這裡完成的。下面我們去看看這裡的parse方法
      parser.parse(candidates);
			......
	}

protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
  	//在這裡首先看設定類上是否有Conditional註解，如果有的話，就去解析處理，看看是否要跳過這個註解類
		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
		}
		
  	//所有解析出來的設定類都要放置到configurationClasses中,key是當前解析出來的設定類,value就是表示這個設定類是通過誰來匯入的。
  	//如果這個設定類不是通過別的類來匯入的，這時key和value就是一樣的。
		ConfigurationClass existingClass = 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;
			}
			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);
				this.knownSuperclasses.values().removeIf(configClass::equals);
			}
		}

		// Recursively process the configuration class and its superclass hierarchy.
  	//這裡是將設定類轉化為SourceClass物件
		SourceClass sourceClass = asSourceClass(configClass, filter);
		do {
      //在這裡就會進行真正的設定類的解析出來。
      
      //注意這裡是個do-while迴圈，處理完當前的設定類，會繼續去處理當前設定類的父類別。
      //如果當前類的父類別類名不是java開頭,且沒有被處理過的話，就會在這個do-while迴圈中繼續去處理
      
			sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
		}
		while (sourceClass != null);
		
		this.configurationClasses.put(configClass, configClass);
	}

@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingBean(name = AbstractApplicationContext.MESSAGE_SOURCE_BEAN_NAME, search = SearchStrategy.CURRENT)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Conditional(ResourceBundleCondition.class)
@EnableConfigurationProperties
public class MessageSourceAutoConfiguration 

	@Nullable
	protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException {
		//在這裡，檢視類是否有Component註解，有的話，查詢當前類的內部類，進行處理
		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// Recursively process any member (nested) classes first
      //這裡就可能會遞迴呼叫到上面的processConfigurationClass方法
			processMemberClasses(configClass, sourceClass, filter);
		}

		// Process any @PropertySource annotations
    //在這裡，檢視類是否有PropertySources註解，有的話去解析屬性設定，新增到環境上下文中去
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
			else {
				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}

		// Process any @ComponentScan annotations
    //在這裡，檢視類是否有ComponentScans註解，有的話，就根據這裡的條件去進行目錄掃描，查詢bean的定義
    //由於我們當前的類上有SpringBootApplication註解，所以這裡是能夠找到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) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
        //在這裡，就會去處理ComponentScans註解相關的內容。
        //ComponentScans註解上有個basePackages屬性，用來指定掃描的包的名字。
        //如果沒有指定basePackages屬性，就在當前類的包下及其所有子包下去查詢相關的bean的定義。
        //我們一般不會指定basePackages屬性，那麼會在當前sourceClass類的包及其所有子包下去查詢bean的定義。
        //我們自己程式碼中定義的controller,service,dao等等都是在這一步獲取到bean的定義的。
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {	
            //這裡也會間接呼叫到processConfigurationClass方法
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// Process any @Import annotations
    //在這裡，就會去處理類上的import註解。
    
    //getImports(sourceClass)首先會獲取到import的類。
    //這裡會有兩個，一個是AutoConfigurationPackage上註解的AutoConfigurationPackages.Registrar.class
    //另一個是EnableAutoConfiguration上的註解AutoConfigurationImportSelector.class)
    
    //下面我們去看看processImports這個方法
   	//這裡面也可能會呼叫到processConfigurationClass方法
		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
		......
	}

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
			boolean checkForCircularImports) {
		
		if (importCandidates.isEmpty()) {
			return;
		}
		//這裡是錯誤檢查，檢查是否出現了遞迴
		if (checkForCircularImports && isChainedImportOnStack(configClass)) {
			this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
		}
		else {
      //先將當前的設定類壓入棧
			this.importStack.push(configClass);
			try {
        //這裡，就會對import標籤匯入的類進行處理
				for (SourceClass candidate : importCandidates) {
          
          //AutoConfigurationImportSelector.class類就會走下面的分支
					if (candidate.isAssignable(ImportSelector.class)) {
						// Candidate class is an ImportSelector -> delegate to it to determine imports
						Class<?> candidateClass = candidate.loadClass();
            //首先在這裡建立一個AutoConfigurationImportSelector類的物件，
						ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
								this.environment, this.resourceLoader, this.registry);
						Predicate<String> selectorFilter = selector.getExclusionFilter();
						if (selectorFilter != null) {
							exclusionFilter = exclusionFilter.or(selectorFilter);
						}
						if (selector instanceof DeferredImportSelector) {
            //在這裡，將當前的設定類和AutoConfigurationImportSelector的物件封裝成DeferredImportSelectorHolder物件
            //新增到延遲匯入的集合deferredImportSelectors中
							this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
						}
						else {
							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
							processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
						}
					}
          //AutoConfigurationPackages.Registrar.class這個類就會走到這個分支中
          //在這個分支中，首先建立AutoConfigurationPackages.Registrar的物件
          //新增到當前設定類的importBeanDefinitionRegistrars屬性中去
					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 =
								ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
										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), exclusionFilter);
					}
				}
			}
			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();
			}
		}
	}

	@Nullable
	protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException {

			......//這部分前面已經分析過了，我們就繼續看後面的吧

		// Process any @ImportResource annotations
    // 這裡是處理ImportResource註解
		AnnotationAttributes importResource =
				AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
		if (importResource != null) {
			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註解的方法，新增到設定類的beanMethods屬性中
		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}

		// Process default methods on interfaces
    //這裡處理設定類實現的介面上預設方法上有Bean註解的話,也新增到beanMethods屬性中
		processInterfaces(configClass, sourceClass);

		// Process superclass, if any
    
    //這裡去獲取設定類的父類別，如果存在父類別且父類別類名不是java開頭且還沒有被處理過，就會返回父類別，繼續進行父類別的處理。
		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;
	}

public void parse(Set<BeanDefinitionHolder> configCandidates) {
		......
		//就會走到下面這行程式碼
		this.deferredImportSelectorHandler.process();
	}

		public void process() {
			
			//在上面程式碼中我們分析到this.deferredImportSelectors中只有一個
      //由前面的設定類和AutoConfigurationImportSelector類的物件封裝的DeferredImportSelectorHolder物件
			List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
			this.deferredImportSelectors = null;
			try {
				if (deferredImports != null) {
					DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
					deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
          //這裡會對延遲匯入的類進行分組，新增到handler中，由於我們這裡只有一個物件，所以這塊的分組，我們可以不用太關注
          //同時會將前面的設定類新增到handler物件的configurationClasses屬性中
					deferredImports.forEach(handler::register);
          //下面就會交給handler去進行處理
					handler.processGroupImports();
				}
			}
			finally {
				this.deferredImportSelectors = new ArrayList<>();
			}
		}
	}

public void processGroupImports() {
  		//這裡就按分組去處理了
			for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
				Predicate<String> exclusionFilter = grouping.getCandidateFilter();
        //這裡的grouping.getImports()就回去獲取系統的設定類,我們下面去看這個getImports
				grouping.getImports().forEach(entry -> {
				......
			}
		}

		public Iterable<Group.Entry> getImports() {
			//這裡的deferredImports中只有一個物件，還是之前的DeferredImportSelectorHolder
			for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
        //這裡的this.group就是之前分組的deferredImport.getImportSelector().getImportGroup();方法的返回值建立的物件
        //具體就是AutoConfigurationImportSelector.AutoConfigurationGroup的物件
        //下面我們先看看這個process方法
				this.group.process(deferredImport.getConfigurationClass().getMetadata(),
						deferredImport.getImportSelector());
			}
			return this.group.selectImports();
		}

		public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
			Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
					() -> String.format("Only %s implementations are supported, got %s",
							AutoConfigurationImportSelector.class.getSimpleName(),
							deferredImportSelector.getClass().getName()));
      //下面這行程式碼也比較重要，我們進去看看
			AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
					.getAutoConfigurationEntry(annotationMetadata);
			this.autoConfigurationEntries.add(autoConfigurationEntry);
			for (String importClassName : autoConfigurationEntry.getConfigurations()) {
				this.entries.putIfAbsent(importClassName, annotationMetadata);
			}
		}

	protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		//這裡,我們就能看到設定spring.boot.enableautoconfiguration屬性去禁止匯入系統設定的bean的定義
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}

		AnnotationAttributes attributes = getAttributes(annotationMetadata);
    //在下面這行中，就能看到通過ClassLoader去載入META-INF/spring.factories檔案，讀取內容。放置到cache中
    //在當前這裡,會去獲取key=org.springframework.boot.autoconfigure.EnableAutoConfiguration的所有屬性設定
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		configurations = removeDuplicates(configurations);
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
    //在這裡獲取設定過濾類並建立物件，對上面的configuras進行過濾
    //這裡的設定過濾類也是從cache中獲取,key=org.springframework.boot.autoconfigure.AutoConfigurationImportFilter
		configurations = getConfigurationClassFilter().filter(configurations);
    //這行程式碼不關鍵，我們可以不用去關注
		fireAutoConfigurationImportEvents(configurations, exclusions);
    //這裡返回一個AutoConfigurationEntry物件
    //其中configurations是過濾器能夠匹配到的設定類,exclusions在我們這裡是空的
		return new AutoConfigurationEntry(configurations, exclusions);
	}

		public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
			......//上面的程式碼剛才已經分析過了
      //在這裡將上面返回的AutoConfigurationEntry物件新增到autoConfigurationEntries中
			this.autoConfigurationEntries.add(autoConfigurationEntry);
      
			for (String importClassName : autoConfigurationEntry.getConfigurations()) {
        //分別將新增的設定類新增到entries這個屬性中
        //importClassName是新查詢到的設定類,annotationMetadata都是同一個就是我們的主類
				this.entries.putIfAbsent(importClassName, annotationMetadata);
			}
		}

	public void processGroupImports() {
			for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
				Predicate<String> exclusionFilter = grouping.getCandidateFilter();
				//上面已經分析到grouping.getImports()返回的是Entry物件的集合
				grouping.getImports().forEach(entry -> {
          //entry.getMetadata()返回的還是我們之前的主類。
          //這裡的configurationClass也是我們之前的主類。
          //這個主要是為了在processImports方法中建立的設定類為它們設定importedBy屬性
					ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
					try {
            //這裡又會呼叫到processImports這個方法。這個在前面已經分析過了，但是這裡有一點不一樣，下面我們看看不一樣的地方
						processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
								Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)),
								exclusionFilter, false);
					}
					catch (BeanDefinitionStoreException ex) {
						throw ex;
					}
					catch (Throwable ex) {
						throw new BeanDefinitionStoreException(
								"Failed to process import candidates for configuration class [" +
										configurationClass.getMetadata().getClassName() + "]", ex);
					}
				});
			}
		}

	private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
			boolean checkForCircularImports) {

			this.importStack.push(configClass);
			try {
				for (SourceClass candidate : importCandidates) {
					if (candidate.isAssignable(ImportSelector.class)) {
					......
					}
					else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
					......	
					}
					else {

						// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
						// process it as an @Configuration class
            //上次進入這個方法，分別走了上面的兩個分支，現在大概率會走到這個分支
            //這裡會將匯入的類新增到imports屬性中,key是新匯入的設定類,value是我們之前的主類
						this.importStack.registerImport(
								currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
            //這裡又會去處理新新增的設定類，在這裡是有可能出現遞迴的，下面我們具體分析下這裡的處理邏輯
						processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
					}
				}
			}
			......
		}
	}

	public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    ......
		do {
			StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
			parser.parse(candidates);//前面已經分析到了這裡
			parser.validate();

      //這裡就會得到所有的設定類
			Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
      //alreadyParsed第一次是空的，由於這個方法是do-while迴圈，在後面會對這個變數賦值
			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());
			}
      //在這裡就會對前面獲取的所有的設定類新增到beanFactory中
			this.reader.loadBeanDefinitions(configClasses);
			alreadyParsed.addAll(configClasses);
			processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();

			candidates.clear();
      //這裡就是對比前後beanFactory中的beanDefinition數量是否有增加,如果有增加說明我們在本次do-while程式碼中新增了beanFactory
      //下面的邏輯主要是為了判斷當前掃描出來的設定類是否全部新增進了beanFactory中,如果有設定類還沒有被今天進去，就會迴圈，重新執行上面的邏輯
			if (registry.getBeanDefinitionCount() > candidateNames.length) {
				String[] newCandidateNames = registry.getBeanDefinitionNames();
				Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
				Set<String> alreadyParsedClasses = new HashSet<>();
				for (ConfigurationClass configurationClass : alreadyParsed) {
					alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
				}
				for (String candidateName : newCandidateNames) {
					if (!oldCandidateNames.contains(candidateName)) {
						BeanDefinition bd = registry.getBeanDefinition(candidateName);
						if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
								!alreadyParsedClasses.contains(bd.getBeanClassName())) {
							candidates.add(new BeanDefinitionHolder(bd, candidateName));
						}
					}
				}
				candidateNames = newCandidateNames;
			}
		}
		while (!candidates.isEmpty());

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

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

	public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
		
		//這個類還是用來對Conditional註解進行處理，來判斷當前設定類是否要被過濾掉
		TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
		for (ConfigurationClass configClass : configurationModel) {
			//在這裡會對每個設定類及它的屬性進行處理，封裝成beanDefinition新增到beanFactory中去
			loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
		}
	}

	private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
		
    //這裡就會對Conditional註解進行判斷，如果當前類是被匯入的，就會去判斷匯入它的類
		if (trackedConditionEvaluator.shouldSkip(configClass)) {
			String beanName = configClass.getBeanName();
			if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
				this.registry.removeBeanDefinition(beanName);
			}
			this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
			return;
		}
		//如果類是被匯入的，就會去對它進行處理
		if (configClass.isImported()) {
			registerBeanDefinitionForImportedConfigurationClass(configClass);
		}
    //下面就是對設定類的各種屬性進行處理
    //處理方法上的bean註解
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}
		//處理匯入的資源
		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    //處理匯入的ImportBeanDefinitionRegistrar
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
	}