Spring Bean循环依赖源码解析

循环依赖

所谓的循环依赖是指，A 依赖 B，B 又依赖 A，它们之间形成了循环依赖。

三级缓存解决循环依赖

Spring通过三级缓存的方式来解决循环依赖的问题。DefaultSingletonBeanRegistry类中的三个缓存变量

//一级缓存：单例缓存池，用于保存所有的完整单例bean 
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

//三级缓存：早期对象包装成ObjectFactory
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

//二级缓存：早期对象，指的是bean刚刚调用了构造方法，还没给bean的属性进行赋值的对象
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

流程梳理

假如存在两个类互相依赖，A 依赖 B，B 又依赖 A，形成循环依赖。

当通过getBean获取A时，先getSingleton从缓存中获取不到，所以通过createBean–>doCreateBean逻辑去进行创建，创建之前通过beforeSingletonCreation标记A正在创建；在doCreateBean中，如果符合条件earlySingletonExposure就把早期对象包装成ObjectFactory暴露到三级缓存singletonFactories中；随后进行属性赋值populateBean，在解析属性时发现依赖B，所以通过getBean去获取B；

通过getBean去获取B和获取A逻辑一样，直到解析属性时发现依赖A，所以再次通过getBean获取A；

再次获取A时，通过getSingleton去缓存中获取，此时一级缓存中还没有A，但是A已经被标记为正在创建，所以会进入if去找二级缓存；二级缓存没有去找三级缓存，从三级缓存中获取到ObjectFactory包装对象，然后获取到早期对象；把早期对象放到二级缓存并删除三级缓存中对象；

第二次获取A完成之后，返回到创建B的操作，将获取到的A赋值到B的a属性，直到创建B完成之后，返回到第一次创建A的操作，将B赋值到A的b属性，直至创建A的操作完成，整个循环依赖处理结束。继续往下走，再次调用getSingleton从二级缓存中获取到A返回。

部分源码

获取Bean对象

Spring通过AbstractBeanFactory#doGetBean来获取Bean对象

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

   ...
   //尝试去缓存中获取对象:一级>二级>三级
   Object sharedInstance = getSingleton(beanName);
   ...
         //创建单例bean
         if (mbd.isSingleton()) {
            //此处getSingleton不同于上面的getSingleton方法：
            //前面的getSingleton主要是从缓存中获取对象，如果有直接返回；
            //后面的getSingleton获取单例对象，用于触发构建bean
            sharedInstance = getSingleton(beanName, () -> {
               try {
                  //进入创建bean的逻辑
                  return createBean(beanName, mbd, args);
               }
         ...
   return (T) bean;     
}

从缓存获取

通过AbstractBeanFactory#getSingleton方法，最终会调用DefaultSingletonBeanRegistry#getSingleton

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   //先从一级缓存中获取
   //第一次进来的时候还获取不到
   Object singletonObject = this.singletonObjects.get(beanName);
   //一级缓存中没有获取到并且该bean处于正在创建阶段
   //第一次进该方法也不是处于正在创建阶段，所以不会走该分支
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         //尝试去二级缓存中获取早期对象
         singletonObject = this.earlySingletonObjects.get(beanName);
         //二级缓存中也没有获取到对象，且allowEarlyReference为true进入if分支
         if (singletonObject == null && allowEarlyReference) {
            //直接从三级缓存中获取ObjectFactory对象
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            //从ObjectFactory对象中获取到早期对象
            if (singletonFactory != null) {
               //在这里通过暴露的ObjectFactory包装对象中,通过调用getObject()来获取早期对象，会调用到getEarlyBeanReference()来进行后置处理
               singletonObject = singletonFactory.getObject();
               //把早期对象放在二级缓存
               this.earlySingletonObjects.put(beanName, singletonObject);
               //ObjectFactory包装对象从三级缓存中删除掉
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

触发构建bean

因为第一次去缓存中获取不到对象，所以还会走下面的getSingleton–>createBean–>doCreateBean逻辑。

在createBean之前把Bean标记成正在创建，作为循环依赖的出口：

  //DefaultSingletonBeanRegistry
	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
     ...
           //标记当前的bean正在被创建
           beforeSingletonCreation(beanName);
           ...
							// 通过钩子方法回调createBean()方法，创建Bean
              singletonObject = singletonFactory.getObject();
    					...
              //加入缓存中
							addSingleton(beanName, singletonObject);  
  }

	protected void beforeSingletonCreation(String beanName) {
    //标记当前的bean正在被创建
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}

	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			//加入到单例缓存池中
			this.singletonObjects.put(beanName, singletonObject);
			//从三级缓存中移除(针对的不是处理循环依赖的)
			this.singletonFactories.remove(beanName);
			//从二级缓存中移除(循环依赖的时候 早期对象存在于二级缓存)
			this.earlySingletonObjects.remove(beanName);
			//用来记录保存已经处理的bean
			this.registeredSingletons.add(beanName);
		}
	}

创建Bean

AbstractAutowireCapableBeanFactory#doCreateBean

  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
        throws BeanCreationException {

     ...

     /**
      * 缓存单例到三级缓存中，以防循环依赖
      * 判断是否能够暴露早期对象的条件:
      * 是否单例
      * 是否允许循环依赖
      * 是否正在创建的Bean
      */
     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
           isSingletonCurrentlyInCreation(beanName));
     //上述条件满足，允许暴露对象
     if (earlySingletonExposure) {
        ...
        //把早期对象包装成一个singletonFactory对象，该对象提供了一个getObject方法，该方法内部调用getEarlyBeanReference方法
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
     ...
        //属性赋值，解析属性时发现循环依赖，会再次调用getBean方法
				populateBean(beanName, mbd, instanceWrapper);
				//对象初始化
				exposedObject = initializeBean(beanName, exposedObject, mbd);
     ...
   if (earlySingletonExposure) {
      //去缓存中获取对象，allowEarlyReference是false，只能在一级二级缓存中去获取
      Object earlySingletonReference = getSingleton(beanName, false);
      ...       
  }

加入三级缓存

DefaultSingletonBeanRegistry#addSingletonFactory

用于把早期对象包装成ObjectFactory暴露到三级缓存singletonFactories中，解决循环依赖

  protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
     Assert.notNull(singletonFactory, "Singleton factory must not be null");
     //同步加锁
     synchronized (this.singletonObjects) {
        //单例缓存池中没有包含当前的bean
        if (!this.singletonObjects.containsKey(beanName)) {
           //加入到三级缓存中，暴露早期对象用于解决循环依赖
           this.singletonFactories.put(beanName, singletonFactory);
           this.earlySingletonObjects.remove(beanName);
           this.registeredSingletons.add(beanName);
        }
     }
  }

其他情况

构造函数的循环依赖：

无法解决。因为构造函数是在实例化过程中，此时还没有实例放入三级缓存中，缓存无法命中，所以无法解决构造器循环依赖。使用@Lazy注解可以解决构造方法造成的循环依赖问题。

多例下的循环依赖

无法解决。多例对象每次都要去创建新对象，所以不会放入缓存中。

暴露早期对象时会判断是否是单例，如果不是单例不会放到三级缓存中。

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
           isSingletonCurrentlyInCreation(beanName));

如果是多例并且正在创建会直接抛异常。

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

二级缓存和三级缓存作用

二级缓存

为了分离完整Bean对象和早期Bean对象(还未属性赋值)， 防止多线程情况下读取到还未创建完成的早期Bean对象。

三级缓存

添加三级缓存：addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));添加的是ObjectFactory，该对象提供了一个getObject方法，调用该方法时内部会调用getEarlyBeanReference方法

当我们从三级缓存中获取该对象时（存在循环依赖时，会在实例化后需要依赖注入时获取；不存在循环依赖时，不会来获取），会调用singletonObject = singletonFactory.getObject();此时就会调用到 getEarlyBeanReference()来进行后置处理；

//通过函数接口回调
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
   Object exposedObject = bean;
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         //判断后置处理器是否实现了SmartInstantiationAwareBeanPostProcessor接口
         if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
            //调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference
            exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
         }
      }
   }
   return exposedObject;
}

实际就是调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference方法。真正实现了该方法的类就是AbstractAutoProxyCreator，也就是通过@EnableAspectJAutoProxy注解导入的AOP核心接口AnnotationAwareAspectJAutoProxyCreator的父类。

也就是说，如果我们当前类没有开启AOP，就不会进入if分支，只是直接return exposedObject（实例化后的原Bean对象），无实际意义。

但是如果开启了AOP，那么此时getEarlyBeanReference返回的就是动态代理对象，而不是实例化后的原对象。正常的aop动态代理创建是在初始化之后，但是如果是循环依赖的Bean使用了aop，就会提前在实例化后直接创建动态代理。

如果不使用三级缓存，直接在二级缓存中，那么在对象实例化后就需要创建动态代理放到二级缓存中，与Spring的AOP设计理念不符。