Spring源码解析：BeanFactory和Bean创建流程
概述
BeanFactory是个Factory，也就是IOC容器或对象工厂；在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。
我们先创建一个类，用创建的类来研究Spring是如何创建的该类的实例以及整个容器的流程（创建的bean实例是使用注解完成的，如果是xml文件形式，和注解的流程类似）：
@Test
public void test(){
//1.创建IOC容器
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(LifeCycle.class);
System.out.println("容器创建完毕");
Person person= applicationContext.getBean(Person .class);
//关闭容器
applicationContext.close();
}
上述的代码就是将LifeCycle配置类放入容器中进行bean的创建，我们使用debug模式来进入new AnnotationConfigApplicationContext(LifeCycle.class)，该构造器中会调用refresh()函数进行容器的“刷新”：
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}
BeanFactory创建的主要流程
进入refresh()函数后会发现，BeanFactory的基本创建都在这个方法之中，下面代码是主要主要流程；
//准备为此上下文以进行刷新
prepareRefresh();
// 告诉子类刷新内部bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//准备在目前情况下使用的bean工厂（BeanFactory的预准备工作）
prepareBeanFactory(beanFactory);
try {
//允许在上下文子类中对bean工厂进行后处理
postProcessBeanFactory(beanFactory);
//调用在上下文中注册的bean的工厂处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 注册拦截Bean创建的Bean处理器
registerBeanPostProcessors(beanFactory);
// 为此上下文初始化消息源
initMessageSource();
//为此上下文初始化事件多播器
initApplicationEventMulticaster();
// 在特定上下文子类中初始化其他特殊bean（空方法，留给子类重写使用的方法，在SpringBoot中，会将该方法重写，并且在该方法中创建了嵌入式Servlet容器实例）
onRefresh();
// 检查侦听器bean并注册它们
registerListeners();
// 实例化所有剩余的（非延迟）单例
finishBeanFactoryInitialization(beanFactory);
// 最后一步：发布相应的事件
finishRefresh();
}
prepareRefresh()创建前的预处理
在该方法中会有以下主要方法:
//在上下文环境中初始化任何占位符属性源(空方法)
initPropertySources();
//验证标记为必需的所有属性都是可解析的
getEnvironment().validateRequiredProperties();
//允许收集早期的ApplicationEvent，一旦多播器可用时就发布
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
- initPropertySources()初始化一些占位符属性源设置，子类可以自定义个性化的属性设置；
- getEnvironment().validateRequiredProperties()验证所有属性标注都是可解析的；
- earlyApplicationEvents = new LinkedHashSet()保存容器中的一些早期的事件，在有了多播器后就可以被直接发布（目前我们没有设置事件，因此为null）；
obtainFreshBeanFactory()获取BeanFactory
- refreshBeanFactory刷新（创建）BeanFactory，并创建了beanFactory = new DefaultListableBeanFactory()；
- getBeanFactory()方法，返回刚刚在1中创建的BeanFactory对象；
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
prepareBeanFactory(beanFactory)预准备工作
BeanFactory的预准备工作（BeanFactory进行一些设置），配置工厂的标准上下文（容器）特征，例如上下文的ClassLoader和后处理器:
将上一步获取的BeanFactory对象传入进来进行配置
@param beanFactory the BeanFactory to configure
postProcessBeanFactory(beanFactory)后置处理
postProcessBeanFactory(beanFactory)该方法也是一个空方法，是为子类所留，子类通过重写该方法，可以在BeanFactory创建并预准备完成以后做进一步的设置； 这里也就是编写后置处理方法的地方；
invokeBeanFactoryPostProcessors(beanFactory)
该方法必须在单例实例化之前被调用；一些后置处理器的执行是会按照优先级（PriorityOrdered接口）和顺序（Ordered接口）依次执行的，最后执行没有实现任何优先级或顺序接口的BeanDefinitionRegistryPostProcessor（后置处理器）方法；
registerBeanPostProcessors(beanFactory)
- 会获取所有的BeanPostProcessor（内部bean，非我们创建的）（后置处理器默认都可以通过PriorityOrdered，Ordered接口指定优先级）；
- 先注册（加入到beanFactory中）PriorityOrdered优先级接口的BeanPostProcessor；接着就是实现了Ordered接口，最后还是执行没有实现任何优先级或顺序接口的BeanPostProcessor；
initMessageSource()
初始化MessageSource组件（国际化功能，消息绑定，消息解析）；
- 【MessageSource能取出国际化配置文件中的某个key值，能按照区域信息获取】
- 获取BeanFactory；
ConfigurableListableBeanFactory beanFactory = getBeanFactory(); - 判断容器中是否有id为MessageSource组件，如果有该组件，就直接赋值给它，如果没有就创建一个DelegatingMessageSource组件；
- 然后把注册好的MessageSource注册在beanFactory中；
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource)
initApplicationEventMulticaster()
初始化事件派发器:
- 获取beanFactory；
- 从beanFactory获取applicationEventMulticaster的ApplicationEventMulticaster；
- 如果没有用户未配置，就会创建一个SimpleApplicationEventMulticaster事件派发器，并将其注册到beanFactory中，以后其它组件就可以自动注入；
onRefresh()
留给子容器（子类），在特定子类中初始化其他特殊的bean；SpringBoot中该方法创建了嵌入式servlet容器的实例；
registerListeners()
给容器中将所有项目里面的ApplicationListener注册进来，
Bean的创建
finishBeanFactoryInitialization(beanFactory)
初始化所有剩余的（非延迟）单例（在该方法中会创建出来我们所定义出来的bean实例）；
- 调用beanFactory.preInstantiateSingletons()；初始化所有剩余的（非延迟）单例，在这个方法中会对bean进行复杂的判断与创建，会获取bean的定义信息，判断bean是否是实现了FactoryBean的Bean等等；
- 若不是实现了FactoryBean的Bean，就会调用 getBean(beanName)继续创建bean实例；
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// 依次注册新的bean定义
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// 开始所有非懒加载单例bean的初始化
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//判断Bean不是抽象的，是单实例的并且不是懒加载的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判断是否是FactoryBean（工厂Bean）的（判断是否实现了FactoryBean的Bean）
if (isFactoryBean(beanName)) {
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
//如果不是FactoryBean，就会利用getBean(beanName)创建对象
else {
getBean(beanName);
}
}
}
// 触发所有合适的bean的初始化后的回调
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
smartSingleton.afterSingletonsInstantiated();
return null;
}
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
- 在getBean方法中调用doGetBean(name, null, null, false)方法：先获取缓存中保存的单实例Bean；如果能够获取到，说明之前已经被创建过（创建的单实例Bean都会被缓存起来）；若获取不到就继续创建；
// 检查单例缓存中是否有注册的单实例bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
- 在缓存中如果没有，说明是没有创建的bean，就会调用createBean(beanName, mbd, args)来继续创建；
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
//创建Bean实例
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
- 在createBean方法中的中会有resolveBeforeInstantiation(beanName,mbd)方法，该方法会给bean的后置处理器一个返回代理对象而不是目标bean实例的机会；让BeanPostProcessor先拦截返回代理对象：
- InstantiationAwareBeanPostProcessor的执行；
- 先执行postProcessBeforeInstantiation(beanClass, beanName)方法，如果有返回值再去执行postProcessAfterInitialization(result, beanName)方法；
//使用实例化之前的后处理器，以解决指定bean实例化之前是否存在的快捷方式 protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { // Make sure bean class is actually resolved at this point. if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { Class<?> targetType = determineTargetType(beanName, mbd); if (targetType != null) { //前置实例化处理 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { //后置实例化处理 bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } mbd.beforeInstantiationResolved = (bean != null); } return bean; } - 如果上一步没有返回代理对象时，就会调用如下方法继续创建：
Object beanInstance = doCreateBean(beanName, mbdToUse, args);/创建Bean
doGetBean方法：
在doGetBean方法中调用createBean，然后再createBean中再调用doCreateBean方法；
-
在doCreateBean方法中创建Bean的实例：createBeanInstance(beanName, mbd, args)；利用工厂方法或确定对象的构造器创建出Bean实例；
-
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)，允许Bean的后置处理器来修改bean的定义；
-
populateBean(beanName, mbd, instanceWrapper)开始给Bean属性进行赋值：
- 赋值之前：
- 获取到InstantiationAwareBeanPostProcessor后置处理器，执行postProcessAfterInstantiation方法；
- 再获取到InstantiationAwareBeanPostProcessor后置处理器，执行postProcessPropertyValues方法；
- 赋值：
- 应用Bean的属性值，为属性利用setter方法进行赋值：applyPropertyValues(beanName, mbd, bw, pvs)；
- 赋值之前：
-
Bean初始化：initializeBean(beanName, exposedObject, mbd)：
- 【执行Aware接口的方法】执行invokeAwareMethods(beanName, bean)方法，也就是执行BeanNameAware、BeanClassLoaderAware和BeanFactoryAware方法（xxxAware方法）；
private void invokeAwareMethods(final String beanName, final Object bean) { if (bean instanceof Aware) { if (bean instanceof BeanNameAware) { ((BeanNameAware) bean).setBeanName(beanName); } if (bean instanceof BeanClassLoaderAware) { ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader()); } if (bean instanceof BeanFactoryAware) { ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this); } } }- 【执行后置处理器初始化之前的方法（预初始化方法）】调用applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)方法，然后再调用BeanPostProcessor.postProcessBeforeInitialization(result, beanName)方法；
- 【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd)：
- 判断是否是InitializingBean接口的实现，执行接口规定的初始化；
- 判断是否自定义初始化方法，如果有就执行；
- 【执行后置处理器初始化后方法】applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)，然后执行beanProcessor.postProcessAfterInitialization(result, beanName)方法；
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged(new PrivilegedAction<Object>() { @Override public Object run() { invokeAwareMethods(beanName, bean); return null; } }, getAccessControlContext()); } else { //执行Aware接口的方法 invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { //【执行后置处理器初始化之前的方法（预初始化方法）】 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { //【执行初始化方法】 invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } if (mbd == null || !mbd.isSynthetic()) { //【执行后置处理器初始化后方法】 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; }5.在上述的doCreateBean方法返回创建好的exposedObject（bean实例），最终在doGetBean中会返回创建的bean：
- 在doCreateBean方法中注册Bean的销毁方法（不是执行）registerDisposableBeanIfNecessary(beanName, bean, mbd)；
-
将创建的Bean实例添加到缓存（ Map
上述是Bean实例的创建过程。
finishRefresh()
完成BeanFactory的初始化创建工作，IOC容器就会创建完毕:
- initLifecycleProcessor()，初始化和声明周期有关的处理器；
- getLifecycleProcessor().onRefresh()，获取到之前定义的生命周期处理器（BeanFactory），回调onRefresh方法；
- publishEvent(new ContextRefreshedEvent(this))，发布容器刷新完成事件；
- LiveBeansView.registerApplicationContext(this)。