每天一点点，Spring执行创建bean(AbstractAutowireCapableBeanFactory#doCreateBean)

Spring 创建bean流程 AbstractAutowireCapableBeanFactory#doCreateBean

1、 判断当前bean是不是单例的，如果是单例的，先从缓存中取，如果存在直接返回(在创建之前已经由依赖注入已生成)，如果不存在执行创建

if (mbd.isSingleton()) {
	instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}

2、如果不是NullBean对象，进行缓存

if (beanType != NullBean.class) {
	mbd.resolvedTargetType = beanType;
}

3、判断缓存是否已经处理过MergedBeanPostProcessors，如果没有则执行

synchronized (mbd.postProcessingLock) {
	if (!mbd.postProcessed) {
		try {
			applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
		}
		mbd.postProcessed = true;
	}
}

4、判断是否允许循环依赖，如果支持将bean的创建暴露，存在则存到DefaultSingletonBeanRegistry#singletonFactories中

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
	addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

5、更换一个变量，执行后面的逻辑。
5.1、分析 ：此处为什么需要重新定义一个变量，而不是直接使用产生的对象 ？？
我的理解 ： 因为上面在判断允许循环依赖的时候，加入的是原始bean对象，在循环依赖的时候，如果需要的对象是需要代理的，则被代理的对象就是这个原始对象bean。如果 此处不重新更换一个变量exposedObject进行后续的处理的话，就有可能导致 在循环依赖的时候里面的被代理对象bean和 exposedObject 对象不一致，这样是有问题的

Object exposedObject = bean;

6、执行属性填充

populateBean(beanName, mbd, instanceWrapper); 

7、执行初始化

exposedObject = initializeBean(beanName, exposedObject, mbd);

8、如果支持循环依赖
8.1、取出二级缓存中的早期暴露的对象earlySingletonReference ，如果存在则代表存在循环依赖

//如果earlySingletonReference != null 则代表当前bean存在循环依赖
Object earlySingletonReference = getSingleton(beanName, false);

8.2、如果 earlySingletonReference != null 代表存在循环依赖
8.2.1 判断当前暴露的类是不是和生成的bean一致，如果一致修改当前类的实例为二级缓存中的bean对象

if (exposedObject == bean) {
// 因为当前ben可能已经被代理了,所以放在单例池的bean应该是代理对象
	exposedObject = earlySingletonReference;
}

9、如果bean有定义销毁方法，注册这些bean

try {
	registerDisposableBeanIfNecessary(beanName, bean, mbd);
}