Spring为什么需要使用三级缓存？

有如下一个场景，X类中注入了Y类，Y类注入了X类，按照正常的类加载顺序，X类在注入Y的时候其实还没完全初始化完成，而注入的Y此时就开始实例化，发现也需要用到X，这是就去获取X，但是X并没有初始化完成，这个时候就会出现X在等Y初始化完成，而Y又在等X初始化完成，就进入了一个互相等待的情况。

Spring是如何避免这种情况的呢？那就是三级缓存。

先来说说Spring有哪三级缓存。

一级缓存 singletonObject ：单例对象集合；
二级缓存 earlySingletonObjects ：早期单例对象集合，也就是对象还没有完全初始化；
三级缓存 singletonFactories ：单例对象工厂集合，里面存储的是对象封装后的ObjectFactory。

Spring实现流程：

X实例化完成；
检测到支持循环依赖，将X实例化的对象封装成ObjectFactory放入三级缓存中；
populateBean渲染X对象，对属性Y进行注入；
获取Y对象，getSingleton返回null；
对Y进行实例化；
将Y实例化后的对象封装成ObjectFactory放入三级缓存；
populateBean渲染Y对象，对属性X进行注入；
获取X对象，getSingleton返回之前三级缓存中存储的对象，并将对象放入二级缓存；
返回二级缓存中的X；
Y初始化完成，返回Y；
X初始化完成。

为什么一定要使用三级缓存（singletonFactories）？

可以思考下，如果只有两级缓存，在进行对象注入的时候，给属性注入的就是原始对象。但是，在AOP场景下，对象可能是一个代理对象，这个时候注入就应该是一个代理对象而不是原始对象。

三级缓存也就是这个原因存储的是一个ObjectFactory，而不是Object；

当循环依赖过程中，对象第二次进入getBean流程时就需要用到三级缓存中对象，就会调用getObject方法返回一个封装后的对象，而对象既可能是原始对象，也可能是代理对象，再将这个对象返回给需要注入的类。

getObject会对对象进行一系列的包装然后返回。Spring中利用lambda表达式的形式声明，具体实现如下：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {// 默认最终公开的对象是bean,通过createBeanInstance创建出来的普通对象Object exposedObject = bean;// mbd的systhetic属性：设置此bean定义是否是"synthetic"，一般是指只有AOP相关的pointCut配置或者Advice配置才会将 synthetic设置为true// 如果mdb不是synthetic且此工厂拥有InstantiationAwareBeanPostProcessorif (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {// 遍历工厂内的所有后处理器for (BeanPostProcessor bp : getBeanPostProcessors()) {// 如果bp是SmartInstantiationAwareBeanPostProcessor实例if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;// 让exposedObject经过每个SmartInstantiationAwareBeanPostProcessor的包装exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);}}}// 返回最终经过层次包装后的对象return exposedObject;
}

Spring调用注册的BeanPostProcessor的getEarlyBeanReference方法来对对象进行包装，最后返回经过包装的对象。

AnnotationAwareAspectJAutoProxyCreator处理器是Spring用来进行AOP处理的，继承了SmartInstantiationAwareBeanPostProcessor类，getEarlyBeanReference方法如下：

public Object getEarlyBeanReference(Object bean, String beanName) {Object cacheKey = getCacheKey(bean.getClass(), beanName);this.earlyProxyReferences.put(cacheKey, bean);return wrapIfNecessary(bean, beanName, cacheKey);
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {// 如果已经处理过，直接返回if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {return bean;}// 这里advisedBeans缓存了已经进行了代理的bean，如果缓存中存在，则可以直接返回if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {return bean;}// 这里isInfrastructureClass()用于判断当前bean是否为Spring系统自带的bean，自带的bean是// 不用进行代理的；shouldSkip()则用于判断当前bean是否应该被略过if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {// 对当前bean进行缓存this.advisedBeans.put(cacheKey, Boolean.FALSE);return bean;}// 获取符合对应类的Advisor，如果没有类没有符合的aop就会返回空集合Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);// 对当前bean的代理状态进行缓存// 生成对应的代理对象if (specificInterceptors != DO_NOT_PROXY) {// 对当前bean的代理状态进行缓存this.advisedBeans.put(cacheKey, Boolean.TRUE);// 根据获取到的Advices和Advisors为当前bean生成代理对象Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));// 缓存生成的代理bean的类型，并且返回生成的代理beanthis.proxyTypes.put(cacheKey, proxy.getClass());return proxy;}// 正常无需代理的对象直接返回beanthis.advisedBeans.put(cacheKey, Boolean.FALSE);return bean;
}

wrapIfNecessary方法和普通AOP在初始化方法中执行postProcessAfterInitialization是一样的，会先获取到类对应的Advisor，然后根据策略生成对应的代理工厂和代理类，当没有Advisor时，也就不会进行代理处理。

当有AOP场景下的类具有循环依赖的情况时，就会将代理对象的生成提前到初始化之前，对象注入的时候。

PS ： AOP处理器postProcessAfterInitialization实现

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {if (bean != null) {// 获取当前bean的key：如果beanName不为空，则以beanName为key，如果为FactoryBean类型，// 前面还会添加&符号，如果beanName为空，则以当前bean对应的class为keyObject cacheKey = getCacheKey(bean.getClass(), beanName);// 判断当前bean是否正在被代理，如果正在被代理则不进行封装if (this.earlyProxyReferences.remove(cacheKey) != bean) {// 如果它需要被代理，则需要封装指定的beanreturn wrapIfNecessary(bean, beanName, cacheKey);}}return bean;
}