原来Spring是这样解决循环依赖的

╰+攻爆jí腚メ 2022-11-24 15:29 205阅读 0赞

##### 什么是循环依赖 #####

通常来说，Spring循环依赖的场景一般是单例Bean。

*  几个Bean之间的循环依赖

@Component
    public class A {
    
        @Autowired
        private B b;
    }
    
    @Component
    public class B {
    
        @Autowired
        private C c;
    }
    
    @Component
    public class C {
    
        @Autowired
        private A a;
    }

效果图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70]

*  自己依赖自己

@Component
    public class A {
    
        @Autowired
        private A a;
    }

效果图如下：  
![在这里插入图片描述][20200806174324488.png]  
先说明前提：原型(Prototype)的场景是不支持循环依赖的，通常会走到AbstractBeanFactory类中下面的判断，抛出异常。

当创建A的时候，发现要注入原型字段B，又创建新的B发现要注入原型字段A，这个时候就会抛出`BeanCurrentlyInCreationException`异常。

if (isPrototypeCurrentlyInCreation(beanName)) {
      throw new BeanCurrentlyInCreationException(beanName);
    }

##### 举个栗子 #####

IOC 容器在读到上面的配置时，会按照顺序，先去实例化 beanA。然后发现 beanA 依赖于 beanB，接在又去实例化 beanB。实例化 beanB 时，发现 beanB 又依赖于 beanA。如果容器不处理循环依赖的话，容器会无限执行上面的流程，直到内存溢出，程序崩溃。

当然，Spring 是不会让这种情况发生的。在容器再次发现 beanB 依赖于 beanA 时，容器会获取 beanA 对象的一个早期的引用（early reference），并把这个早期引用注入到 beanB 中，让 beanB 先完成实例化。beanB 完成实例化，beanA 就可以获取到 beanB 的引用，beanA 随之完成实例化。

##### Spring是如何解决循环依赖的 #####

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    
    	/** Cache of singleton objects: bean name to bean instance. */
    	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    	/** Cache of singleton factories: bean name to ObjectFactory. */
    	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    
    	/** Cache of early singleton objects: bean name to bean instance. */
    	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
    
    	// 。。。
    }

首先Spring维护了三个Map，也就是我们通常说的三级缓存。

*  `singletonObjects`：俗称单例池，缓存创建完成的单例Bean。
 *  `singletonFactories`：映射创建Bean的原始工厂。
 *  `earlySingletonObjects`：映射Bean的早期引用，也就是说这个Map里的Bean不是完整的，只是完成了实例化，但还没有初始化。

Spring通过三级缓存解决了循环依赖，其中一级缓存为单例池（singletonObjects），二级缓存为早期曝光对象earlySingletonObjects，三级缓存为早期曝光对象工厂（singletonFactories）。

当A、B两个类发生循环引用时，在A完成实例化后，就使用实例化后的对象去创建一个对象工厂，并添加到三级缓存中，如果A被AOP代理，那么通过这个工厂获取到的就是A代理后的对象，如果A没有被AOP代理，那么这个工厂获取到的就是A实例化的对象。

当A进行属性注入时，会去创建B，同时B又依赖了A，所以创建B的同时又会去调用getBean(a)来获取需要的依赖，此时的getBean(a)会从缓存中获取，第一步，先获取到三级缓存中的工厂；第二步，调用对象工工厂的getObject方法来获取到对应的对象，得到这个对象后将其注入到B中。

紧接着B会走完它的生命周期流程，包括初始化、后置处理器等。当B创建完后，会将B再注入到A中，此时A再完成它的整个生命周期。至此，循环依赖结束！

简单一句话说：`先去缓存里找Bean，没有则实例化当前的Bean放到Map，如果有需要依赖当前Bean的，就能从Map取到`。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70]: /images/20221124/18e6aca5b22d4566a3c3e0be7085450b.png
[20200806174324488.png]: /images/20221124/334bddd665ed466f9dd8c53eeefbd1fa.png