Spring从源码层面剖析——下

Spring从源码层面剖析——下 前言

这次写的内容，是接着上次的博客Spring从源码层面剖析——上
因为spring源码有几万行，即使只看核心代码，也要看很久，所以分两次来学习记录。

IOC

接着上次看Spring的IOC，看它是怎么创建bean对象。
根据上次debug看程序的执行流程，我们知道了spring已经把几个后置处理器类 ( xxxPostProcessor)和我们定义的配置类(MainConfig)注册成了bean定义(BeanDefinition)。 我们看到了核心方法 refresh()，然后进一步跟到了一个方法processConfigBeanDefinitions

processConfigBeanDefinitions

	public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		List configCandidates = new ArrayList<>();
		//获取IOC 容器中目前所有bean定义的名称
		String[] candidateNames = registry.getBeanDefinitionNames();

		//循环我们的上一步获取的所有的bean定义信息
		for (String beanName : candidateNames) {
			//通过bean的名称来获取我们的bean定义对象
			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));
			}
		}

		// 若没有找到配置类 直接返回
		if (configCandidates.isEmpty()) {
			return;
		}

		//对我们的配置类进行Order排序
		configCandidates.sort((bd1, bd2) -> {
			int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
			int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
			return Integer.compare(i1, i2);
		});

		// 创建我们通过@CompentScan导入进来的bean name的生成器
		// 创建我们通过@import导入进来的bean的名称
		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) {
					//设置@CompentScan导入进来的bean的名称生成器(默认类首字母小写）也可以自己定义，一般不会
					this.componentScanBeanNameGenerator = generator;
					//设置@import导入进来的bean的名称生成器(默认类首字母小写）也可以自己定义，一般不会
					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);

		//用于保存我们的配置类BeanDefinitionHolder放入上面筛选出来的配置类
		Set candidates = new linkedHashSet<>(configCandidates);
		//用于保存我们的已经解析的配置类，长度默认为解析出来默认的配置类的集合长度
		Set alreadyParsed = new HashSet<>(configCandidates.size());
		//do while 会进行第一次解析
		do {
			//真正的解析我们的配置类 
			parser.parse(candidates); //todo:(注意这个方法，后续我们要重点跟进)
			parser.validate();

			//解析出来的配置类
			Set 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());
			}
			// 此处才把@Bean的方法和@import 注册到BeanDefinitionMap中
			this.reader.loadBeanDefinitions(configClasses);
			//加入到已经解析的集合中
			alreadyParsed.addAll(configClasses);

			candidates.clear();
			//判断我们ioc容器中的是不是>候选原始的bean定义的个数
			if (registry.getBeanDefinitionCount() > candidateNames.length) {
				//获取所有的bean定义
				String[] newCandidateNames = registry.getBeanDefinitionNames();
				//原始的老的候选的bean定义
				Set oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
				Set 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();
		}
	}

跟进这个方法：parser.parse(candidates); 是去解析BeanDefinition。

public void parse(Set configCandidates) {
		
		this.deferredimportSelectors = new linkedList<>();
		// 循环配置类
		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				//真正的解析我们的bean定义 :通过注解元数据 解析
				if (bd instanceof AnnotatedBeanDefinition) {
					//todo:(注意这个方法，后续我们要重点跟进)
					parse(((AnnotatedBeanDefinition) bd).getmetadata(), holder.getBeanName());
				}
				else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
					parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
				}
				else {
					parse(bd.getBeanClassName(), holder.getBeanName());
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
			}
		}
		//处理我们延时的DeferredimportSelectors w我们springboot就是通过这步进行记载spring.factories文件中的自定装配的对象
		processDeferredimportSelectors();
	}

接着跟进它解析的核心方法：parse(((AnnotatedBeanDefinition) bd).getmetadata(), holder.getBeanName());

	
	protected final void parse(Annotationmetadata metadata, String beanName) throws IOException {
		
		 //todo:(注意这个方法，后续我们要重点跟进)
		processConfigurationClass(new ConfigurationClass(metadata, beanName)); 
	}

看到它执行了processConfigurationClass方法，继续跟进 processConfigurationClass

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
		if (this.conditionevaluator.shouldSkip(configClass.getmetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
		}

		//获取处我们的配置类对象
		ConfigurationClass existingClass = this.configurationClasses.get(configClass);

		if (existingClass != null) {
			//传入进来的配置类是通过其他配置类的import导入进来的
			if (configClass.isimported()) {
				if (existingClass.isimported()) {
					//需要合并配置
					existingClass.mergeimportedBy(configClass);
				}
				// Otherwise ignore new imported config class; existing non-imported class overrides it.
				// 所以假如通过@import导入一个 已存在的配置类 是不允许的，会忽略。
				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 = asSourceClass(configClass);
		//真正的进行配置类的解析
		do {
			//解析我们的配置类   //todo:(注意这个方法，后续我们要重点跟进)
			sourceClass = doProcessConfigurationClass(configClass, sourceClass);
		}
		while (sourceClass != null);

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

这行代码 ：sourceClass = doProcessConfigurationClass(configClass, sourceClass);
通过经验总结在spring源码中，如果一个方法是do开头的，那这个方法会特别重要，是真正做事的核心方法，那我们重点寻找的核心代码也将会在这个方法里体现。
下面继续跟进 doProcessConfigurationClass方法

重要方法 doProcessConfigurationClass

	
	@Nullable
	protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
			throws IOException {

		// Recursively process any member (nested) classes first
		processMemberClasses(configClass, sourceClass);

		//处理我们的@propertySource注解的
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getmetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
			else {
				logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getmetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}

		//解析我们的 @ComponentScan 注解

		//从我们的配置类上解析处ComponentScans的对象集合属性
		Set componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getmetadata(), ComponentScans.class, ComponentScan.class);
		if (!componentScans.isEmpty() &&
				!this.conditionevaluator.shouldSkip(sourceClass.getmetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			//循环解析 我们解析出来的AnnotationAttributes
			for (AnnotationAttributes componentScan : componentScans) {
				//把我们扫描出来的类变为bean定义的集合 真正的解析  //todo:(注意这个方法，后续我们要重点跟进)
				Set scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getmetadata().getClassName());
				//循环处理我们包扫描出来的bean定义
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					//判断当前扫描出来的bean定义是不是一个配置类,若是的话 直接进行递归解析
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						//递归解析 因为@Component算是lite配置类
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// 处理 @import annotations
		processimports(configClass, sourceClass, getimports(sourceClass), true);

		// 处理 @importResource annotations
		AnnotationAttributes importResource =
				AnnotationConfigUtils.attributesFor(sourceClass.getmetadata(), importResource.class);
		if (importResource != null) {
			String[] resources = importResource.getStringArray("locations");
			Class readerClass = importResource.getClass("reader");
			for (String resource : resources) {
				String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
				configClass.addimportedResource(resolvedResource, readerClass);
			}
		}

		// 处理 @Bean methods 获取到我们配置类中所有标注了@Bean的方法
		Set beanMethods = retrieveBeanMethodmetadata(sourceClass);

		for (Methodmetadata methodmetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodmetadata, configClass));
		}

		// 处理配置类接口 默认方法的@Bean
		processInterfaces(configClass, sourceClass);

		// 处理配置类的父类的 ，循环再解析
		if (sourceClass.getmetadata().hasSuperClass()) {
			String superclass = sourceClass.getmetadata().getSuperClassName();
			if (superclass != null && !superclass.startsWith("java") &&
					!this.knownSuperclasses.containsKey(superclass)) {
				this.knownSuperclasses.put(superclass, configClass);
				// Superclass found, return its annotation metadata and recurse
				return sourceClass.getSuperClass();
			}
		}

		// 没有父类解析完成
		return null;
	}

继续跟进：this.componentScanParser.parse(componentScan,sourceClass.getmetadata().getClassName());

public Set parse(AnnotationAttributes componentScan, final String declaringClass) {
		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
				componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

		//为我们的扫描器设置beanName的生成器对象
		Class generatorClass = componentScan.getClass("nameGenerator");
		boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
		scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
				BeanUtils.instantiateClass(generatorClass));

		
		ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
		if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
			scanner.setScopedProxyMode(scopedProxyMode);
		}
		else {
			Class resolverClass = componentScan.getClass("scopeResolver");
			scanner.setScopemetadataResolver(BeanUtils.instantiateClass(resolverClass));
		}

		scanner.setResourcePattern(componentScan.getString("resourcePattern"));

		//设置CompentScan对象的includeFilters 包含的属性
		for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
			for (TypeFilter typeFilter : typeFiltersFor(filter)) {
				scanner.addIncludeFilter(typeFilter);
			}
		}
		//设置CompentScan对象的excludeFilters 包含的属性
		for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
			for (TypeFilter typeFilter : typeFiltersFor(filter)) {
				scanner.addExcludeFilter(typeFilter);
			}
		}

		
		boolean lazyInit = componentScan.getBoolean("lazyInit");
		if (lazyInit) {
			scanner.getBeanDefinitionDefaults().setLazyInit(true);
		}

		//包路径com.my.demo
		Set basePackages = new linkedHashSet<>();
		String[] basePackagesArray = componentScan.getStringArray("basePackages");
		for (String pkg : basePackagesArray) {
			String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
					ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
			Collections.addAll(basePackages, tokenized);
		}
		for (Class clazz : componentScan.getClassArray("basePackageClasses")) {
			basePackages.add(ClassUtils.getPackageName(clazz));
		}
		if (basePackages.isEmpty()) {
			basePackages.add(ClassUtils.getPackageName(declaringClass));
		}

		scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
			@Override
			protected boolean matchClassName(String className) {
				return declaringClass.equals(className);
			}
		});
		//真正的进行扫描解析  //todo:(注意这个方法，后续我们要重点跟进)
		return scanner.doScan(StringUtils.toStringArray(basePackages));
	}

在这个方法里，我们看到它根据注解，获取到了我们需要扫描的包。接着在scanner.doScan(StringUtils.toStringArray(basePackages));去扫描去了。
所以继续跟进scanner.doScan方法：

	protected Set doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		//创建bean定义的holder对象用于保存扫描后生成的bean定义对象
		Set beanDefinitions = new linkedHashSet<>();
		//循环我们的包路径集合
		for (String basePackage : basePackages) {
			//找到候选的Components  //todo:(注意这个方法，后续我们要重点跟进)
			Set candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {

				Scopemetadata scopemetadata = this.scopemetadataResolver.resolveScopemetadata(candidate);
				candidate.setScope(scopemetadata.getScopeName());
				//设置我们的beanName
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				//这是默认配置 autowire-candidate
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				//获取@Lazy @DependsOn等注解的数据设置到BeanDefinition中
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				//把我们解析出来的组件bean定义注册到我们的IOC容器中（容器中没有才注册）
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopemetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

Set candidates = findCandidateComponents(basePackage);
继续跟进findCandidateComponents方法

	
	public Set findCandidateComponents(String basePackage) {
		if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
			return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
		}
		else {
		   //todo:(注意这个方法，后续我们要重点跟进)
			return scanCandidateComponents(basePackage);
		}
	}

继续跟进 scanCandidateComponents(basePackage);

private Set scanCandidateComponents(String basePackage) {
		Set candidates = new linkedHashSet<>();
		try {
			 //把传进来的类似 命名空间形式的字符串转换成类似类文件地址的形式，然后在前面加上classpath*: 
			 //即：com.xx=>classpath*:com/xx*.class
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolvebasePackage(basePackage) + '/' + this.resourcePattern;
			//扫描指定包路径下面的所有.class文件
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
			//需要我们的resources集合
			for (Resource resource : resources) {
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
				//判断当的是不是可读的
				if (resource.isReadable()) {
					try {
						metadataReader metadataReader = getmetadataReaderFactory().getmetadataReader(resource);
						//是不是候选的组件
						if (isCandidateComponent(metadataReader)) {
							//包装成为一个ScannedGenericBeanDefinition
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							//并且设置class资源
							sbd.setResource(resource);
							sbd.setSource(resource);
							if (isCandidateComponent(sbd)) {
								if (debugEnabled) {
									logger.debug("Identified candidate component class: " + resource);
								}
								//加入到集合中
								candidates.add(sbd);
							}
							else {
								if (debugEnabled) {
									logger.debug("Ignored because not a concrete top-level class: " + resource);
								}
							}
						}
						else {
							if (traceEnabled) {
								logger.trace("Ignored because not matching any filter: " + resource);
							}
						}
					}
					catch (Throwable ex) {
						throw new BeanDefinitionStoreException(
								"Failed to read candidate component class: " + resource, ex);
					}
				}
				else {
					if (traceEnabled) {
						logger.trace("Ignored because not readable: " + resource);
					}
				}
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		//返回
		return candidates;
	}

在此方法中，把要扫描的包"com.my.demo"转换成了路径，
然后去根据路径地址读取包的资源，循环扫描获得符合要求的文件。最终会把符合要求的文件，转换为BeanDefinition，并且返回。 （在这里终于扫描我们自己项目定义的类了）

至此 我们把思绪调回到 doProcessConfigurationClass 方法中

还记得我们跟进了好多步，其实是在doProcessConfigurationClass方法中从parse方法一路跟下来的，就是为了看一下，我们自己定义的类是怎么被扫描，然后被解析成为bean定义的。回忆一下就是doProcessConfigurationClass中的这个方法。

//把我们扫描出来的类变为bean定义的集合 真正的解析  
Set scannedBeanDefinitions = this.componentScanParser.parse(componentScan,sourceClass.getmetadata().getClassName());

parse方法看完，接下来我们跟进 doProcessConfigurationClass方法中的：processimports方法
该方法，会把我们有@import注解的类，完成bean定义
// 处理 @import annotations
processimports(configClass, sourceClass, getimports(sourceClass), true);

在private void processimports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection importCandidates, 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) {
					//判断该组件是不是实现了importSelector的
					if (candidate.isAssignable(importSelector.class)) {
						// Candidate class is an importSelector -> delegate to it to determine imports
						Class candidateClass = candidate.loadClass();
						//实例化我们的Selectimport组件
						importSelector selector = BeanUtils.instantiateClass(candidateClass, importSelector.class);
						//调用相关的aware方法
						ParserStrategyUtils.invokeAwareMethods(
								selector, this.environment, this.resourceLoader, this.registry);
						//判断是不是延时的DeferredimportSelectors，是这个类型 不进行处理
						if (this.deferredimportSelectors != null && selector instanceof DeferredimportSelector) {
							this.deferredimportSelectors.add(
									new DeferredimportSelectorHolder(configClass, (DeferredimportSelector) selector));
						}
						else {//不是延时的
							//调用selector的selectimports
							String[] importClassNames = selector.selectimports(currentSourceClass.getmetadata());
							// 所以递归解析-- 直到成普通组件
							Collection importSourceClasses = asSourceClasses(importClassNames);
							processimports(configClass, currentSourceClass, importSourceClasses, false);
						}
					}
					//判断我们导入的组件是不是importBeanDefinitionRegistrar，这里不直接调用，只是解析
					else if (candidate.isAssignable(importBeanDefinitionRegistrar.class)) {
						// Candidate class is an importBeanDefinitionRegistrar ->
						// delegate to it to register additional bean definitions
						Class candidateClass = candidate.loadClass();
						//实例话我们的importBeanDefinitionRegistrar对象
						importBeanDefinitionRegistrar registrar =
								BeanUtils.instantiateClass(candidateClass, importBeanDefinitionRegistrar.class);
						ParserStrategyUtils.invokeAwareMethods(
								registrar, this.environment, this.resourceLoader, this.registry);
						//保存我们的importBeanDefinitionRegistrar对象 currentSourceClass=所在配置类
						configClass.addimportBeanDefinitionRegistrar(registrar, currentSourceClass.getmetadata());
					}
					else {
						// 当做配置类再解析，注意这里会标记：importedBy，  表示这是import的配置的类
						// 再执行之前的processConfigurationClass()方法 ，
						this.importStack.registerimport(
								currentSourceClass.getmetadata(), candidate.getmetadata().getClassName());
						processConfigurationClass(candidate.asConfigClass(configClass));
					}
				}
			}
			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();
			}
		}
	}

至此我们把焦点再返回到refresh() 方法里。当时我们就是在refresh()方法中
invokeBeanFactoryPostProcessors(beanFactory);一步步跟到 doProcessConfigurationClass的，它去完成class扫描成beanDefinition

接下来 我们看spring是怎么把bean定义转换成 实例bean的
在refresh方法中的 finishBeanFactoryInitialization(beanFactory)：

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 为我们的bean工厂创建类型转化器  Convert
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// 处理关于aspectj
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		//冻结所有的 bean 定义 ， 说明注册的 bean 定义将不被修改或任何进一步的处理
		beanFactory.freezeConfiguration();

		//实例化剩余的单实例bean   //todo:(注意这个方法，后续我们要重点跟进)
		beanFactory.preInstantiateSingletons();
	}

继续跟进 preInstantiateSingletons方法

public void preInstantiateSingletons() throws BeansException {
		if (logger.isDebugEnabled()) {
			logger.debug("Pre-instantiating singletons in " + this);
		}

		//获取我们容器中所有bean定义的名称
		List beanNames = new ArrayList<>(this.beanDefinitionNames);

		//循环我们所有的bean定义名称
		for (String beanName : beanNames) {
			//合并我们的bean定义，转换为统一的RootBeanDefinition类型(在)， 方便后续处理
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				//是不是工厂bean
				if (isFactoryBean(beanName)) {
					// 是factoryBean会先生成实际的bean  &beanName 是用来获取实际bean的
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean factory = (FactoryBean) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction)
											((SmartFactoryBean) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean) factory).isEagerInit());
						}
						//调用真正的getBean的流程
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {//非工厂Bean 就是普通的bean
					getBean(beanName);
				}
			}
		}

		//或有的bean的名称 ...........到这里所有的单实例的bean已经记载到单实例bean到缓存中
		for (String beanName : beanNames) {
			//从单例缓存池中获取所有的对象
			Object singletonInstance = getSingleton(beanName);
			//判断当前的bean是否实现了SmartInitializingSingleton接口
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction