循环依赖

以及

spring是如何解决循环依赖的

循环依赖

通俗来说

就是beanA中依赖了beanB,beanB中也依赖了beanA。

spring是支持循环依赖的,但是默认只支持单例的循环依赖,如果bean中依赖了原型bean,则需要加上lookup方法。

继续之前的项目,改造了People,User类:

@Component
public class People {
@Autowired
private User user;
public People(){
System.out.println("create People");
}
}
@Component
public class User {
@Autowired
private People people;
public User(){
System.out.println("create User");
}
}

People--(依赖)-->User--(依赖)-->People--(依赖)-->User.......,这就形成了循环依赖。

继续进入上篇的preInstantiateSingletons()方法:

Spring Boot源码(七):循环依赖-LMLPHP

进行条件断点:

Spring Boot源码(七):循环依赖-LMLPHP

Spring Boot源码(七):循环依赖-LMLPHP

进入上篇说的getSingleTon()方法:

Spring Boot源码(七):循环依赖-LMLPHP

singletonObjects是spring的单例池,从其中没有拿到bean,singletonObject为null,且isSingletonCurrentlyInCreation()为false。

public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}

其实这个方法就是去判断该map(singletonCurrentlyInCreation)是否包含该bean?(这里是people)。

这个方法通俗意思就是 “该bean是否在创建过程中?”

先不管这个意思,继续往下走。

spring创建对象前还会做很多判断,例如是否为原型,是否抽象?

Spring Boot源码(七):循环依赖-LMLPHP

这里的getSingleton(String beanName, ObjectFactory<?> singletonFactory)是重载,与之前的getSingleton(String beanName, boolean allowEarlyReference)不同。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}

Spring Boot源码(七):循环依赖-LMLPHP

protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}

此方法把 “people”放入singletonsCurrentlyInCreation中,那么isSingletonCurrentlyInCreation("people")这时为true

Spring Boot源码(七):循环依赖-LMLPHP

进入lambda表达式 createBean()

create People Object ----注入依赖发现依赖User--->create User Object---发现依赖People---create People Object---发现isSingletonCurrentlyInCreation(beanName)为true,表示正在创建People:

Spring Boot源码(七):循环依赖-LMLPHP

然后才会执行里面的代码:

Spring Boot源码(七):循环依赖-LMLPHP

allowEarlyReference 是否允许从singletonFactories中通过getObject拿到对象,也就是执行if中的方法。

我们看一下singletonObjects(一级缓存),earlySingletonObjects(二级缓存),singletonFactories(三级缓存)。

AbstractAutowireCapableBeanFactory#doCreateBean()中:

Spring Boot源码(七):循环依赖-LMLPHP

Spring Boot源码(七):循环依赖-LMLPHP

这时候存进去的并不是完整的bean:

Spring Boot源码(七):循环依赖-LMLPHP

但是可以供User依赖注入了,这也就是spring对循环依赖的解决。

05-26 23:27