前提：允许bean提前暴露(属性还没有赋值，有空的类对象) ，允许循环依赖 (循环依赖才往三级缓存中添加数据)

 

循环依赖的情况 一 （属性中循环依赖）

例子:

循环依赖

@Component
public class CircleRefA {

    @Autowired
    private CircleRefB circleRefB;
}

@Component
public class CircleRefB {
    @Autowired
    private CircleRefA circleRefA;

    @Autowired
    private CircleRefC circleRefC;
}

@Component
public class CircleRefC {
    @Autowired
    private CircleRefA circleRefA;
}

假设spring中处理顺序为 CircleRefA (beanName为circleRefA ) -》  CircleRefB (beanName为circleRefB )   -》  CircleRefC (beanName为circleRefC) 

先处理CircleRefA

先 getbean(circleRefA)，这时一级缓存singletonObjects中没有对应的类，且 singletonCurrentInCreation 中没有 circleRefA , getbean(beanName) 返回 null ，调用getBean(circleRefA , ObjectFactory) 

　　　　　　　　　　此时先往 singletonCureentInCreation 中加入 circleRefA（表示正在创建 circleRefA 对应的实例） ，再真正创建circleRefA的实例。

　　　　　　　　　　先创建一个属性值为空的A ，在三级缓存中添加circleRefA 对应的 ObjectFactory(此对象，就理解为时 A实例的包装)再进行populateBean进行IOC填充circleRefA 。发现A中有CircleRefB的引用，进行

　　　　　　　　　　 CircleRefB实例化，进行 先 getbean(circleRefB)

 

在进行getbean(circleRefB)，前面的操作一样，后面再进行opulateBean进行IOC填充circleRefB 时，发现B中有CircleRefA的引用，进行getBean(circleRefA) (需要说明的时，属性的编写是认为的，此处可能先进行getBean(circleRefC)，分析一样)

　　　　　　　　　　进行getBean(circleRefA)时，一级缓存singletonObjects中没有对应的类，singetonCureentInCreation中有 circleRefA ；则查找二级缓存earlySingletonObjects ,没有数据；再查找三级缓存，有数据 ，将数据填充到二级缓存

　　　　　　　　　　earlyObjects , 删除三级缓存，返回给B实例进行填充。发现有C类属性，进行 getbean(circleRefC)

 

在进行getbean(circleRefC)，前面操作同getBean(circleRefA)。后面再进行opulateBean进行IOC填充circleRefC 时，发现C中有CircleRefA的引用，进行getBean(circleRefA)  。此时getBean(circleRefA) ，是从二级缓存中拿到的数据 ，返回A对应

　　　　　　　　　　的类。

 

完成 C 的实例化，一级缓存singletonObjects中添加C的实例，删除 singletosCurrentlyInCreation中的circleRefC ，删除三级级缓存中 circleRefC，删除二级缓存 circleRefC。再递归完成 B , A的实例化(同C的实例化)。

 

 

说明：

singletonCureentInCreation 中存bean的名称，表示实例正在创建

这里为什么有一个三级缓存singletonfactories，就是放置早期的bean实例。

为什么有一个二级缓存earlySingletonObjects，其实也是放置早期的bean实例。多次拿  早期的bean实例 这一直接冲这里面拿。

直接放在三级缓存singletonfactories 中 ，不放在earlySingletonObjects中，功能上不是也可以吗？是的

 

但是，其实获取三级缓存的方式是

源码 :  

//添加 三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
        synchronized (this.singletonObjects) {
            // 如果 一级缓存 中不存在
            if (!this.singletonObjects.containsKey(beanName)) {
                // 设置 三级缓存 ，缓存 的 是  singletonFactory 对象
                this.singletonFactories.put(beanName, singletonFactory);
                // 删除 二级缓存
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }

获取三级缓存

ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);

singletonObject = singletonFactory.getObject();
其中

@FunctionalInterface
public interface ObjectFactory<T> {

    /**
     * Return an instance (possibly shared or independent)
     * of the object managed by this factory.
     * @return the resulting instance
     * @throws BeansException in case of creation errors
     */
    T getObject() throws BeansException;

}

 

三级缓存是一个包装bean的实例的对象，singletonFactory.getObject() 是 ，其实是调用的  getEarlyBeanReference(beanName, mbd, bean) ,

    protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                }
            }
        }
        return exposedObject;
    }

这个地方就是预留了一个点位，进行操作 早期的类对象 ，将经过处理(有处理过程，可以放回原始的bean早期类对象，也可能不是，实现BeanPostProcessor接口，重写getEarlyBeanReference就行，完全可以自定义修改) 。

 

就是我们说的三级缓存中，其实可以对 早期的类对象 进行自定已处理 。将处理完的对象 ，放在二级缓存中，若还有循环依赖的 处理 ，拿的是 经过处理的   早期的类对象 

 

说的比较大白话，中间的一些话语 也不是专业术语，能力有限，单大体上就是