学习spring流程，脉络梳理-含源码及注释
PostProcessor？
PostProcessor (增强器 后置处理器) ，BeanFactoryPostProcessor 完成对 Beanfactory 相关信息的修改或者扩展，BeanPostProcessor 完成对 bean 的修改或者扩展。
Bean的生命周期
取自BeanFactory接口代码注释
* <p>Bean factory implementations should support the standard bean lifecycle interfaces * as far as possible. The full set of initialization methods and their standard order is: * Bean工厂实现应该尽可能地支持标准bean lifecycle接口，所有实例方法和他们的标准排序如下 * <ol> * <li>BeanNameAware\'s {@code setBeanName} * <li>BeanClassLoaderAware\'s {@code setBeanClassLoader} * <li>BeanFactoryAware\'s {@code setBeanFactory} * <li>EnvironmentAware\'s {@code setEnvironment} * <li>EmbeddedValueResolverAware\'s {@code setEmbeddedValueResolver} * <li>ResourceLoaderAware\'s {@code setResourceLoader} * (only applicable when running in an application context) * <li>ApplicationEventPublisherAware\'s {@code setApplicationEventPublisher} * (only applicable when running in an application context) * <li>MessageSourceAware\'s {@code setMessageSource} * (only applicable when running in an application context) * <li>ApplicationContextAware\'s {@code setApplicationContext} * (only applicable when running in an application context) * <li>ServletContextAware\'s {@code setServletContext} * (only applicable when running in a web application context) * <li>{@code postProcessBeforeInitialization} methods of BeanPostProcessors * <li>InitializingBean\'s {@code afterPropertiesSet} * <li>a custom init-method definition * <li>{@code postProcessAfterInitialization} methods of BeanPostProcessors * </ol>
脉络总览
分步骤讲解
关键方法 ApplicationContext.refresh();
refresh 方法
@Override public void refresh() throws BeansException, IllegalStateException { //startupShutdownMonitor对象在spring环境刷新和销毁的时候都会用到，确保刷新和销毁不会同时执行 synchronized (this.startupShutdownMonitor) { // 准备工作，例如记录事件，设置标志，检查环境变量等，并有留给子类扩展的位置，用来将属性加入到applicationContext中 prepareRefresh(); // 创建beanFactory，这个对象作为applicationContext的成员变量，可以被applicationContext拿来用, // 并且解析资源（例如xml文件），取得bean的定义，放在beanFactory中 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 对beanFactory做一些设置，例如类加载器、spel解析器、指定bean的某些类型的成员变量对应某些对象等 prepareBeanFactory(beanFactory); try { // 子类扩展用，可以设置bean的后置处理器（bean在实例化之后这些后置处理器会执行） postProcessBeanFactory(beanFactory); // 执行beanFactory后置处理器（有别于bean后置处理器处理bean实例，beanFactory后置处理器处理bean定义） invokeBeanFactoryPostProcessors(beanFactory); // 将所有的bean的后置处理器排好序，但不会马上用，bean实例化之后会用到 registerBeanPostProcessors(beanFactory); // 初始化国际化服务 initMessageSource(); // 创建事件广播器 initApplicationEventMulticaster(); // 空方法，留给子类自己实现的，在实例化bean之前做一些ApplicationContext相关的操作 onRefresh(); // 注册一部分特殊的事件监听器，剩下的只是准备好名字，留待bean实例化完成后再注册 registerListeners(); // 单例模式的bean的实例化、成员变量注入、初始化等工作都在此完成 finishBeanFactoryInitialization(beanFactory); // applicationContext刷新完成后的处理，例如生命周期监听器的回调，广播通知等 finishRefresh(); } catch (BeansException ex) { logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex); // 刷新失败后的处理，主要是将一些保存环境信息的集合做清理 destroyBeans(); // applicationContext是否已经激活的标志，设置为false cancelRefresh(ex); // Propagate exception to caller. throw ex; } } }
1、创建 BeanFactory 容器
2、加载配置文件，解析 Bean 定义信息，包装成 BeanDafination
BeanDifinationConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
--> refreshBeanFactory();
--> try{
// 创建 DefaultListableBeanFactory 对象
DefaultListableBeanFactory beanFactory = createBeanFactory();
// 为了序列化指定 id，可以从id反序列化到 BeanFactory 对象
beanFactory.setSerializationId(getId());
// 定制 beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖
customizeBeanFactory(beanFactory);
// 初始化 documentReader，并进行 XML 文件读取及解析，默认命名空间的解析，自定义标签的解析
loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
}
在 obtainFreshBeanFactory() 方法中，先创建了一个 DefaultListableBeanFactory，再向其中设置一些基本属性，后通过 loadBeanDifinations(beanFactory) 将自定义的对象加入到 beanDifinationMap 中，在 map 中完成将每一个对象包装成 BeanDifination；
3、执行 BeanFactoryPostProcesser
invokeBeanFactoryPostProcessors(beanFactory);
执行后，BeanDifination 已经确定。
4、准备工作：准备 BeanPostProcesser，广播器，监听器
initApplicationEventMulticaster();
registerListeners();
初始化当前应用的事件广播器
注册监听器
5、实例化操作
6、初始化操作
finishBeanFactoryInitialization(beanFactory);
--> beanFactory.preInstantiateSingletons();
--> // 将所有的 beanDefinitionNames 创建一个集合
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 触发所有非延迟加载单例 bean 的初始化，遍历集合的对象
for () {
...
getBean(beanName);
--> doGetBean(name, null, null, false);
--> // bean 对象实现 FactoryBean 接口后会变成 &beanName
String beanName = transformedBeanName(name);
Object bean;
// 提前检查单例缓存中是否有手动注册的单例对象，跟循环依赖有关联
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
...
} else {
createBean(beanName, mbd, args);
--> Object beanInstance = doCreateBean(beanName, mbdToUsc, args);
--> instanceWrapper = createBeanInstance(beanName, mbd, args);
--> Constructor<?> ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
// 使用默认无参构造函数创建对象，如果没有无参构造且存在多个有参构造且没有 @AutoWired 注解构造，会报错
return instantiateBean(beanName, mbd);
--> beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
--> constructorToUse = clazz.getDeclaredConstructor();
return BeanUtils.instantiateClass(constructorToUse);
--> return ctor.newInstance(argsWithDefaultValues);
// 初始化过程 填充属性
populateBean(beanName, mbd, instanceWrapper);
// 执行初始化逻辑
exposedObject = initializeBean(beanName, exposedObject, mbd);
--> // Aware 接口处理器，调用 BeanNameAware、BeanClassLoaderAware、beanFactoryAware
invokeAwareMethods(beanName, bean);
// 将 BeanPostProcessors 应用到给定的现有 Bean 实例，调用它们的postProcessBeforeInitialization 初始化方法。
wrappedBean = applyBeanPostProcessorBeforeInitialization(wrappedBean, beanName);
// 调用初始化方法，先调用 bean 的 InitializingBean 接口方法，后调用 bean 的自定义初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
// 将 BeanPostProcessors 应用到给定的现有 Bean 实例，调用它们的 postProcessAfterInitialization方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
}
实例化所有 剩余的 非懒加载的 单例对象
Aware接口是方便自定义对象获取到容器对象
7、获取对象
略