Spring的循环依赖

Spring的循环依赖

1. 什么是循环依赖?
2. 循环依赖并不能彻底解决，就算非构造方法注入也不能，为什么?
3. "二级缓存"如何解决循环依赖?
4. spring为什么用"三级缓存"去解决循环依赖?
5. 总结"三级缓存"的精妙之处

构建过程：

构造AService对应的bean的过程:

1. 扫描类--->BeanDefinition
2. aService = new aService();//原始对象(每个bean创建时都会生成原始对象，并且放在缓存中)
3. aService填充属性bservice-----------》BService的Bean------------》构造一个BService---------》
4. Aware,init
5. BeanPostProcessor:对前面所生成的对象进行加工 这一步会进行AOP----->生成一个代理对象
6. 单例池(singleTonObjects,beanName:bean对象)

Aservice--->bean对象--->代理对象(最后单例池放的就是代理对象[不是原对象])

构造AService对应的bean的过程:

• 1. 扫描类--->BeanDefinition
• 2. bService = new BService();//原始对象
• 3. bService填充属性aservice-----------》AService的Bean------------》单例池去找？找不到
• 4. Aware,init
• 5. BeanPostProcessor:对前面所生成的对象进行加工
• 6. 单例池(singleTonObjects,beanName:bean对象)

关于替换容器的对象(使用BeanPostProcessy或AOP):

1. BeanPostProcessor:你返回变量是没有返回对应对象的原始对象(就是你替换了接口默认的返回值)，会导致bean的注入失败
2. AOP:如果你使用了aop那么你getBean()时得到的对象是代理对象，这样为什么不会报值的注入异常-----

Spring存在三级缓存(都是Map):

1. 单例池singleTonFactory :已经经历了完整生命周期的bean对象。
2. earlySingleTonFactory（二级缓存）:比singletonObjects多了一个early，表示缓存的是早期的bean对象。早期是什么意思？表示Bean的生命周期还没走完就把这个Bean放入了earlySingletonObjects。缓存提前拿原始对象进行了AOP之后得到的代理对象，原始对象还没有进行属性注入和后续的BeanPostProcessor等生命周期
3. 单例对象工厂(singleTonFactory) :缓存的是一个ObjectFactory，主要用来去生成原始对象进行了AOP之后得到的代理对象，在每个Bean的生成过程中，都会提前暴露一个工厂，这个**工厂可能用到，也可能用不到**，如果没有出现循环依赖依赖本bean，那么这个工厂无用，本bean按照自己的生命周期执行，执行完后直接把本bean放入singletonObjects中即可，如果出现了循环依赖依赖了本bean，则另外那个bean执行ObjectFactory提交得到一个AOP之后的代理对象(如果有AOP的话，如果无需AOP，则直接得到一个原始对象)。

三级缓存处理逻辑的代码:

    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                //没有earlySingleTonObjects会怎么样
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    //为什么需要singleTonFactories
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        /*
                            就是执行()->getEarlyBeanReference(beanName,mbd,bean原始对象),执行这段lamda表达式就是得到一个代理对象(cglib代理，此时他的原始对象还没有赋值)
                        */
                        singletonObject = singletonFactory.getObject();//AOP代理
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

第三级缓存(singleTonFactories)如何解决循环依赖的:

顺序:

singletonFactories----》根据beanName得到一个objectFactory-(就是调用getEarlyBeanReference)----》此时我得到了一个A原始对象经过AOP之后的代理对象---------》将代理对象添加到earlySingletonObject(第二级缓存)------》此时就会将这个添加的代理对象填充到你的bean的属性中-----》最后填充好属性的bean在走一下AOP判断和BeanPostProcess的执行流程-----》放入到单例池

解决详情:

从singletonFactories根据beanName得到一个ObjectFactory，然后执行ObjectFactory，也就是执行getEarlyBeanReference方法，此时会得到一个A原始对象经过AOP之后的代理对象，然后把该代理对象放入earlySingletonObjects中，注意此时并没有把代理对象放入singletonObjects中，那什么时候放入到singletonObjects中呢？

我们这个时候得来理解一下earlySingletonObjects的作用，此时，我们只得到了A原始对象的代理对象，这个对象还不完整，因为A原始对象还没有进行属性填充，所以此时不能直接把A的代理对象放入singletonObjects中，所以只能把代理对象放入earlySingletonObjects，假设现在有其他对象依赖了A，那么则可以从earlySingletonObjects中得到A原始对象的代理对象了，并且是A的同一个代理对象。

当B创建完了之后，A继续进行生命周期，而A在完成属性注入后，会按照它本身的逻辑去进行AOP，而此时我们知道A原始对象已经经历过了AOP，所以对于A本身而言，不会再去进行AOP了，那么怎么判断一个对象是否经历过了AOP呢？会利用上文提到的earlyProxyReferences，在AbstractAutoProxyCreator的postProcessAfterInitialization方法中，会去判断当前beanName是否在earlyProxyReferences，如果在则表示已经提前进行过AOP了，无需再次进行AOP。

对于A而言，进行了AOP的判断后，以及BeanPostProcessor的执行之后，就需要把A对应的对象放入singletonObjects中了，但是我们知道，应该是要A的代理对象放入singletonObjects中，所以此时需要从earlySingletonObjects中得到代理对象，然后入singletonObjects中。