【Spring】IOC容器的创建过程

重点部分标注有"重点！！！"

使用AnnotationConfigApplicationContext

//会执行构造函数
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
UserService userService = ctx.getBean("userService", UserService.class)
ctx.close();

AnnotationConfigApplicationContext的构造函数

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
	/**
	 * Create a new AnnotationConfigApplicationContext, deriving bean definitions
	 * from the given annotated classes and automatically refreshing the context.
	 * 创建一个新的AnnotationConfigApplicationContext，派生bean定义
	 * 从给定的带注释的类中自动刷新上下文。
	 *
	 * @param annotatedClasses one or more annotated classes,
	 *                         e.g. {@link Configuration @Configuration} classes
	 */
	public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		//构造read和scan
		this();
		//将用户类注册进去
		register(annotatedClasses);
		//最为核心的方法，整个Spring的加载流程
		refresh();
	}
}

Spring-IOC容器创建(刷新)过程

即org.springframework.context.support.AbstractApplicationContext#refresh

一、prepareRefresh();

prepareRefresh()
	this.startupDate = System.currentTimeMillis();
	this.closed.set(false);
	this.active.set(true);
	// Initialize any placeholder property sources in the context environment.
	// 初始化上下文环境中的占位符属性源
	initPropertySources();
	// 交给子类去实现，默认啥也不做
	getEnvironment().validateRequiredProperties();
	this.earlyApplicationEvents = new LinkedHashSet<>();

二、obtainFreshBeanFactory();

// Tell the subclass to refresh the internal bean factory.
// 初始化BeanFactory，并进行XML文件读取，这里将复用BeanFactory中的配置文件读取解析等功能
// 此时xml中定义的配置都已经转换成各种BeanDefinition对象存储在BeanFactory中
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
	refreshBeanFactory();
		//创建DefaultListableBeanFactory实例，因为它是容器的基础，必须要先被实例化
		DefaultListableBeanFactory beanFactory = createBeanFactory();
			return new DefaultListableBeanFactory(getInternalParentBeanFactory());
		//为了序列化指定id，如有需要，使得这个BeanFactory从id反序列化到BeanFactory对象
		beanFactory.setSerializationId(getId());
		//定制beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象、是否允许bean之间存在循环依赖
		//设置@Autowired和@Qualifier注解解析器QualifierAnnotationAutowireCandidateResolver(这在3.0版本中还是存在的)
		customizeBeanFactory(beanFactory);
		//初始化DocumentReader，并进行XML文件读取及解析
		//为register(Class...)指定的任何类注册BeanDefinition并扫描scan(String...)指定的任何包。
		loadBeanDefinitions(beanFactory);
		//使用全局变量beanFactory记录DefaultListableBeanFactory实例
		this.beanFactory = beanFactory;
	return getBeanFactory();

三、prepareBeanFactory(beanFactory);

// Prepare the bean factory for use in this context.
//对BeanFactory进行各种功能填充（@Qualifier和@Autowired正是在这里得到了支持）
prepareBeanFactory(beanFactory);
	// Tell the internal bean factory to use the context's class loader etc.
	//设置beanFactory的classLoader为当前context的classLoader
	beanFactory.setBeanClassLoader(getClassLoader());
	//设置beanFactory的表达式语言处理器，从spring3开始增加了表达式语言的支持，默认可使用#{xxx}的形式来调用相关属性值
	//这里增加了对SPEL语言的支持
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	//为beanFactory增加一个propertyEditorRegistrar，它主要用于所有bean创建的过程
	//这里增加了对属性编辑器的支持
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
	// Configure the bean factory with context callbacks.
	//为beanFactory新增一个BeanPostProcessor
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	//设置几个忽略自动装配的依赖的接口
	/*因为在spring中增加了ApplicationContextAwareProcessor(它是BeanProcessor类型)，在其postProcessBeforeInitialization()中间接调用的
	 *Aware类已不再是普通的bean，而是EnvironmentAware、EmbeddedValueResolverAware...ApplicationContextAware,故需要在spring
	 *做bean的依赖注入时忽略这些类型的bean*/
	/*凡注册到Spring容器内的bean，实现了EnvironmentAware接口重写setEnvironment方法后，
	 *在工程启动时可以获得application.properties的配置文件配置的属性值。*/
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

	// BeanFactory interface not registered as resolvable type in a plain(简单的) factory.
	// MessageSource registered (and found for autowiring) as a bean.
	//设置几个自动装配的特殊规则
	/*注入了依赖解析后，注入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的后处理器--BeanPostProcessor
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	// Detect(探测) a LoadTimeWeaver and prepare for weaving(织入), if found.
	//这里增加了对AspectJ的支持
	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		//增加LoadTimeWeaverAwareProcessor，（因为prepareBeanFactory()是在容器初始化时调用，
		//即只有注册了LoadTimeWeaverAwareProcessor才会激活AspectJ的功能）
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		// Set a temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}

	// Register default environment beans.
	//注册默认的系统环境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());
	}

四、postProcessBeanFactory(beanFactory);

// Allows post-processing of the bean factory in context subclasses.
//子类覆盖方法做额外的处理
postProcessBeanFactory(beanFactory);

五、invokeBeanFactoryPostProcessors(beanFactory);

// Invoke factory processors registered as beans in the context.
//激活各种BeanFactory处理器
invokeBeanFactoryPostProcessors(beanFactory);
	//重点！！！ 真正的核心代码其实是委托给了PostProcessorRegistrationDelegate
	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)
	//如果发现loadTimeWeaver实例，并同时准备织入
	if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}

PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors

final class PostProcessorRegistrationDelegate {
	public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		// 如果有任何的BeanDefinitionRegistryPostProcessor，则先执行invokeBeanDefinitionRegistryPostProcessors()
		// 用于存储实现了PriorityOrdered和Ordered接口的BeanDefinitionRegistryPostProcessor实例对应的实例名
		Set<String> processedBeans = new HashSet<>();
		// 若ConfigurableListableBeanFactory为BeanDefinitionRegistry类型
		// 而DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，因此这边为true
		if (beanFactory instanceof BeanDefinitionRegistry) {
			// 将DefaultListableBeanFactory硬编码转型为BeanDefinitionRegistry
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			// 记录BeanFactoryPostProcessor类型的处理器
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			// 记录BeanDefinitionRegistryPostProcessor类型的处理器
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
			// 遍历所有的beanFactoryPostProcessors
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					// 重点！！！ 对于BeanDefinitionRegistryPostProcessor
					// 执行其postProcessBeanDefinitionRegistry方法
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					//记录BeanDefinitionRegistryPostProcessor类型的BeanDefinitionPostProcessor
					registryProcessors.add(registryProcessor);
				} else {
					//对于非BeanDefinitionRegistryPostProcessor类型的BeanFactoryPostProcessor，记录常规BeanFactoryPostProcessor
					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!
			// 到目前为止，不要再这里实例化FactoryBeans，因为我们需要将regular beans非实例化，
			// 然后让BeanFactoryPostProcessor应用它们
			// Separate between BeanDefinitionRegistryPostProcessors that implement
			// PriorityOrdered, Ordered, and the rest.
			// 将所有的BeanDefinitionRegistryPostProcessor划拨为实现PriorityOrdered、实现Ordered及其他
			// 用于保存本次要执行的BeanDefinitionRegistryPostProcessor
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			// 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 校验是否实现了PriorityOrdered接口
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					// 获取ppName对应的bean实例, 添加到currentRegistryProcessors中
					// beanFactory.getBean: 这边getBean方法会触发创建ppName对应的bean对象
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			//排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			// 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
			registryProcessors.addAll(currentRegistryProcessors);
			// 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			// 执行完毕清空currentRegistryProcessors
			currentRegistryProcessors.clear();

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			// 接着，调用实现了Ordered接口的BeanDefinitionRegistryPostProcessor
			// 因为执行完上面的BeanDefinitionRegistryPostProcessor
			// 可能会新增了其他的BeanDefinitionRegistryPostProcessor,
			// 因此需要重新查找实现BeanDefinitionRegistryPostProcessor接口的类
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				如果bean的名字所对应的bean和目标类型对应(即实现了Ordered接口)
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			//最后，遍历并调用所有的其他类型的BeanDefinitionRegistryPostProcessor
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				// 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					// 跳过已经执行过的
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						// 设置为true再查找一次，防止出现新的BeanDefinitionRegistryPostProcessor
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				//遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			// 重点！！！ 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
				for (BeanFactoryPostProcessor postProcessor : postProcessors) {
					postProcessor.postProcessBeanFactory(beanFactory);
				}
			// 最后, 调用beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		} else {
			// Invoke factory processors registered with the context instance.
			// 调用BeanFactoryPostProcessor实例的postProcessBeanFactory()方法处理已注册的beanFactoryPostProcessors
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// 此时入参beanFactoryPostProcessors和容器中的所有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!
		// 找出所有实现BeanFactoryPostProcessor接口的类
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		// 将BeanFactoryPostProcessors划拨为实现PriorityOrdered、Ordered及其他
		// 用于记录实现了PriorityOrdered接口的BeanFactoryPostProcessor类型的处理器
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		// 用于记录实现了Ordered接口的BeanFactoryPostProcessor类型的处理器实例对应的实例名
		List<String> orderedPostProcessorNames = new ArrayList<>();
		// 用于记录除实现了PriorityOrdered和Ordered接口的BeanFactoryPostProcessor类型的处理器实例对应的实例名
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		// 对后置处理器进行分类
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
				//已经处理过的则跳过
			}
			//如BeanFactoryPostProcessor实现了PriorityOrdered接口
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			//若BeanFactoryPostProcessor实现了Ordered接口
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			} else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		//先调用实现了PriorityOrdered接口的BeanFactoryPostProcessors
		//按照priority进行排序
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		// 遍历priorityOrderedPostProcessors, 执行postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		//然后调用实现Ordered接口的BeanFactoryPostProcessors
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		//按照order排序
		sortPostProcessors(orderedPostProcessors, beanFactory);
		// 遍历orderedPostProcessors, 执行postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		// 最后，直接调用所有的其他无序BeanFactoryPostProcessors
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			// 获取postProcessorName对应的bean实例, 添加到nonOrderedPostProcessors, 准备执行
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		//执行postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

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

六、registerBeanPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.
//注册拦截Bean创建的Bean后处理器，这里只是注册，真正的调用则是在getBean时
registerBeanPostProcessors(beanFactory);
	//重点！！！ 对配置文件中的BeanPostProcessor进行提取，并注册到beanFactory中
	PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);

七、initMessageSource();

// Initialize message source for this context.
//为上下文初始化message源，即不同语言的消息体，国际化处理
initMessageSource();

八、initApplicationEventMulticaster();

// Initialize event multicaster for this context.
/*初始化消息广播器ApplicationEventMulticaster，并放入“applicationEventMulticaster”bean中
	 *情况一：若用户自定义了事件广播器，那么使用用户自定义的事件广播器
	 *若用户没有自定义事件广播器，则默认使用SimpleApplicationEventMulticaster */
initApplicationEventMulticaster();
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	//对应情况一，并将自定义的事件广播器指定到this.applicationEventMulticaster中
	if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
		this.applicationEventMulticaster =
				beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
		if (logger.isTraceEnabled()) {
			logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
		}
	} else {
		//对应情况二，并和applicationEventMulticaster关联为K&V，并保存到DefaultSingletonBeanRegistry的singletonObjects缓存中
		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
		beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
		if (logger.isTraceEnabled()) {
			logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
					"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
		}
	}

九、onRefresh();

// Initialize other special beans in specific context subclasses.
//留给子类来初始化其他的bean
onRefresh();

十、registerListeners();

// Check for listener beans and register them.
//在所有注册的bean中查找Listener bean，注册到消息广播器中
registerListeners();
	//硬编码方式注册的监听器处理
	// Register statically specified listeners first.
	for (ApplicationListener<?> listener : getApplicationListeners()) {
		getApplicationEventMulticaster().addApplicationListener(listener);
	}

	//重点！！！ 配置文件注册的监听器处理
	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let post-processors apply to them!
	String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
	for (String listenerBeanName : listenerBeanNames) {
		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
	}

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

十一、finishBeanFactoryInitialization(beanFactory);

// Instantiate all remaining (non-lazy-init) singletons.
//完成BeanFactory的初始化工作，实例化剩下的（非懒加载）单实例
finishBeanFactoryInitialization(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 bean post-processor
	// (such as a PropertyPlaceholderConfigurer bean) registered any before:
	// at this point, primarily for resolution in annotation attribute values.
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
	//初始化LoadTimeWeaverAware beans
	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.
	//冻结所有的bean定义，标志着已注册的bean定义将不会被修改或任何进一步的处理
	beanFactory.freezeConfiguration();

	// Instantiate all remaining (non-lazy-init) singletons.
	//重点！！！ 初始化剩下的单实例（非惰性的）
	beanFactory.preInstantiateSingletons();
		//下面讲...

DefaultListableBeanFactory#preInstantiateSingletons

beanFactory.preInstantiateSingletons();
	// 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.
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// Trigger initialization of all non-lazy singleton beans...
	//for循环beanName获取BeanDefinition
	for (String beanName : beanNames) {
		//返回RootBeanDefinition，如果是非RootBeanDefinition（即是子bean），则（会与父bean合并）转换成RootBeanDefinition返回
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		//非抽象类、单实例、非懒加载
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			//重点！！！ isFactoryBean(beanName)内部：
			//1.调用transformedBeanName(name)：剔除工厂引用前缀（支持重复前缀），并将别名解析为规范的名称（支持多层别名） 
			//2.return (beanInstance instanceof FactoryBean)
			if (isFactoryBean(beanName)) {
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					//重点！！！
					return doGetBean(name, null, null, false);
						//1.根据beanName从缓存中获取（原始）单例对象，涉及到解决循环依赖的三级缓存
						Object sharedInstance = getSingleton(beanName);
							//下面讲...
						//2.若尝试直接从缓存中加载单例成功，就调用该方法。涉及FactoryBean的处理逻辑
						//对获取到的实例返回对应的真正实例对象，即如果是FactoryBean，会根据beanInstance、name、beanName判断返回FactoryBean实例本身或其创建的对象
						getObjectForBeanInstance(sharedInstance, name, beanName, null)
							// 若传入的name是工厂相关的（即以"&"开头）
							if (BeanFactoryUtils.isFactoryDereference(name)) {
								if (beanInstance instanceof NullBean) {
									return beanInstance;
								}
								//且beanInstance不是FactoryBean类型的，则验证不通过
								if (!(beanInstance instanceof FactoryBean)) {
									throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
								}
							}
							if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
								return beanInstance;
							}
							//若能执行到这里，要获取的都是FactoryBean创建的对象
							object = doGetObjectFromFactoryBean(factory, beanName);
								object = factory.getObject();
							//调用ObjectFactory的后处理器
							object = postProcessObjectFromFactoryBean(object, beanName);
						//3.若尝试从缓存中加载单例失败，就尝试从parentBeanFactory中获取
						BeanFactory parentBeanFactory = getParentBeanFactory();
						//4.若尝试从parentBeanFactory中获取失败，就自己创建。
						//注意是上面的getSingleton(beanName)的重载方法getSingleton(String beanName, ObjectFactory<?> singletonFactory)，下面讲...
						//其中第二个参数ObjectFactory的getObject()方法体为：return createBean(beanName, mbd, args);
						sharedInstance = getSingleton(beanName, () -> {
							try {
								return createBean(beanName, mbd, args);
									//下面讲...
							}
							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;
							}
						});
						//5.同上，涉及FactoryBean的处理逻辑
						beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				//如果是工厂bean,且需要急切初始化，则还会调用getBean()方法得到工厂bean创建的实例
				if (bean instanceof FactoryBean) {
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
										((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					} else {
						//SmartFactoryBean#isEagerInit 是否需要急切初始化，即急切地调用getObject()和应用post-processors
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
							//重点！！！ 同上
							return doGetBean(name, null, null, false);
					}
				}
			} else {
				//同上
				getBean(beanName);
			}
		}
	}

	// Trigger post-initialization callback for all applicable beans...
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		//重点！！！ bean实例创建成功后，判断是否为SmartInitializingSingleton，若true就调用afterSingletonsInstantiated()
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			} else {
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}

• 问题1：getSingleton(String beanName, ObjectFactory<?> singletonFactory)为什么要传入一个ObjectFactory，而不是直接传入一个bean？
  方便对target bean 进行增强/修改，譬如AOP。如果直接传入bean，则无法进行增强/修改了。

DefaultSingletonBeanRegistry#getSingleton多个重载方法

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	/** Cache of singleton objects: bean name to bean instance. 一级缓存（单例池，即Spring容器），k：beanName，v：已创建完成的单例 */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

	/** Cache of singleton factories: bean name to ObjectFactory. 三级缓存，k：beanNme，v：还未创建单例bean的ObjectFactory，调用getObject()方法可获取bean */
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/** Cache of early singleton objects: bean name to bean instance. 二级缓存，k：beanName，v：提前暴露的单例 */
	//earlySingletonObjects不同于singletonObjects，当一个单例bean被放在该容器内，当bean还在创建过程中，可以通过getBean方法获取
	//该容器的作用是用来检测循环引用
	private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

	/** Names of beans that are currently in creation. 当前正在创建的bean的名称 */
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));
	
	/**
	 * Add the given singleton factory for building the specified singleton
	 * if necessary.
	 * <p>To be called for eager registration of singletons, e.g. to be able to
	 * resolve circular references.
	 * @param beanName the name of the bean
	 * @param singletonFactory the factory for the singleton object
	 */
	protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		synchronized (this.singletonObjects) {
			if (!this.singletonObjects.containsKey(beanName)) {
				this.singletonFactories.put(beanName, singletonFactory);
				this.earlySingletonObjects.remove(beanName);
				this.registeredSingletons.add(beanName);
			}
		}
	}

	@Override
	@Nullable
	public Object getSingleton(String beanName) {
		//参数true设置标识允许早期依赖
		return getSingleton(beanName, true);
	}

	/**
	 * 返回以给定名称注册的（原始）单例对象。
	 * 检查已经实例化的单例，并且还允许对当前创建的单例的早期引用（解析循环引用）。
	 */
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// Quick check for existing instance without full singleton lock
		//单例在spring的同一个容器内只会被创建一次，以后获取bean时，只需尝试直接从singletonObjects单例池中进行获取
		Object singletonObject = this.singletonObjects.get(beanName);
		//如果从单例缓存中获取不成功，且这边bean正在创建中
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			//则尝试从earlySingletonObjects中获取
			singletonObject = this.earlySingletonObjects.get(beanName);
			//如果从earlySingletonObjects中获取也获取不成功，且允许提前暴露bean
			if (singletonObject == null && allowEarlyReference) {
				//则加锁，并再次尝试从上面两个缓存中获取，若还取不到就从singletonFactories中获取singletonFactory
				synchronized (this.singletonObjects) {
					// Consistent creation of early reference within full singleton lock
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						singletonObject = this.earlySingletonObjects.get(beanName);
						if (singletonObject == null) {
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								//调用singletonFactory.getObject()得到我们要的bean
								singletonObject = singletonFactory.getObject();
								//将获取到的bean放入earlySingletonObjects中（k：beanName，v：bean）
								//三级缓存产生bean之后，存入二级缓存，是为了防止重复调用ObjectFactory#getObject()--这个方法可能很复杂很耗时，从而提高性能。也保证了单例bean
								this.earlySingletonObjects.put(beanName, singletonObject);
								//并删除singletonFactories中对应的记录（k：beanName，v：ObjectFactory）
								this.singletonFactories.remove(beanName)
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}

	/**
	 * 返回以给定名称注册的（原始）单例对象，如果尚未注册，则创建并注册一个新对象。
	 * 注意：只尝试从singletonObjects中获取，获取不到就使用传入的singletonFactory创建
	 */
	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		//全局变量需要同步
		synchronized (this.singletonObjects) {
			//先检测beanName对应的bean是否已经加载过，因为singleton模式是复用已创建的bean
			Object singletonObject = this.singletonObjects.get(beanName);
			//如果为空才可以进行singleton的bean的初始化
			if (singletonObject == null) {
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
				}
				//重点！！！ 加载单例前记录加载状态，默认实现将单例注册为"正在创建中"。
				beforeSingletonCreation(beanName);
					if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
						throw new BeanCurrentlyInCreationException(beanName);
					}
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					//初始化bean，这个singletonFactory的getObject()的方法体就是:createBean(beanName, mbd, args)
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
					// Has the singleton object implicitly appeared in the meantime ->
					// if yes, proceed with it since the exception indicates that state.
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						throw ex;
					}
				}
				catch (BeanCreationException ex) {
					if (recordSuppressedExceptions) {
						for (Exception suppressedException : this.suppressedExceptions) {
							ex.addRelatedCause(suppressedException);
						}
					}
					throw ex;
				}
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
					//加载单例后的回调方法，需要移除缓存中对该bean的正在加载状态的记录
					afterSingletonCreation(beanName);
						if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
							throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
						}
				}
				if (newSingleton) {
					//如果是新的singletong的bean则加入缓存，并移除bean加载过程中所记录的各种辅助状态
					addSingleton(beanName, singletonObject);
						synchronized (this.singletonObjects) {
							this.singletonObjects.put(beanName, singletonObject);
							this.singletonFactories.remove(beanName);
							this.earlySingletonObjects.remove(beanName);
							this.registeredSingletons.add(beanName);
						}
				}
			}
			return singletonObject;
		}
	}
}

• 问题：为什么需要二级缓存earlySingletonObjects？
  为了防止重复调用三级缓存的ObjectFactory#getObject()–这个方法可能很复杂很耗时，从而提高性能。也保证了单例bean
• 问题：为什么需要三级缓存singletonFactories？
  为AOP等创建代理bean提供了支持，若没有三级缓存singletonFactories，而是直接存的traget bean，就没法对traget bean进行增强/修改了。

AbstractAutowireCapableBeanFactory#createBean

createBean(beanName, mbd, args);
	//1.锁定class，根据设置的class属性或者根据className来解析Class
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	mbdToUse.setBeanClass(resolvedClass);
	//2.验证及准备覆盖的方法
	mbdToUse.prepareMethodOverrides();
	//Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
	//3.重点！！！  应用初始化前的后处理器，给BeanPostProcessors一个机会来返回目标bean实例的代理
	Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		//对后处理器中的所有InstantiationAwareBeanPostProcessor类型的后处理器，调用其postProcessBeforeInstantiation()方法
		bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
			Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
		if (bean != null) {
			/*
			 * 在bean的初始化后尽可能保证将注册的后处理器的postProcessAfterInitialization()应用到该bean中，
			 * 因为若返回的bean不为空，那么便不会再次经历普通bean的创建过程，
			 * 则只能调用BeanPostProcessors的postProcessAfterInitialization()
			 * */
			bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
		}
	if (bean != null) {
		return bean;
	}
	//4.重点！！！ 真正创建bean的任务委托给了doCreateBean()
	Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		//4-1
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		//4-2.对指定的bean使用合适的初始化策略创建新的实例（即将BeanDefinition转换为BeanWrapper）
		//如工厂方法、构造器自动注入、简单初始化
		/*a.若存在工厂方法，则使用工厂方法进行初始化
		 *b.一个类有多个构造函数，每个构造函数都有不同的参数，故需要根据参数锁定构造函数并进行初始化
		 *c.既不存在工厂方法也不存在带参数的构造函数，则使用默认的构造函数进行bean的实例化
		 */
		instanceWrapper = createBeanInstance(beanName, mbd, args);
			//下面讲...
		//4-3.对指定的beanDefinition应用MergedBeanDefinitionPostProcessors，并调用其postProcessMergedBeanDefinition方法
		//bean合并后的处理，@Autowired正是通过该方法实现诸如类型的预解析
		applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		//4-4.是否需要提早曝光，单例&&允许循环依赖&&当前bean正在创建中
		//isSingletonCurrentlyInCreation()：在spring中，通过DefaultSingletonBeanRegistry的singletonsCurrentlyInCreation来记录					
		//bean的加载状态，在bean开始创建前会将beanName记录在其中，在bean创建后会将beanName从其中移除
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			//addSingletonFactory()：为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
			/*getEarlyBeanReference()：对bean再一次依赖引用，主要应用SmartInstantiationAwareBeanPostProcessor
			 *AOP在这里将advice动态织入bean中，若没有则直接返回bean，不做任何处理*/
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
				synchronized (this.singletonObjects) {
					if (!this.singletonObjects.containsKey(beanName)) {
						//放入三级缓存
						this.singletonFactories.put(beanName, singletonFactory);
						this.earlySingletonObjects.remove(beanName);
						this.registeredSingletons.add(beanName);
					}
				}
		}
		//4-4
		/*在给定的BeanWrapper中，用beanDefinition中的所有属性填充至bean实例中，
		 *其中，可能存在依赖于其他bean的属性，则会递归初始依赖的bean，
		 *在递归初始依赖的bean的过程中并不是直接去实例化相关的bean，而是先检测缓存中是否有已经建好的对应的bean，
		 *或是否已经创建好的ObjectFactory*/
		populateBean(beanName, mbd, instanceWrapper);
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					//返回值为是否继续填充bean
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					//PropertyValues：是一个或多个PropertyValue对象的持有者，通常包括针对特定目标 bean 的一次更新。
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						//对所有需要依赖检查的属性进行后处理
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
			//真正开始执行属性赋值，利用上述操作得到的PropertyValues
			if (pvs != null) {
				applyPropertyValues(beanName, mbd, bw, pvs);
			}
		//4-5.调用初始化方法，比如init-method属性指定的初始化方法
		exposedObject = initializeBean(beanName, exposedObject, mbd);
			//对特殊的bean处理，若bean是BeanNameAware、BeanClassLoaderAware、BeanFactoryAware类型
			invokeAwareMethods(beanName, bean);
			//应用BeanPostProcessor处理器的postProcessBeforeInitialization()
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
			//调用用户自定义的init方法
			/*两种方式自定义init方法：
			 *a.使用配置init-method进行指定
			 *b.使用自定义的bean实现InitializingBean接口，并在afterPropertiesSet中实现自己的初始化业务逻辑*/
			invokeInitMethods(beanName, wrappedBean, mbd);
				//下面讲...
			//应用BeanPostProcessor处理器的postProcessAfterInitialization()
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

AbstractAutowireCapableBeanFactory#createBeanInstance

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		//解析class
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}
		//若在RootBeanDefinition中存在factoryMethodName属性（即工厂方法不为空，也就是配置了factory-method）
		//则使用工厂方法初始化策略，根据RootBeanDefinition中的配置生成bean的实例
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		/*解析构造函数并进行构造函数的实例化
		 *因为一个bean对应的类中可能会有多个构造函数，而每个构造函数的参数不同，spring根据参数及类型去判断最终会使用哪个
		 *构造函数进行实例化，但判断过程比较消耗性能，故采用缓存机制，若已经解析过则不需要重复解析而是直接从
		 * RootBeanDefinition的resolvedConstructorOrFactoryMethod中获取，若需要再次解析，则将解析的结果添加至其中去*/
		// Shortcut when re-creating the same bean...
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				//一个类有多个构造函数，每个构造函数都有不同的参数，故调用前需要先根据参数锁定构造函数或对应的工厂方法
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		//若已经解析过，则使用解析好的构造函数方法，无须再次锁定
		if (resolved) {
			if (autowireNecessary) {
				//构造函数自动注入
				//带有参数的实例化情况：因存在不确定性，故在判断对应参数上做了大量工作
				return autowireConstructor(beanName, mbd, null, null);
			} else {
				//使用默认构造函数构造
				//不带参数的构造函数的实例化过程
				return instantiateBean(beanName, mbd);
			}
		}

		// Candidate constructors for autowiring?
		//需要根据参数解析构造函数
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
			SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
			Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			//构造函数自动注入
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// Preferred constructors for default construction?
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		// No special handling: simply use no-arg constructor.
		//使用默认构造函数构造
		return instantiateBean(beanName, mbd);
	}
}

AbstractAutowireCapableBeanFactory#invokeInitMethods

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
	protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {
		/*init-method与afterPropertiesSet()均在初始化bean时执行，且init-method较后执行*/
		/*首先会检查自定义的bean是否是InitializingBean类型，即是否实现了InitializingBean接口，
		 *如果是的话，则需要调用afterPropertiesSet()*/
		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isTraceEnabled()) {
				logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
			}
			if (System.getSecurityManager() != null) {
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				} catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			} else {
				//属性初始化后的处理
				((InitializingBean) bean).afterPropertiesSet();
			}
		}

		if (mbd != null && bean.getClass() != NullBean.class) {
			String initMethodName = mbd.getInitMethodName();
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				//调用配置中自定义的初始化方法，即init-method配置指定的方法
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}
}

• 问题：bean的三种初始化方法及它们的执行顺序
  参考链接

十二、finishRefresh();

// Last step: publish corresponding event.
//完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人
finishRefresh();
	// Clear context-level resource caches (such as ASM metadata from scanning).
	//清空context域中的资源缓存
	clearResourceCaches();

	// Initialize lifecycle processor for this context.
	//初始化LifecycleProcessor，若没有指定，则使用默认的DefaultLifecycleProcessor
	initLifecycleProcessor();

	// Propagate refresh to lifecycle processor first.
	getLifecycleProcessor().onRefresh();

	// Publish the final event.
	//重点！！！ 通过spring中的事件发布机制来发出ContextRefreshedEvent事件
	publishEvent(new ContextRefreshedEvent(this));
		publishEvent(event, null);
			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
				//下面讲...

	// Participate in LiveBeansView MBean, if active.
	LiveBeansView.registerApplicationContext(this);

SimpleApplicationEventMulticaster#multicastEvent

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		//遍历所有监听器
		for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
			Executor executor = getTaskExecutor();
			if (executor != null) {
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
				//用给定的事件驱动监听器，并使用监听器中的onApplicationEvent()来进行监听器的处理
				invokeListener(listener, event);
			}
		}
	}
}