protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
// 步骤1
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 步骤2
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
addSingletonFactory(beanName, new ObjectFactory
上面是精简doCreateBean方法，这五个步骤是我认为相对比较重要的，下面说下这个五个步骤完成功能
1、拿到Bean的普通实例，这里的普通实例是相对AOP代理的那种Bean而言的。普通bean大部分都是通过反射拿到构造方法创建实例对象
2、创建这个Bean的ObjectFactory的对象，并且把他加到第三级缓存中
3、给普通实例Bean填充属性，比如Bean里面有属性带了@Autowired，就是给里面的属性赋值
4、执行Bean的初始化的前置回调方法、初始化回调方法、初始化的后置回调方法，这里有个点需要知道，AOP代理的Bean大部分都是通过后置回调方法创建的
5、从一级或者二级缓存中获取Bean的实例，不从三级缓存中取
下面结合Bean的创建说下上面五参与创建Bean的流程：
二、创建非AOP代理的Bean，比如没有被切面拦截的Service，或者没有加@Transactional注解的Bean1、通过步骤1创建Bean的实例
2、执行步骤2将Bean加到三级缓存中，三级缓存主要是解决AOP代理Bean被依赖的问题，所以步骤2在这没有作用
3、完成这个普通Bean里面的依赖属性，比如带有@Autowired属性赋值，比如带有@Value属性赋值
4、因为不是AOP处理的Bean，所以步骤4没有做用什么
5、步骤5从一、二级缓存没有拿到数据，所以这一步也没什么作用，最后返回步骤1创建的实例对象
总结：参与Bean的实例化也就步骤1，步骤3
二、创建AOP代理的Bean，没有循环依赖的情况
1、通过步骤1创建Bean的实例
2、执行步骤2将Bean加到三级缓存中，这里不涉及循环依赖，所以步骤2没有用
3、完成这个普通Bean里面的依赖属性
4、通过SmartInstantiationAwareBeanPostProcessor类型的后置处理器，调用postProcessAfterInitialization方法创建AOP代理的Bean
5、步骤5从一、二级缓存没有拿到数据，没什么作用
三、创建非AOP代理的Bean，有循环依赖，A依赖B，B依赖A，A和B都是非AOP代理的Bean总结：最后返回4中创建的代理Bean，那么有人会问步骤1创建的普通实例Bean，就没用了吗，其实在步骤4创建代理Bean的时候，要用到步骤1创建的Bean，以Spring的JDK动态代理来说，创建的代理对象需要目标对象的实例对象，在执行invoke方法时，调用"目标方法"需要传"目标对象实例"的
假设A先实例化
1、A->步骤1，创建A的实例
2、A->步骤2，创建A的ObjectFactory的对象，并且把他加到第三级缓存中，后面会用到
3、A->步骤3，完成A实例里面的依赖属性，因为依赖B，但是B还没有实例化，这个会去实例化B
4、B->步骤1，创建B的实例
5、B->步骤2，创建B的ObjectFactory的对象,并且加到第三级缓存中
6、B->步骤3，填充B的属性，然后找依赖的A，发现缓存中只有一个ObjectFactory对象，通过ObjectFactory的getObject来得到A的实例对象，然后存到二级缓存中。
7、B->步骤4，因为B非AOP代理对象，所以步骤四没有实质作用。
8、B->步骤5，没有实质作用，返回实例好的B，注意这里的B属性赋值也完成，最后存到一级缓存中。
9、A->步骤4，因为A是非AOP代理对象，所以步骤四没有实质作用。
10、A->步骤5，前面实例化B的时候，在节点6，已经把A存到了二级缓存，所以从二级缓存取出A的实例返回，其实二级缓存对象和节点1创建的实例对象是同一。
四、创建AOP代理的Bean，有循环依赖，A依赖B，B依赖A，A是被AOP代理，B不是。总结：最后将实例A存到一次缓存中，至此实例化A和实例化B已经完成，实例对象都是在步骤1完成。提前引用彼此的实例对象地址，然后通过滞后性完成里面的属性填充。
假设A先实例化。其实A是AOP代理和B是AOP代理产生的B一个道理
1、A->步骤1，创建A的实例
2、A->步骤2，创建A的ObjectFactory的对象，并且把他加到第三级缓存中，后面会用到
3、A->步骤3，完成A实例里面的依赖属性，因为依赖B，但是B还没有实例化，这个会去实例化B
4、B->步骤1，创建B的实例
5、B->步骤2，创建B的ObjectFactory的对象,并且加到第三级缓存中
6、B->步骤3，填充B的属性，然后找依赖的A，发现缓存中只有一个ObjectFactory对象，通过ObjectFactory的getObject来得到A的代理对象，然后存到二级缓存中。
7、B->步骤4，因为B非AOP代理对象，所以步骤四没有实质作用。
8、B->步骤5，没有实质作用，返回实例好的B，注意这里的B属性赋值也完成，最后存到一级缓存中。
9、A->步骤4，A是AOP代理对象，所以步骤4会去创建A的代理对象。但是此时A的代理对象已经被B调用getObject产生了，而且还引用了，所以步骤4会先从缓存中判断是否已经创建了A的代理对象，如果创建了就不会再去创建，返回创建好的。
10、A->步骤5，前面实例化B的时候，在节点6，已经把A存到了二级缓存，所以从二级缓存取出A的实例返回，其实二级缓存对象和节点1创建的实例对象不一样的，一个是普通对象，一个是代理对象。
注意：创建依赖的AOP代理Bean和创建依赖的非AOP代理主要区别是在：节点6、节点9、节点10，中间利用了一个earlyProxyReferences来处理是否还要创建AOP代理对象，如果创建过就把BeanName会存到earlyProxyReferences里面去。
有时间可以参考这篇文章写的非常好：https://cloud.tencent.com/developer/article/1497692
