3.为啥需要三个缓存
Spring 为啥用三个缓存去解决循环依赖问题？
上面两个缓存的地方，我们只是没有考虑代理的情况。
代理的存在
Bean在创建的最后阶段，会检查是否需要创建代理，如果创建了代理，那么最终返回的就是代理实例的引用。我们通过beanname获取到最终是代理实例的引用
也就是说：上文中，假设A最终会创建代理，提前暴露A的引用， B填充属性时填充的是A的原始对象引用。A最终放入成品库里是代理的引用。那么B中依然是A的早期引用。这种结果最终会与我们的期望的大相径庭了。
怎么办？？？
Spring 是这么做的
=======AbstractAutowireCapableBeanFactory.doCreateBean protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) throws BeanCreationException { 【1】Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { instanceWrapper = createBeanInstance(beanName, mbd, args); } 【早期引用】 final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null); 【2】在需要暴露早期引用的条件下 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { 【2.1】绑定当前Bean引用到ObjectFactory，注册到三级singletonFactories addSingletonFactory(beanName, new ObjectFactory<Object>() { 【重写getObject】 @Override public Object getObject() throws BeansException { return getEarlyBeanReference(beanName, mbd, bean); } }); } } ===AbstractAutowireCapableBeanFactory.doCreateBean--->DefaultSingletonBeanRegistry.getSingleton protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) { synchronized (this.singletonObjects) { if (!this.singletonObjects.containsKey(beanName)) { 【3】放入到singletonFactories 缓存中，清除其他缓存 this.singletonFactories.put(beanName, singletonFactory); this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } } ===========AbstractBeanFactory.doGetBean--->DefaultSingletonBeanRegistry.getSingleton 【4】按Beanname取Bean protected Object getSingleton(String beanName, boolean allowEarlyReference) { 【4.1】先尝试从成品缓存获取 Object singletonObject = this.singletonObjects.get(beanName); 【4.2】成品缓存没有，且正在创建，尝试从半成品缓存获取 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { synchronized (this.singletonObjects) { singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null && allowEarlyReference) { 【4.3】半成品缓存没有，且允许早期引用，尝试从工厂缓存中查找有么此Bean的工厂类存在 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { 【4.4】存在，执行getObject获取早期引用，放入到半成品缓存，并将工厂类从工厂缓存中移除 singletonObject = singletonFactory.getObject(); this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } return (singletonObject != NULL_OBJECT ? singletonObject : null); }
注册 ObjectFactory工厂类到工厂缓存：
singletonFactory.getObject();会调用重写getObject()调用getEarlyBeanReference的后续操作。
- 如果后续操作没有创建代理，
返回的依然是原始引用 - 如果需要代理，在此处
返回就是代理的引用
早期的扩展处理 protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) { Object exposedObject = bean; if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof SmartInstantiationAwareBeanPostProcessor) { SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp; exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName); if (exposedObject == null) { return null; } } } } return exposedObject; }
可以看出此处是执行扩展的操作。
AbstractAutoProxyCreator
【1】针对提前创建代理，返回代理引用 public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException { Object cacheKey = getCacheKey(bean.getClass(), beanName); this.earlyProxyReferences.put(cacheKey, bean); return wrapIfNecessary(bean, beanName, cacheKey); } 【2】针对不是提前创建代理的情况 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean != null) { Object cacheKey = getCacheKey(bean.getClass(), beanName); if (this.earlyProxyReferences.remove(cacheKey) != bean) { return wrapIfNecessary(bean, beanName, cacheKey); } } return bean; }
可以看出singletonFactory工厂缓存，解决了代理问题的关键
大体流程如图
关键点：
- A绑定到ObjectFactory 注册到
工厂缓存singletonFactory中， - B在填充A时，
先查成品缓存有没有，再查半成品缓存有没有，最后看工厂缓存有没有单例工厂类，有A的ObjectFactory。调用getObject ，执行扩展逻辑，可能返回的代理引用，也可能返回原始引用。 - 成功获取到A的早期引用，将A放入到
半成品缓存中，B填充A引用完毕。 - 代理问题， 循环依赖问题都解决了。
四、额外思考的自问自答
在这之外，我还有一些思考，并提出自己的观点。
1：为啥不提前调用ObjectFactory.getObject ()直接执行扩展逻辑处理A的早期引用，得到半成品实例引用放入到earlySingletonObjects中，非要先放一个工厂类到工厂缓存中？使用三级缓存呢？
答：假设A只是依赖B 。如果提前执行A扩展操作，在A创建的后期，还会遍历一遍扩展点，岂不是浪费？
2.二级缓存存在意义是啥？
答：其实吧，我觉得 二级缓存earlySingletonObjects 与 三级缓存singletonFactories 。都是为分工明确而生。
一级缓存singletonObjects： 就是存的最终的成品二级缓存earlySingletonObjects就是为存半成品Bean三级缓存singletonFactories： 就是为存bean工厂
因为是早期暴露，从工厂里创建完成后，是半成品，放入半成品缓存，全部流程执行完时是成品放入到成品缓存。分工明确
这也为什么，我认为叫成品缓存，半成品缓存，单例工厂缓存 更加合适的原因
3.是不是走极端，让我设计此块，我非得设计成单个缓存。提前执行后续操作，把他放到singletonObjects。
好像也没有问题，就是非常乱
五、总结
以上就是我对Spring循环依赖的一些理解与思考
循环依赖的关键点：提前暴露绑定A原始引用的工厂类到工厂缓存。等需要时触发后续操作处理A的早期引用，将处理结果放入二级缓存
