循环依赖

以及

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()方法：

进行条件断点：

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

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

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

其实这个方法就是去判断该map（singletonCurrentlyInCreation）是否包含该bean？（这里是people）。

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

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

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

这里的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;
}
}

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

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

进入lambda表达式 createBean()

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

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

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

我们看一下singletonObjects（一级缓存），earlySingletonObjects（二级缓存），singletonFactories（三级缓存）。

AbstractAutowireCapableBeanFactory#doCreateBean()中：

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

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