1.什么是循环依赖
在Java中,我们可以使用如下方式,使得两个Service互相持有,代码如下:
typescript
代码解读
复制代码
@Component public class AService { private BService bService; @Autowired public void setBService(BService bService) { this.bService = bService; } } @Component public class BService { private AService aService; @Autowired public void setAService(AService aService) { this.aService = aService; } } public class Logic { public static void main(String[] args) { AService aService = new AService(); BService bService = new BService(); aService.setBService(bService); bService.setAService(aService); } }
但Logic#main()这种情况并不会由于循环依赖而导致死循环等问题,循环依赖的问题主要在依赖注入(DI)框架如Spring中出现,为什么这么说呢?
通过Bean的生命周期,我们知道Bean的创建有BeanDefinition加载、Bean实例化、属性填充(依赖注入)、初始化的过程,在BeanDefinition加载、Bean实例化过程中并不会有问题,关键在于属性填充(依赖注入)这步,这步完成了注入点的值注入。值注入前需要先找到要注入的Bean,并将要注入的Bean完成创建流程,在这个过程中,如果Bean之间存在循环依赖且没有其他处理,就会导致死循环的问题,具体如下图所示:
2.如何解决循环依赖
通过上面的循环依赖生成图中,我们发现要解决这个问题,对于依赖的对象是单例对象的情况下,引入一个中间缓存即可,对于依赖的对象是多例对象的情况下,无法解决。接下来进行两种情况的分析。
2.1 单例对象
2.1.1 依赖单例普通对象
对于依赖的对象是单例对象的情况下,引入的中间缓存先将其称之为earlySingletonObjects,即将创建的AService实例(半成品)保存到中间缓存earlySingletonObjects中,当创建BService实例进行依赖注入的过程中,将AService实例(半成品)传给BService即可,如下图所示:
通过中间缓存earlySingletonObjects,打破了循环依赖中创建依赖对象时还需重新创建原对象的问题,使得循环依赖得到解决。
2.1.2 依赖单例代理对象
通过上述方式,解决了原始对象循环依赖注入的问题,但Bean如果需要被代理,在创建过程的初始化后步骤中会创建对应代理对象返回给外部使用,因此上述方式过程给BService赋值的AService对象,与最终创建的AService并不是一个,会导致逻辑执行不一致。要解决这个问题有两种方法解决:
方法①:提前完成AService代理对象的创建并放到中间缓存中;
方法②:提供一个Bean工厂,用于创建AService代理对象。
方法①的提前完成AService代理对象的创建并放到中间缓存中的方式,会使得原本Bean的实例化、属性填充(依赖注入)、初始化(初始化前、初始化、初始化后)的流程变得复杂且不清晰不易理解,即当发生循环依赖时,会变成实例化、初始化后(创建代理对象)、属性填充(依赖注入)、初始化(初始化前、初始化、初始化后)的流程,因此此方法并不合适。
方法②的提供一个Bean工厂,用于创建AService代理对象,即在AService对象实例化后,提供一个Bean工厂,存放到中间缓存中,先将其称之为singletonFactories,接着执行到属性填充(依赖注入)步骤的创建BService过程中,通过从中间缓存singletonFactories中取得Bean工厂并执行创建对象的方法,从而得到AService对象的代理对象,完成BService的属性填充(依赖注入)步骤,进而完成BService对象的创建,使得循环依赖得到解决。整体步骤如下图所示:
通过earlySingletonObjects、singletonFactories两个中间缓存,分别解决了基础对象循环依赖、代理对象循环依赖的问题,但实际使用过程中,这两种情况是并存的,因此需要一套流程,将两种情况兼容。
2.1.3 同时依赖普通/代理对象
从代理对象循环依赖流程中我们发现Bean工厂是用于创建代理对象的,得到的结果也是一个Bean,而普通对象循环依赖流程中中间缓存earlySingletonObjects存放的也是对象,因此将singletonFactories作为earlySingletonObjects的底层缓存即可得到兼容两种情况的流程,具体如下图所示:
整理了一份核心面试笔记包括了:Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题
需要全套面试笔记的【点击此处即可】即可免费获取
2.2 多例对象
如果AService和BService均是多例对象,意味着Bean的属性填充(依赖注入)步骤发现依赖对象未创建时,必须调用对应创建方法,完成对象创建后进行注入才行,而新创建的对象不能用于下次依赖注入,也就无法存入缓存中进行复用,因此无法解决循环依赖中依赖多例对象的情况。
2.3 其他无法解决的循环依赖情况
我们知道依赖注入的方式有:
- 构造器注入
- 属性注入
- 字段注入
- 方法参数注入
其中Bean的实例化需要执行构造方法才能完成,且实例化在属性填充(依赖注入)之前,因此构造器注入上的循环依赖无法解决,其余集中情况均可在Bean实例化后的属性填充(依赖注入)环节完成,因此可以解决。
3.源码分析
通过上述过程,我们分析了循环依赖的解决方法,接下来将深入Spring源码,看看Spring是如何解决的,源码基于Spring5.3.37版本进行分析。
3.1 三级缓存
通过Bean的生命周期我们知道了AbstractBeanFactory#doGetBean()完成了Bean的获取(创建),因此从这个方法作为入口进行分析,其中关于缓存相关源码如下:
java
代码解读
复制代码
protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { // 省略部分代码... // 先从缓存中尝试获取单例Bean,获取的Bean有可能是完整Bean,也可能是Bean(半成品) Object sharedInstance = getSingleton(beanName); // 省略部分Bean创建相关的代码... }
我们可以看到在创建Bean之前,调用AbstractBeanFactory#getSingleton(String beanName)方法从缓存中尝试获取单例Bean,该方法内部调用了AbstractBeanFactory#getSingleton(String beanName, boolean allowEarlyReference)方法,该方法的源码如下:
java
代码解读
复制代码
protected Object getSingleton(String beanName, boolean allowEarlyReference) { // 先从singletonObjects缓存中尝试获取完整的Bean对象 Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { // 如果当前Bean处于正在创建中,则尝试从earlySingletonObjects缓存中获取Bean对象 singletonObject = this.earlySingletonObjects.get(beanName); // 若获取的依旧是空,且支持创建早期引用,则尝试从singletonFactories缓存中获取Bean对象 if (singletonObject == null && allowEarlyReference) { synchronized (this.singletonObjects) { // 再次尝试从singletonObjects缓存中尝试获取完整的Bean对象,因为可能存在其他线程创建完了该对象 singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { // 再次尝试从earlySingletonObjects缓存中获取Bean对象 singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null) { // 获取Bean工厂 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { // 调用Bean工厂的getObject()方法获取Bean对象 singletonObject = singletonFactory.getObject(); // 将获取的Bean对象放到earlySingletonObjects缓存中 this.earlySingletonObjects.put(beanName, singletonObject); // 将当前Bean对应的Bean工厂从singletonFactories缓存中移除 this.singletonFactories.remove(beanName); } } } } } } return singletonObject; }
从此处,我们发现了三个缓存,分别是:singletonObjects、earlySingletonObjects、singletonFactories,三者之间是递进关系,我们将其称之为三级缓存。其中earlySingletonObjects、singletonFactories与第二节分析解决循环依赖引入缓存一样,分别存放的是Bean对象(半成品)、Bean工厂,此处我们发现earlySingletonObjects的Bean对象(半成品)来自于从singletonFactories的Bean工厂创建的Bean对象,因此若singletonFactories不存在对应Bean的Bean工厂,则earlySingletonObjects也将没有Bean对象(半成品);singletonObjects则是存放的最终完整版Bean对象,供后续使用。
3.2 singletonFactories
singletonFactories是在AbstractAutowireCapableBeanFactory#doCreateBean()方法中添加的Bean工厂,此方法作为Bean对象创建的入口方法,包含了Bean实例的创建、属性填充(依赖注入)、初始化步骤,这些均在《Spring源码之Bean的生命周期》中分析过,因此此处重点分析singletonFactories的值的来源,其核心源码如下:
java
代码解读
复制代码
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // 省略部分代码... if (instanceWrapper == null) { // 创建Bean实例 instanceWrapper = createBeanInstance(beanName, mbd, args); } // 省略部分代码... boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { // 省略日志代码... // 如果当前Bean是单例Bean且配置了允许循环依赖,且当前Bean正在创建中, // Bean正在创建中,意味着Bean创建了一半,重新调用了Bean的创建方法来创建依赖对象 // 则将包含当前Bean对象(半成品)BeanFactory匿名对象放到singletonFactories缓存中 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { // 属性填充(依赖注入) populateBean(beanName, mbd, instanceWrapper); // 初始化 exposedObject = initializeBean(beanName, exposedObject, mbd); } // 省略部分代码... if (earlySingletonExposure) { // 如果当前Bean是单例Bean且配置了允许循环依赖,且当前Bean正在创建中,再次尝试获取Bean对象 // 此时可以从earlySingletonObjects中获取的Bean对象(半成品),因为在创建依赖对象过程中执行了BeanFactory Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { // 此处大部分情况下是相等,即使存在创建代理对象的过程, // 因为在创建依赖对象时创建了当前Bean的代理对象, // AbstractAutoProxyCreator#postProcessAfterInitialization()方法中将会将原始Bean对象直接返回 if (exposedObject == bean) { // 因为发生循环依赖时,代理对象放到了earlySingletonObjects中, // 所以需要再次赋值,将代理对象赋值给exposedObject并返回给上层方法 exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { // 省略抛出异常代码... } } } } // Register bean as disposable. try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }
本方法总结下来就是:如果当前Bean是单例Bean且配置了允许循环依赖,且当前Bean正在创建中,则将包含当前Bean对象(半成品)BeanFactory匿名对象放到singletonFactories缓存中。如果存在创建代理对象的过程,则在Bean初始化完成后,返回前,需要将代理对象(完整)从earlySingletonObjects取出并返回。此处还引入了singletonsCurrentlyInCreation缓存,用于存储创建中的Bean名称,便于Bean创建流程中的相关判断。
关于() -> getEarlyBeanReference(beanName, mbd, bean)部分对应的核心源码如下:
java
代码解读
复制代码
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) { Object exposedObject = bean; if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) { exposedObject = bp.getEarlyBeanReference(exposedObject, beanName); } } return exposedObject; }
其内部实际调用的是AbstractAutoProxyCreator#getEarlyBeanReference()方法,其核心源码如下:
java
代码解读
复制代码
public Object getEarlyBeanReference(Object bean, String beanName) { Object cacheKey = getCacheKey(bean.getClass(), beanName); // 将当前对象放到earlyProxyReferences缓存中, // 用于后续AbstractAutoProxyCreator#postProcessAfterInitialization()避免再次生成代理对象 this.earlyProxyReferences.put(cacheKey, bean); // 创建代理对象 return wrapIfNecessary(bean, beanName, cacheKey); }
其中关于创建代理对象(AOP)的核心AbstractAutoProxyCreator#postProcessAfterInitialization()将于后续进行深入分析。其内部通过earlyProxyReferences缓存避免了代理对象被提前创建后的再次创建,其核心源码如下:
java
代码解读
复制代码
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) { if (bean != null) { Object cacheKey = getCacheKey(bean.getClass(), beanName); // 如果earlyProxyReferences中不存在当前Bean,才会走代理对象创建过程 if (this.earlyProxyReferences.remove(cacheKey) != bean) { return wrapIfNecessary(bean, beanName, cacheKey); } } return bean; }
3.3 singletonObjects
通过AbstractAutowireCapableBeanFactory#doCreateBean()完成了Bean的完整创建,得到了完整的Bean对象,此时需要将完整的Bean对象放置到singletonObjects缓存中,对应逻辑在DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法中,其核心源码如下:
java
代码解读
复制代码
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); synchronized (this.singletonObjects) { // 首先尝试从singletonObjects缓存中获取Bean对象 Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { // 省略部分代码... // 此处为调用AbstractAutowireCapableBeanFactory#createBean()得到Bean对象 singletonObject = singletonFactory.getObject(); newSingleton = true; } // 省略部分代码... if (newSingleton) { // 添加到singletonObjects缓存中 addSingleton(beanName, singletonObject); } } return singletonObject; } }
4.总结
在Spring中,通过引入singletonsCurrentlyInCreation、singletonObjects、earlySingletonObjects、singletonFactories、earlyProxyReferences缓存,解决普通/代理对象的循环依赖问题。无法解决的循环依赖情况有:①构造方法注入;②依赖与被依赖的Bean均为多例Bean。
singletonsCurrentlyInCreation
在DefaultSingletonBeanRegistry类中定义,类型为Set,存放了正在创建的Bean名称,用于循环依赖过程中判断Bean是否正在创建中。
singletonObjects
在DefaultSingletonBeanRegistry类中定义,类型为Map<String, Object>,作为一级缓存,存放了创建完成(经过实例化、依赖注入、初始化)的完整Bean对象(普通或代理对象),用于后续其他Bean创建获取依赖及运行过程中获取要使用的单例Bean。
earlySingletonObjects
在DefaultSingletonBeanRegistry类中定义,类型为Map<String, Object>,作为二级缓存,存放了半成品的Bean对象(经过实例化),若不存在循环依赖则此缓存为空。当对应Bean对象(半成品)经过依赖注入、初始化流程后,将自动变成完整的Bean对象(Java对象引用的作用)。
singletonFactories
在DefaultSingletonBeanRegistry类中定义,类型为Map<String, ObjectFactory<?>>,作为三级缓存,存放了BeanFactory,在需要动态代理的情况下为原始对象生成代理对象并返回,否则返回原始对象。用于延迟代理对象的创建。此缓存作为兼容普通/代理对象获取逻辑的缓存,避免了对创建代理对象(Spring的Bean生命周期中AOP(初始化后))的流程调整,保证了Bean生命周期的清晰与完整。
earlyProxyReferences
在AbstractAutoProxyCreator类中定义,类型为Map<Object, Object>,存放了提前创建了代理对象的原始普通Bean对象,该缓存在Bean生命周期的初始化后阶段中的AbstractAutoProxyCreator#postProcessAfterInitialization()方法中被移除,用于避免初始化后的AOP流程中重复创建代理对象。