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循環(huán)中，會從beanFactory中已經(jīng)有的bean的定義中尋找有Configuration注解的配置類。
    //默認(rèn)這里獲取到的只有一個包含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的定義的查找都是在這里完成的。下面我們?nèi)タ纯催@里的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是當(dāng)前解析出來的配置類,value就是表示這個配置類是通過誰來導(dǎo)入的。
  	//如果這個配置類不是通過別的類來導(dǎo)入的，這時key和value就是一樣的。
		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
  	//如果通過多個配置類導(dǎo)入了同一個配置類，那么把這個和配置類的導(dǎo)入關(guān)系就要進(jìn)行一下合并
		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.
  	//這里是將配置類轉(zhuǎn)化為SourceClass對象
		SourceClass sourceClass = asSourceClass(configClass, filter);
		do {
      //在這里就會進(jìn)行真正的配置類的解析出來。
      
      //注意這里是個do-while循環(huán)，處理完當(dāng)前的配置類，會繼續(xù)去處理當(dāng)前配置類的父類。
      //如果當(dāng)前類的父類類名不是java開頭,且沒有被處理過的話，就會在這個do-while循環(huán)中繼續(xù)去處理
      
			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注解，有的話，查找當(dāng)前類的內(nèi)部類，進(jìn)行處理
		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// Recursively process any member (nested) classes first
      //這里就可能會遞歸調(diào)用到上面的processConfigurationClass方法
			processMemberClasses(configClass, sourceClass, filter);
		}

		// Process any @PropertySource annotations
    //在這里，查看類是否有PropertySources注解，有的話去解析屬性配置，添加到環(huán)境上下文中去
		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注解，有的話，就根據(jù)這里的條件去進(jìn)行目錄掃描，查找bean的定義
    //由于我們當(dāng)前的類上有SpringBootApplication注解，所以這里是能夠找到ComponentScan注解的，就會進(jìn)到這個方法里面去
		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注解相關(guān)的內(nèi)容。
        //ComponentScans注解上有個basePackages屬性，用來指定掃描的包的名字。
        //如果沒有指定basePackages屬性，就在當(dāng)前類的包下及其所有子包下去查找相關(guān)的bean的定義。
        //我們一般不會指定basePackages屬性，那么會在當(dāng)前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)) {	
            //這里也會間接調(diào)用到processConfigurationClass方法
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// Process any @Import annotations
    //在這里，就會去處理類上的import注解。
    
    //getImports(sourceClass)首先會獲取到import的類。
    //這里會有兩個，一個是AutoConfigurationPackage上注解的AutoConfigurationPackages.Registrar.class
    //另一個是EnableAutoConfiguration上的注解AutoConfigurationImportSelector.class)
    
    //下面我們?nèi)タ纯磒rocessImports這個方法
   	//這里面也可能會調(diào)用到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;
		}
		//這里是錯誤檢查，檢查是否出現(xiàn)了遞歸
		if (checkForCircularImports && isChainedImportOnStack(configClass)) {
			this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
		}
		else {
      //先將當(dāng)前的配置類壓入棧
			this.importStack.push(configClass);
			try {
        //這里，就會對import標(biāo)簽導(dǎo)入的類進(jìn)行處理
				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();
            //首先在這里創(chuàng)建一個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) {
            //在這里，將當(dāng)前的配置類和AutoConfigurationImportSelector的對象封裝成DeferredImportSelectorHolder對象
            //添加到延遲導(dǎo)入的集合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這個類就會走到這個分支中
          //在這個分支中，首先創(chuàng)建AutoConfigurationPackages.Registrar的對象
          //添加到當(dāng)前配置類的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 {

			......//這部分前面已經(jīng)分析過了，我們就繼續(xù)看后面的吧

		// 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
    //這里是處理配置類內(nèi)部的有Bean注解的方法，添加到配置類的beanMethods屬性中
		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}

		// Process default methods on interfaces
    //這里處理配置類實現(xiàn)的接口上默認(rèn)方法上有Bean注解的話,也添加到beanMethods屬性中
		processInterfaces(configClass, sourceClass);

		// Process superclass, if any
    
    //這里去獲取配置類的父類，如果存在父類且父類類名不是java開頭且還沒有被處理過，就會返回父類，繼續(xù)進(jìn)行父類的處理。
		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);
          //這里會對延遲導(dǎo)入的類進(jìn)行分組，添加到handler中，由于我們這里只有一個對象，所以這塊的分組，我們可以不用太關(guān)注
          //同時會將前面的配置類添加到handler對象的configurationClasses屬性中
					deferredImports.forEach(handler::register);
          //下面就會交給handler去進(jìn)行處理
					handler.processGroupImports();
				}
			}
			finally {
				this.deferredImportSelectors = new ArrayList<>();
			}
		}
	}

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

		public Iterable<Group.Entry> getImports() {
			//這里的deferredImports中只有一個對象，還是之前的DeferredImportSelectorHolder
			for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
        //這里的this.group就是之前分組的deferredImport.getImportSelector().getImportGroup();方法的返回值創(chuàng)建的對象
        //具體就是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()));
      //下面這行代碼也比較重要，我們進(jìn)去看看
			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) {
		//這里,我們就能看到設(shè)置spring.boot.enableautoconfiguration屬性去禁止導(dǎo)入系統(tǒng)配置的bean的定義
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}

		AnnotationAttributes attributes = getAttributes(annotationMetadata);
    //在下面這行中，就能看到通過ClassLoader去加載META-INF/spring.factories文件，讀取內(nèi)容。放置到cache中
    //在當(dāng)前這里,會去獲取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);
    //在這里獲取配置過濾類并創(chuàng)建對象，對上面的configuras進(jìn)行過濾
    //這里的配置過濾類也是從cache中獲取,key=org.springframework.boot.autoconfigure.AutoConfigurationImportFilter
		configurations = getConfigurationClassFilter().filter(configurations);
    //這行代碼不關(guān)鍵，我們可以不用去關(guān)注
		fireAutoConfigurationImportEvents(configurations, exclusions);
    //這里返回一個AutoConfigurationEntry對象
    //其中configurations是過濾器能夠匹配到的配置類,exclusions在我們這里是空的
		return new AutoConfigurationEntry(configurations, exclusions);
	}

		public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
			......//上面的代碼剛才已經(jīng)分析過了
      //在這里將上面返回的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();
				//上面已經(jīng)分析到grouping.getImports()返回的是Entry對象的集合
				grouping.getImports().forEach(entry -> {
          //entry.getMetadata()返回的還是我們之前的主類。
          //這里的configurationClass也是我們之前的主類。
          //這個主要是為了在processImports方法中創(chuàng)建的配置類為它們設(shè)置importedBy屬性
					ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
					try {
            //這里又會調(diào)用到processImports這個方法。這個在前面已經(jīng)分析過了，但是這里有一點不一樣，下面我們看看不一樣的地方
						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
            //上次進(jìn)入這個方法，分別走了上面的兩個分支，現(xiàn)在大概率會走到這個分支
            //這里會將導(dǎo)入的類添加到imports屬性中,key是新導(dǎo)入的配置類,value是我們之前的主類
						this.importStack.registerImport(
								currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
            //這里又會去處理新添加的配置類，在這里是有可能出現(xiàn)遞歸的，下面我們具體分析下這里的處理邏輯
						processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
					}
				}
			}
			......
		}
	}

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

      //這里就會得到所有的配置類
			Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
      //alreadyParsed第一次是空的，由于這個方法是do-while循環(huán)，在后面會對這個變量賦值
			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數(shù)量是否有增加,如果有增加說明我們在本次do-while代碼中添加了beanFactory
      //下面的邏輯主要是為了判斷當(dāng)前掃描出來的配置類是否全部添加進(jìn)了beanFactory中,如果有配置類還沒有被今天進(jìn)去，就會循環(huán)，重新執(zhí)行上面的邏輯
			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注解進(jìn)行處理，來判斷當(dāng)前配置類是否要被過濾掉
		TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
		for (ConfigurationClass configClass : configurationModel) {
			//在這里會對每個配置類及它的屬性進(jìn)行處理，封裝成beanDefinition添加到beanFactory中去
			loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
		}
	}

	private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
		
    //這里就會對Conditional注解進(jìn)行判斷，如果當(dāng)前類是被導(dǎo)入的，就會去判斷導(dǎo)入它的類
		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;
		}
		//如果類是被導(dǎo)入的，就會去對它進(jìn)行處理
		if (configClass.isImported()) {
			registerBeanDefinitionForImportedConfigurationClass(configClass);
		}
    //下面就是對配置類的各種屬性進(jìn)行處理
    //處理方法上的bean注解
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}
		//處理導(dǎo)入的資源
		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    //處理導(dǎo)入的ImportBeanDefinitionRegistrar
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
	}