首先看下Spring创建一个bean的基本流程：
创建该实例的原始对象 --> 进行自动装配 --> AOP代理处理 --> 完成bean的创建并加入单例池(即一级缓存)
一级缓存用于存放已经属性赋值初始化后的单列Bean 解决循环依赖
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
二级缓存用于存放已经实例化，还未做代理、属性赋值操作的单例 解决对象完整性
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
三级缓存 存放单例Bean的工厂 解决AOP
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
已经注册的单例池里的beanName
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
正在创建中的beanName Bean开始创建时放值，创建完成后会将其移出
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
当前被排除在创建检查之外的bean的名称
private final Set<String> inCreationCheckExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
从缓存查找bean；一级没有，就从二级获取，二级也没有，就从三级创建放入二级
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
在一级缓存里获取
Object singletonObject = this.singletonObjects.get(beanName);
一级缓存不存在，判断是否正在创建中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
加锁防止并发
synchronized (this.singletonObjects) {
在二级缓存里获取
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
在三级缓存里获取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
存到二级缓存里
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
假设单例1与单例2相互依赖对方并且此时都没有加入到单例池：
如果配置不允许循环依赖,则一切皆空谈。spring解决不了构造方法的循环依赖！
处理流程：
spring中，bean的初始化只是其生命周期的一部分(第一步)，在bean初始化之后，spring会判断是否需要提前暴露对象(条件为：是否是单例bean && 当前容器允许循环依赖 && bean名称存在于正在创建的bean名称清单中)，允许的话就会生成一个ObjectFactory<?>(这是一个函数式接口)存到三级缓存，它的作用是生产一个bean(getObject方法)，所有的bean在初始化未完成(对于spring的bean生命周期来说)的时候都会先存一个ObjectFactory<?>到三级缓存。
创建单例A，将A的工厂加入三级缓存，发现A依赖于B，这个时候spring会调用getBean("B")(递归操作)去一级，二级，三级缓存里获取B，因为B没有被加载，所以获取不到，spring就会去加载B。创建B的工厂且加入singletonFactories缓存(前提是执行了构造器,所以构造器的循环依赖没法解决)，发现B又是依赖于A的，spring就会从一级、二级缓存取A，发现没有，就去三级缓存中找A的工厂(前面已经将A的工厂存入到三级缓存)，执行ObjectFactory.getObject()，这个方法会调用getEarlyBeanReference方法(函数式接口)，会返回一个bean实例。将其放入二级缓存earlySingletonObjects内,并将三级缓存中A的工厂删掉。这个时候对象已经实例化了，虽然还不完美，但是对象的引用已经可以被其它引用了。然后B取得A完成创建后，B加入一级缓存，在将B自身返回给A，A得到B创建成功，将A加入一级缓存，删除二级缓存earlySingletonObjects中的A，循环依赖问题被解决。
什么是早期的bean？
刚刚实例化好的bean，此时bean还未进行属性填充，初始化等操作。
Spring在创建Bean的过程中分为三步:
AbstractAutowireCapableBeanFactory类中
实例化：
createBeanInstance()方法：简单理解就是new了一个对象。
属性注入：
populateBean()方法：为实例化中new出来的对象填充属性和注入依赖。
初始化：
initializeBean()方法：执行aware接口中的方法，初始化方法，完成AOP代理。
到这里我有个疑惑，为什么不直接在二级缓存中存bean的实例呢？为什么要使用ObjectFactory函数式接口呢？
查看源码后发现，getEarlyBeanReference()会判断传入的这个类有没有被AOP增强，如果被AOP增强了（比如可能在上面加了拦截器，前置通知，环绕通知等，将其包装为一个代理了），则返回一个被AOP包装过后的实例(在被AOP增强的时候，返回的是一个代理类(这个时候createProxy()会重新创建一个实例)。
如果直接在二级缓存中存入bean实例(此时没有被AOP增强)，然后去设置了属性B（B这个时候会去三级缓存中找A(A这个时候没有被AOP增强))，B属性设置完成后，A后面被AOP增强(这个时候A会重新创建)然后放入到单例池，这个时候B中的A就跟单例池里的A不是一个对象了。
这个时候又有一个疑问，既然要提前被AOP包装，为什么不直接把AOP包装后的类放入到二级缓存呢？而要使用三级缓存呢？
这里应该跟spring的设计思想有关，spring想尽可能的按照常规的bean的生命周期来创建bean，除非要解决循环依赖，不然三级缓存的ObjectFactory永远都用不到(二级缓存也用不到)。最后在实例被加入到一级缓存的时候，会把二级缓存和三级缓存中的实例移除。
