一文搞懂Spring执行流程

要想搞清楚Spring的执行逻辑我们必须明白在Spring的IOC容器中执行的12步都在干什么。

@Override  //容器刷新的十二大步。模板模式
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

		//准备上下文环境 Prepare this context for refreshing.
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		// 工厂创建：BeanFactory第一次开始创建的时候,有xml解析逻辑。
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		//给容器中注册了环境信息作为单实例Bean方便后续自动装配；放了一些后置处理器处理（监听、xxAware功能） Prepare the bean factory for use in this context.
		prepareBeanFactory(beanFactory);

		try {
			//留给子类的模板方法，允许子类继续对工厂执行一些处理； Allows post-processing of the bean factory in context subclasses.
			postProcessBeanFactory(beanFactory);

			StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
			//【大核心】工厂增强：执行所有的BeanFactory后置增强器；利用BeanFactory后置增强器对工厂进行修改或者增强,配置类会在这里进行解析。 Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory);

			//【核心】注册所有的Bean的后置处理器 Register bean processors that intercept bean creation.
			registerBeanPostProcessors(beanFactory);
			beanPostProcess.end();

			//初始化国际化功能 Initialize message source for this context.
			initMessageSource();

			//初始化事件多播功能（事件派发） Initialize event multicaster for this context.
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			onRefresh();

			//注册监听器，从容器中获取所有的ApplicationListener； Check for listener beans and register them.
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			//【大核心】bean创建；完成 BeanFactory 初始化。（工厂里面所有的组件都好了）
			finishBeanFactoryInitialization(beanFactory);

			//发布事件 Last step: publish corresponding event.
			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...
			resetCommonCaches();
			contextRefresh.end();
		}
	}
}

下面我们就来一个一个说明。

一、准备上下文环境

1、保存环境变量信息

// 准备上下文环境
prepareRefresh();

protected void prepareRefresh() {
	// 修改容器状态为执行状态Switch to active.
	this.startupDate = System.currentTimeMillis();
	this.closed.set(false);
	this.active.set(true);

	// 其他子容器自行实现（比如：WebApplicationContext） Initialize any placeholder property sources in the context environment.
	// 这个方法是可以让子类去实现的，每个容器类都会维护一个environment属性，这个属性里面就存储了环境变量的信息，子实现类可以自由重写这个方法来添加属性
	initPropertySources();

	//准备环境变量信息 Validate that all properties marked as required are resolvable:
	// see ConfigurablePropertyResolver#setRequiredProperties
	// 将环境变量信息添加到属性environment中
	getEnvironment().validateRequiredProperties();

	// 存储子容器早期运行的一些监听器； Store pre-refresh ApplicationListeners...
	if (this.earlyApplicationListeners == null) {
		this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
	}
	else {
		// Reset local application listeners to pre-refresh state.
		this.applicationListeners.clear();
		this.applicationListeners.addAll(this.earlyApplicationListeners);
	}

	//早期的一些时间存储到这里 Allow for the collection of early ApplicationEvents,
	// to be published once the multicaster is available...
	this.earlyApplicationEvents = new LinkedHashSet<>();
}

这个步骤相对简单，只是准备一些环境变量添加到容器中。

二、工厂创建

1、创建BeanFactory

// 工厂创建：BeanFactory第一次开始创建的时候,有xml解析逻辑。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	//刷新整个BeanFactory,注解模式下就是准备工厂，设置工厂id；xml模式下会解析xml
	refreshBeanFactory(); 
	return getBeanFactory();
}

@Override
protected final void refreshBeanFactory() throws BeansException {
	// 如果已经创建工厂了就销毁
	if (hasBeanFactory()) {
		destroyBeans();
		closeBeanFactory();
	}
	/** 
		创建Bean工厂DefaultListableBeanFactory
	    这个DefaultListableBeanFactory类很有意思
	    	它实现了SingletonBeanRegistry接口代表它是一个单例池，保存所有单例对象
	    	它实现了BeanFactory接口的子接口ListableBeanFactory代表它能根据名称或类型获取BeanDefinition或Bean
	    	它实现了BeanDefinitionRegistry接口代表它是一个档案馆，可以获取BeanDefinition
	*/
	DefaultListableBeanFactory beanFactory = createBeanFactory(); 
	// 设置序列化ID
	beanFactory.setSerializationId(getId());
	// 可以设置是否允许循环依赖等，作用不大
	customizeBeanFactory(beanFactory);
	// 加载BeanDefinitions
	loadBeanDefinitions(beanFactory);
	// 保存IOC容器
	this.beanFactory = beanFactory;
}

// 创建DefaultListableBeanFactory
protected DefaultListableBeanFactory createBeanFactory() {
	return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

2、加载BeanDefinition

// 加载BeanDefinitions
loadBeanDefinitions(beanFactory);

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// 创建BeanDefinitionReader准备读取xml内容的读取器 Create a new XmlBeanDefinitionReader for the given BeanFactory. 
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

	// Configure the bean definition reader with this context's
	// resource loading environment.
	// 将环境信息保存到IOC容器中
	beanDefinitionReader.setEnvironment(this.getEnvironment());
	// 将IOC容器当作资源加载器传入Reader中准备读取XML文件
	beanDefinitionReader.setResourceLoader(this); 	
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

	// Allow a subclass to provide custom initialization of the reader,
	// then proceed with actually loading the bean definitions.
	// 初始化BeanDefinitionReader，主要目的是让子类可以重写来实现自定义Reader的效果
	initBeanDefinitionReader(beanDefinitionReader);
	// 真正的加载loadBeanDefinition
	loadBeanDefinitions(beanDefinitionReader);
}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
	// 以Resource的格式获取资源，这里默认的getConfigResources()方法默认返回null，留给子类去实现来设置资源位置
	Resource[] configResources = getConfigResources();
	if (configResources != null) {
		reader.loadBeanDefinitions(configResources);
	}
	// 这里的configLocations就是我们传进去的配置文件的路径和名称，可以一次传入很多配置文件
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		// 读取配置文件并加载BeanDefinition
		reader.loadBeanDefinitions(configLocations); 
	}
}

@Override
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
	Assert.notNull(locations, "Location array must not be null");
	int count = 0;
	for (String location : locations) { 
		// 加载每一个配置文件里面的内容
		count += loadBeanDefinitions(location);
	}
	return count;
}

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
	// 就是IOC容器
	ResourceLoader resourceLoader = getResourceLoader();

	if (resourceLoader instanceof ResourcePatternResolver) {
		// Resource pattern matching available.
		// 一般情况下走这里
		// 将xml资源转换为Resource类
		Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
		// 加载资源为BeanDefinition的地方
		int count = loadBeanDefinitions(resources);
		return count;
	}
	else {
		// Can only load single resources by absolute URL.
		// 根据URL加载资源的Loader走这里
		Resource resource = resourceLoader.getResource(location);
		int count = loadBeanDefinitions(resource);
		return count;
	}
}

@Override
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
	Assert.notNull(resources, "Resource array must not be null");
	int count = 0;
	for (Resource resource : resources) {
		// 遍历加载每一个BeanDefinition
		count += loadBeanDefinitions(resource);
	}
	return count;
}

@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
	// 装饰器模式装饰了一下资源
	return loadBeanDefinitions(new EncodedResource(resource));
}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	// 获取ThreadLocal中的资源Set
	Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
	// 将传入的资源添加到Set中
	if (!currentResources.add(encodedResource)) {
		throw new BeanDefinitionStoreException(
				"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
	}

	try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
		InputSource inputSource = new InputSource(inputStream);
		if (encodedResource.getEncoding() != null) {
			inputSource.setEncoding(encodedResource.getEncoding());
		}
		// 处理资源
		return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
	} 
	finally {
		// 处理完后从Set中移除这个资源
		currentResources.remove(encodedResource);
		if (currentResources.isEmpty()) {
			this.resourcesCurrentlyBeingLoaded.remove();
		}
	}
}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
	//利用dom解析工具把xml变成Document
	Document doc = doLoadDocument(inputSource, resource); 
	// 注册BeanDefinitions到容器中
	int count = registerBeanDefinitions(doc, resource);
	return count;
}

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	// 创建Document解析器来解析document对象
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	// 获取IOC容器中BeanDefinitionMap的size()
	int countBefore = getRegistry().getBeanDefinitionCount();
	// 读取doc中的内容为BeanDefinition并保存到IOC容器的BeanDefinitionMap中，这里太深入就不看了，设计到DOM解析过程，知道大概就可以了
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
	return getRegistry().getBeanDefinitionCount() - countBefore;
}

至此所有BeanDefinition就都加载到IOC容器中了。工厂创建过程完成。

三、准备BeanFactory

// 给容器中注册了环境信息作为单实例Bean方便后续自动装配；放了一些后置处理器处理（监听、xxAware功能） Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// Tell the internal bean factory to use the context's class loader etc.
	// 设置Bean的类加载器
	beanFactory.setBeanClassLoader(getClassLoader());
	
	if (!shouldIgnoreSpel) { 
		// 解释器模式，配置解析${}的解析器
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	}
	
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// Configure the bean factory with context callbacks.
	// 添加XxxAware接口的执行器，这个执行器负责执行给Bean注入相应的Xxx
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	// 告诉Spring先别管这些接口，将这些类添加到HashSet集合中
	// 因为在ApplicationContextAwareProcessor中已经完成了手动注入
	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.ignoreDependencyInterface(ApplicationStartupAware.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 (!NativeDetector.inNativeImage() && 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());
	}
	if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
		beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
	}
}

这个步骤给BeanFactory做了一些简单处理，比如放置了一些后置处理器类并注入了一些基本单例对象。

四、BeanFactory处理

// 留给子类的模板方法，允许子类继续对工厂执行一些处理；父类没有提供任何方法 Allows post-processing of the bean factory in context subclasses.
// 在标准初始化之后修改应用程序上下文的内部 bean 工厂。所有 bean 定义都将被加载，但还没有 bean 被实例化。这允许在某些 ApplicationContext 实现中注册特殊的 BeanPostProcessors 等。
postProcessBeanFactory(beanFactory);

五、执行BeanFactory后置增强器

//【大核心】工厂增强：执行所有的BeanFactory后置增强器；利用BeanFactory后置增强器对工厂进行修改或者增强,配置类会在这里进行解析。 Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	// 执行所有的工厂增强器，主要逻辑在这里，目前getBeanFactoryPostProcessors()为null
	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 (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
}

public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
	// 创建Set集合保存所有处理器Bean
	Set<String> processedBeans = new HashSet<>();

	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		// 常规后置处理器
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		// 注册的后置处理器
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
		// 先拿到底层默认有的BeanFactoryPostProcessor，默认为null
		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.
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		// 首先：从工厂中获取所有的实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor； First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
		// 先获得实现了BeanDefinitionRegistryPostProcessor接口的后置处理器类的名称列表
		// 具体获得过程是拿到系统中每一个组件的BeanDefinition信息，进行类型对比，是否匹配指定的类型，如果匹配就添加到result(ArrayList类型)，最后再将result返回
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 从工厂中获取这个组件【getBean整个组件创建的流程】并放到这个集合
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		} 
		// 下面利用优先级排序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		// 执行这些BeanDefinitionRegistryPostProcessor的方法，会在下面介绍
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); 
		currentRegistryProcessors.clear();

		// 接下来，获取所有实现了Ordered接口的 BeanDefinitionRegistryPostProcessor Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			// 这里判断一下processedBeans中没有的防止重复执行
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName); //即使实现了 PriorityOrdered 和Ordered，也是以 PriorityOrdered
			}
		}//排序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); //执行
		currentRegistryProcessors.clear();

		// 最后，我们自定义的一般没有任何优先级和排序接口   Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);//拿到所有的BeanDefinitionRegistryPostProcessor
			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, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear(); //防止重复执行
		}

		// 接下来，再来执行实现BeanDefinitionRegistryPostPrecessor接口的postProcessBeanFactory方法，下面有介绍 Now, invoke the postProcessBeanFactory callback of all processors handled so far.
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}
	
	// 以前在执行 BeanDefinitionRegistryPostProcessor ,以后来执行 BeanFactoryPostProcessor
	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!
	// 获取所有实现BeanFactoryProcessor接口的类的定义信息的名字
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	// 在这里直接创建了三个列表分别存放实现PriorityOrdered、Ordered、没有实现任何接口的对象
	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);
		}
	}

	// 首先执行所有实现了 PriorityOrdered 的 BeanFactoryPostProcessor；First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// 接下来执行，实现了 Ordered 接口的 BeanFactoryPostProcessor  Next, invoke the BeanFactoryPostProcessors that implement Ordered.
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

	// 最后执行没有任何优先级和排序接口的 BeanFactoryPostProcessor Finally, invoke all other BeanFactoryPostProcessors.
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory); //执行所有的 BeanFactoryPostProcessor

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

private static void invokeBeanDefinitionRegistryPostProcessors(
		Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry, ApplicationStartup applicationStartup) {

	for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
		StartupStep postProcessBeanDefRegistry = applicationStartup.start("spring.context.beandef-registry.post-process")
				.tag("postProcessor", postProcessor::toString);
		// 核心，配置类的后置处理器会在此执行postProcessBeanDefinitionRegistry方法
		postProcessor.postProcessBeanDefinitionRegistry(registry); 
		postProcessBeanDefRegistry.end();
	}
}

private static void invokeBeanFactoryPostProcessors(
		Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {

	for (BeanFactoryPostProcessor postProcessor : postProcessors) {
		StartupStep postProcessBeanFactory = beanFactory.getApplicationStartup().start("spring.context.bean-factory.post-process")
				.tag("postProcessor", postProcessor::toString);
		postProcessor.postProcessBeanFactory(beanFactory);
		postProcessBeanFactory.end();
	}
}

这里是BeanDefinitionRegistryPostProcesser执行postProcessBeanDefinitionRegistry()、postProcessBeanFactory()方法和BeanFactoryPostProcesser执行postProcessBeanFactory()方法的地方，那么我们都知道上一步我们只是将Bean的定义信息添加到IOC容器中，那么我们是怎么将BeanFactory定义信息转换为对象来执行相应的方法呢？主要逻辑在下面这句话

nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

protected <T> T doGetBean(
		String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
		throws BeansException {

	String beanName = transformedBeanName(name); //转换Bean名字
	Object beanInstance;

	// 先检查单实例bean的缓存 Eagerly check singleton cache for manually registered singletons.
	Object sharedInstance = getSingleton(beanName); //检查缓存中有没有，如果是第一次获取肯定是没有的
	if (sharedInstance != null && args == null) {
		if (logger.isTraceEnabled()) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
						"' that is not fully initialized yet - a consequence of a circular reference");
			}
			else {
				logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
			}
		}
		beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}

	else { //默认第一次获取组件都会进入else环节
		// Fail if we're already creating this bean instance:
		// We're assumably within a circular reference.
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}

		// 拿到整个beanFactory的父工厂；看父工厂没有，从父工厂先尝试获取组件； Check if bean definition exists in this factory.
		BeanFactory parentBeanFactory = getParentBeanFactory();
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { //以下开始从父工厂获取组件
			// Not found -> check parent.
			String nameToLookup = originalBeanName(name);
			if (parentBeanFactory instanceof AbstractBeanFactory) {
				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
						nameToLookup, requiredType, args, typeCheckOnly);
			}
			else if (args != null) {
				// Delegation to parent with explicit args.
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else if (requiredType != null) {
				// No args -> delegate to standard getBean method.
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}

		if (!typeCheckOnly) {
			markBeanAsCreated(beanName); //标记当前beanName的bean已经被创建
		}

		StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
				.tag("beanName", name);
		try {
			if (requiredType != null) {
				beanCreation.tag("beanType", requiredType::toString);
			}
			RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);

			// Guarantee initialization of beans that the current bean depends on.
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) { //看当前Bean有没有依赖其他Bean
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					registerDependentBean(dep, beanName);
					try {
						getBean(dep); //依赖了其他bean，就先获取其他的哪些bean
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}

			// 创建bean的实例；Create bean instance.
			if (mbd.isSingleton()) {
				sharedInstance = getSingleton(beanName, () -> {
					try {
						return createBean(beanName, mbd, args);  //创建bean对象的实例
					}
					catch (BeansException ex) {
						// Explicitly remove instance from singleton cache: It might have been put there
						// eagerly by the creation process, to allow for circular reference resolution.
						// Also remove any beans that received a temporary reference to the bean.
						destroySingleton(beanName);
						throw ex;
					}
				}); //看当前bean是否是FactoryBean
				beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}

			else if (mbd.isPrototype()) {
				// It's a prototype -> create a new instance.
				Object prototypeInstance = null;
				try {
					beforePrototypeCreation(beanName);
					prototypeInstance = createBean(beanName, mbd, args);
				}
				finally {
					afterPrototypeCreation(beanName);
				}
				beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}

			else {
				String scopeName = mbd.getScope();
				if (!StringUtils.hasLength(scopeName)) {
					throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
				}
				Scope scope = this.scopes.get(scopeName);
				if (scope == null) {
					throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
				}
				try {
					Object scopedInstance = scope.get(beanName, () -> {
						beforePrototypeCreation(beanName);
						try {
							return createBean(beanName, mbd, args);
						}
						finally {
							afterPrototypeCreation(beanName);
						}
					});
					beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
				}
				catch (IllegalStateException ex) {
					throw new ScopeNotActiveException(beanName, scopeName, ex);
				}
			}
		}
		catch (BeansException ex) {
			beanCreation.tag("exception", ex.getClass().toString());
			beanCreation.tag("message", String.valueOf(ex.getMessage()));
			cleanupAfterBeanCreationFailure(beanName);
			throw ex;
		}
		finally {
			beanCreation.end();
		}
	}
	//转Object为Bean的T类型
	return adaptBeanInstance(name, beanInstance, requiredType);
}

创建对象的逻辑在后面会涉及到，这里就不作展开了。

六、执行Bean后置增强器

//【核心】注册所有的Bean的后置处理器 Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	// 主要方法在这里执行
	PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

public static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

	// WARNING: Although it may appear that the body of this method can be easily
	// refactored to avoid the use of multiple loops and multiple lists, the use
	// of multiple lists and multiple passes over the names of processors is
	// intentional. We must ensure that we honor the contracts for PriorityOrdered
	// and Ordered processors. Specifically, we must NOT cause processors to be
	// instantiated (via getBean() invocations) or registered in the ApplicationContext
	// in the wrong order.
	//
	// Before submitting a pull request (PR) to change this method, please review the
	// list of all declined PRs involving changes to PostProcessorRegistrationDelegate
	// to ensure that your proposal does not result in a breaking change:
	// https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22
	// 获取到容器中所有的 BeanPostProcessor； Bean的后置处理器
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	// Register BeanPostProcessorChecker that logs an info message when
	// a bean is created during BeanPostProcessor instantiation, i.e. when
	// a bean is not eligible for getting processed by all BeanPostProcessors.
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	// Separate between BeanPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	for (String ppName : postProcessorNames) {
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {  
			// 获取所有实现了 PriorityOrdered 的 BeanPostProcessor
			// 从容器中获取组件，如果没有就创建，创建过程中也可能执行Bean后置处理器
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			priorityOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	// 首先，注册所有的实现了 PriorityOrdered 的 BeanPostProcessor ；就是添加到列表中，优先级越高越添加到前面  First, register the BeanPostProcessors that implement PriorityOrdered.
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	// 接下来，注册所有的实现了 Ordered 的 BeanPostProcessor  Next, register the BeanPostProcessors that implement Ordered.
	List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
	for (String ppName : orderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); //获取后置处理器对象
		orderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, orderedPostProcessors);

	// 最后，注册所有普通的 BeanPostProcessor ；Now, register all regular BeanPostProcessors.
	List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String ppName : nonOrderedPostProcessorNames) {
		// 从容器中获取这个组件
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); 
		nonOrderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

	//最后，重新注册所有internal的BeanPostProcessors  Finally, re-register all internal BeanPostProcessors.
	sortPostProcessors(internalPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, internalPostProcessors);

	// 重新注册一下这个后置处理器 Re-register post-processor for detecting inner beans as ApplicationListeners,
	// 把他放到后置处理器的最后一位； moving it to the end of the processor chain (for picking up proxies etc).
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

七、初始化国际化功能

//初始化事件多播功能（事件派发） Initialize event multicaster for this context.
initApplicationEventMulticaster();

一般情况下用不到。这里不介绍了。

八、初始化事件多播功能（事件派发）

//8初始化事件多播功能（事件派发） Initialize event multicaster for this context.
initApplicationEventMulticaster();

九、初始化特殊Bean

// 初始化特殊Bean
onRefresh();

// 可以重写以添加特定于上下文的刷新工作的模板方法。在单例实例化之前调用特殊 bean 的初始化。这里父类没有给出具体实现，由子类去完成。
protected void onRefresh() throws BeansException {
	// For subclasses: do nothing by default. 模板模式的实现
}

十、注册监听器

//注册监听器，从容器中获取所有的ApplicationListener； Check for listener beans and register them.
registerListeners();

protected void registerListeners() {
	//把所有监听器保存到多播器的集合中，初始为null Register statically specified listeners first.
	for (ApplicationListener<?> listener : getApplicationListeners()) {
		getApplicationEventMulticaster().addApplicationListener(listener);
	}

	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// 获取ApplicationListener在ioc容器中注册的bean的名字 uninitialized to let post-processors apply to them!
	String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
	for (String listenerBeanName : listenerBeanNames) {
		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); //获取所有的容器中的监听器，并保存他们的名字
	}

	//派发之前攒的一些早期事件 Publish early application events now that we finally have a multicaster...
	Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
	this.earlyApplicationEvents = null;
	if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
		for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
			getApplicationEventMulticaster().multicastEvent(earlyEvent);
		}
	}
}

十一、初始化Bean

// Instantiate all remaining (non-lazy-init) singletons.
//【大核心】bean创建；完成 BeanFactory 初始化。（工厂里面所有的组件都好了）
finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// 给工厂设置好 ConversionService【负责类型转换的组件服务】， Initialize conversion service for this context.
	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));
	}

	// 注册一个默认的值解析器（"${}"）  ；Register a default embedded value resolver if no BeanFactoryPostProcessor
	// (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
	// at this point, primarily for resolution in annotation attribute values.
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// LoadTimeWeaverAware；aspectj：加载时织入功能【aop】。 Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
	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);

	// Allow for caching all bean definition metadata, not expecting further changes.
	beanFactory.freezeConfiguration();

	// Instantiate all remaining (non-lazy-init) singletons.
	// 初始化所有的非懒加载的单实例Bean，核心在这里
	beanFactory.preInstantiateSingletons();
}

@Override
public void preInstantiateSingletons() throws BeansException {
	if (logger.isTraceEnabled()) {
		logger.trace("Pre-instantiating singletons in " + this);
	}

	// Iterate over a copy to allow for init methods which in turn register new bean definitions.
	// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
	// 获取所有BeanNames
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// 遍历并创建出所有的单实例Bean；Trigger initialization of all non-lazy singleton beans...
	for (String beanName : beanNames) {
		// 开始解析文件的时候每一个bean标签被解析封装成一个BeanDefinition
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); 
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 如果是FactoryBean则执行下面逻辑
			if (isFactoryBean(beanName)) { 
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); //得到HelloFactory
				if (bean instanceof FactoryBean) {
					FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(
								(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			// 不是FactoryBean则执行这个,普通的单实例非懒加载bean的创建，下面会介绍getBean方法
			else { 
				getBean(beanName);
			}
		}
	}

	// 触发 post-initialization 逻辑；  Trigger post-initialization callback for all applicable beans...
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
					.tag("beanName", beanName);
			SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			}
			else {
				smartSingleton.afterSingletonsInstantiated();
			}
			smartInitialize.end();
		}
	}
}

@Override
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(
		String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
		throws BeansException {

	String beanName = transformedBeanName(name); //转换Bean名字
	Object beanInstance;

	// 先检查单实例bean的缓存一级、二级、三级缓存 Eagerly check singleton cache for manually registered singletons.
	Object sharedInstance = getSingleton(beanName); //检查缓存中有没有，如果是第一次获取肯定是没有的
	if (sharedInstance != null && args == null) {
		if (logger.isTraceEnabled()) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
						"' that is not fully initialized yet - a consequence of a circular reference");
			}
			else {
				logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
			}
		}
		beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}

	else { 
		//默认第一次获取组件都会进入else环节
		// Fail if we're already creating this bean instance:
		// We're assumably within a circular reference.
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}

		// 拿到整个beanFactory的父工厂；看父工厂没有，从父工厂先尝试获取组件； Check if bean definition exists in this factory.
		BeanFactory parentBeanFactory = getParentBeanFactory();
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 
			//以下开始从父工厂获取组件
			// Not found -> check parent.
			String nameToLookup = originalBeanName(name);
			if (parentBeanFactory instanceof AbstractBeanFactory) {
				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
						nameToLookup, requiredType, args, typeCheckOnly);
			}
			else if (args != null) {
				// Delegation to parent with explicit args.
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else if (requiredType != null) {
				// No args -> delegate to standard getBean method.
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}

		if (!typeCheckOnly) {
			// 标记当前beanName的bean已经被创建
			markBeanAsCreated(beanName); 
		}
		
		try {
			// 获取bean定义信息
			RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);

			// Guarantee initialization of beans that the current bean depends on.
			// 获取当前定义信息所依赖的定义信息，先将依赖的Bean加载
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) { 
					registerDependentBean(dep, beanName);
					//依赖了其他bean，就先获取其他的哪些bean
					getBean(dep); 
				}
			}

			// 创建bean的实例；Create bean instance.
			if (mbd.isSingleton()) {
				// 核心方法是getSingleton
				sharedInstance = getSingleton(beanName, () -> {
					try {
						return createBean(beanName, mbd, args);  //创建bean对象的实例
					}
				}); //看当前bean是否是FactoryBean
				beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}
			
			// 创建多例Bean的实例
			else if (mbd.isPrototype()) {
				// It's a prototype -> create a new instance.
				Object prototypeInstance = null;
				try {
					beforePrototypeCreation(beanName);
					prototypeInstance = createBean(beanName, mbd, args);
				}
				finally {
					afterPrototypeCreation(beanName);
				}
				beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}
			// 如果是其他作用域就调用其他作用域的方法
			else {
				String scopeName = mbd.getScope();
				Scope scope = this.scopes.get(scopeName);
				try {
					Object scopedInstance = scope.get(beanName, () -> {
						beforePrototypeCreation(beanName);
						try {
							return createBean(beanName, mbd, args);
						}
						finally {
							afterPrototypeCreation(beanName);
						}
					});
					beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
				}
			}
		}
		finally {
			beanCreation.end();
		}
	}
	//转Object为Bean的T类型
	return adaptBeanInstance(name, beanInstance, requiredType);
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	synchronized (this.singletonObjects) {
		// 先从单例池中获取
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null) { 
			// 单实例池子里面没有当前对象（说明没有创建完成）
			// 单实例创建之前，没什么作用，让子类去重写的模板方法
			beforeSingletonCreation(beanName);
			boolean newSingleton = false;
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet<>();
			}
			try {
				// 会调用lamda表达式的内容，真正创建对象，核心在这里
				singletonObject = singletonFactory.getObject();
				newSingleton = true;
			}
			finally {
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = null;
				}
				afterSingletonCreation(beanName);
			}
			if (newSingleton) {
				// 添加到单例池中
				addSingleton(beanName, singletonObject);
			}
		}
		return singletonObject;
	}
}

sharedInstance = getSingleton(beanName, () -> {
	try {
		return createBean(beanName, mbd, args);  //创建bean对象的实例
	}
}); 

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {
		
	RootBeanDefinition mbdToUse = mbd;

	// Make sure bean class is actually resolved at this point, and
	// clone the bean definition in case of a dynamically resolved Class
	// which cannot be stored in the shared merged bean definition.
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}

	// Prepare method overrides.
	// 准备方法覆盖
	try {
		mbdToUse.prepareMethodOverrides();
	}

	try {
		//（即使AOP的BeanPostProcessor都不会珍惜这个机会） 提前给我们一个机会，去返回组件的代理对象。 Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
		// 如果有实现了InstantiationAwareBeanPostProcessor接口的类就会去执行，返回这个类中一个方法返回的对象替换Bean。
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}

	try { 
		// Spring真正自己创建对象，核心方法
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		return beanInstance;
	}
}

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {

	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) { 
		// 从缓存中移除这个单例对象
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		// 创建Bean的实例,默认使用无参构造器创建的对象，组件的原始对象就创建了
		// 在这里SmartInstantiationAwareBeanPostProcessor起作用了，可以决定使用哪个构造器
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	Object bean = instanceWrapper.getWrappedInstance();
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	// 允许 后置处理器 再来修改下beanDefinition；
	// 这里到 MergedBeanDefinitionPostProcessor起作用了  MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition；；   Allow post-processors to modify the merged bean definition.
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			mbd.postProcessed = true;
		}
	}

	// 提前暴露单实例。专门来解决循环引用问题；Eagerly cache singletons to be able to resolve circular references
	// even when triggered by lifecycle interfaces like BeanFactoryAware.
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		//三级缓存中的Bean也会被后置处理来增强，
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 
	}

	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
		// 给创建好的对象每个属性进行赋值，@Autowired发生在这里
		// 在这里InstantiationAwareBeanPostProcessor起作用了，
		// 这里先调用Processor的postProcessAfterInstantiation方法
		// 之后赋值根据XML指定的，再之后就是Processor的postProcessProperties方法给属性自动注入赋值
		populateBean(beanName, mbd, instanceWrapper); 
		// 初始化bean，在这里如果组件实现了XxxAware接口就会向里面注入值
		// 之后会执行BeanPostProcessor的postProcessBeforeInitialization方法
		// 之后会执行Bean的初始化方法afterPropertiesSet（如果实现了InitializingBean接口）
		// 最后会执行BeanPostProcessor的postProcessAfterInitialization方法
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	//早期单实例暴露
	if (earlySingletonExposure) {
		// 检查早期缓存中是否存在这个组件
		Object earlySingletonReference = getSingleton(beanName, false); 
		if (earlySingletonReference != null) {
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				for (String dependentBean : dependentBeans) {
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}
			}
		}
	}

	// Register bean as disposable.
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	// 返回这个实例，对象创建过程至此完毕
	return exposedObject;
}

十二、发布事件

//12发布事件 Last step: publish corresponding event.
finishRefresh();

protected void finishRefresh() {
	// Clear context-level resource caches (such as ASM metadata from scanning).
	clearResourceCaches();

	// Initialize lifecycle processor for this context.
	initLifecycleProcessor();

	//告诉LifecycleProcessor容器onRefresh Propagate refresh to lifecycle processor first.
	getLifecycleProcessor().onRefresh();

	//发布事件 Publish the final event.
	publishEvent(new ContextRefreshedEvent(this)); //发布上下文环境刷新完成的事件

	//jconsole（暴露MBean端点信息） Participate in LiveBeansView MBean, if active.
	if (!NativeDetector.inNativeImage()) {
		LiveBeansView.registerApplicationContext(this);
	}
}

其他问题

1、循环依赖的解决

spring解决循环依赖是通过缓存来实现的，我们假定类A与类B相互依赖，当容器给类A创建单例对象时首先根据默认无参构造器创建出来一个对象，这时候将这个对象a添加到缓存中，之后给a的属性赋值，赋值过程通过后置处理器来完成，其中给a的属性b赋值时也调用beanFactory.getBean(b)方法，之后也会利用无参构造器创建出来一个对象b，这时候将对象b添加到缓存中，之后给b的属性赋值，其中给属性a赋值时也会调用beanFactory.getBean(a)方法，这时候获取对象a时首先判断缓存中有没有，显然之前已经添加到缓存中了，所以我们可以直接获取对象a，这样就解决了循环依赖问题。

2、AOP功能的实现

实现AOP功能重要的是要在配置类上加入@EnableAspectJAutoProxy注解，之后在增强功能类上添加@Aspect注解代表这是一个切面，之后在切面中编写增强逻辑。代码如下：

@EnableAspectJAutoProxy //开启自动代理
@Configuration
public class AopOpenConfig {
	
}

@Component  //切面也是容器中的组件
@Aspect //说明这是切面
public class LogAspect {

	public LogAspect(){
		System.out.println("LogAspect...");
	}

	//前置通知  增强方法/增强器
	@Before("execution(* com.atguigu.spring.aop.HelloService.sayHello(..))")
	public void logStart(JoinPoint joinPoint){
		String name = joinPoint.getSignature().getName();
		System.out.println("logStart()==>"+name+"....【args: "+ Arrays.asList(joinPoint.getArgs()) +"】");
	}

	//返回通知
	@AfterReturning(value = "execution(* com.atguigu.spring.aop.HelloService.sayHello(..))",returning = "result")
	public void logReturn(JoinPoint joinPoint,Object result){
		String name = joinPoint.getSignature().getName();
		System.out.println("logReturn()==>"+name+"....【args: "+ Arrays.asList(joinPoint.getArgs()) +"】【result: "+result+"】");
	}


	//后置通知
	@After("execution(* com.atguigu.spring.aop.HelloService.sayHello(..))")
	public void logEnd(JoinPoint joinPoint){
		String name = joinPoint.getSignature().getName();
		System.out.println("logEnd()==>"+name+"....【args: "+ Arrays.asList(joinPoint.getArgs()) +"】");
	}


	//异常
	@AfterThrowing(value = "execution(* com.atguigu.spring.aop.HelloService.sayHello(..))",throwing = "e")
	public void logError(JoinPoint joinPoint,Exception e){
		String name = joinPoint.getSignature().getName();
		System.out.println("logError()==>"+name+"....【args: "+ Arrays.asList(joinPoint.getArgs()) +"】【exception: "+e+"】");
	}
}

那么为什么我们在配置类中添加@EnableAspectJAutoProxy注解就开始了AOP功能呢，我们先看一下这个注解的组成

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {}

其中最重要的是我们向容器中添加了org.springframework.aop.config.InternalAutoProxyCreator类型（是一个BeanPostProcesser）的beanDefinition。这个添加过程是容器十二大步之工厂增强阶段解析配置类时添加的。