1、循环依赖
（1）概念
对象依赖分为强依赖和弱依赖：
强依赖指的是一个对象包含了另外一个对象的引用，例如：学生类中包含了课程类，在学生类中存在课程类的引用
创建课程类：
@Data
public class Course {
private String cname;
private Integer credit;
}
创建学生类：
@Data
public class Student {
private String sname;
private int age;
private Course course;
}
测试类：
public class Test {
public static void main(String[] args) {
Student student=new Student();
Course course=new Course();
student.setCourse(course);
}
}
弱依赖指的是一个对象里面调用了另外一个对象
循环依赖：A引用B，而B又引用A
创建课程类，课程类中有学生类的引用：
@Data
public class Course {
private String cname;
private Integer credit;
private Student student;
}
创建学生类，学生类中存在课程类中的引用：
@Data
public class Student {
private String sname;
private int age;
private Course course;
}
创建测试类，测试类中学生类调用课程类的对象，课程类的对象又调用学生类的对象：
public class Test {
public static void main(String[] args) {
Student student=new Student();
Course course=new Course();
student.setCourse(course);
course.setStudent(student);
}
}
测试类可以正常地获取对象，也就是说这种方式是支持循环依赖的。
（2）spring的循环依赖
<bean id="student" class="com.zhb.bean.Student" scope="singleton">
<property name="course" ref="course"></property>
</bean>
<bean id="course" class="com.zhb.bean.Course" scope="singleton">
<property name="student" ref="student"></property>
</bean>
单例模式下支持，多例模式下不支持
（3）spring是否支持循环依赖
支持
（4）spring的所有对象是不是都支持循环依赖
单例模式下支持：单例模式下是首先创建出两个对象，然后进行依赖的注入。A注入B，B注入A。
多例模式下不支持：A创建的时候会去判断是否依赖于其他对象，如果依赖的话就不会去先创建A。创建B的时候也会去判断是否依赖其他对象，如果A依赖于B，而B又依赖于A的话就会造成一个死循环，两个对象都不会创建。
2、spring循环依赖的过程
（1）流程
（2）源码
ClassPathXmlApplicationContext方法：
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
super(parent);
this.setConfigLocations(configLocations);
if (refresh) {
this.refresh();//refresh方法是真正的创建对象的方法
}
}
refresh方法：
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
this.prepareRefresh();
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
this.prepareBeanFactory(beanFactory);
try {
this.postProcessBeanFactory(beanFactory);
this.invokeBeanFactoryPostProcessors(beanFactory);//Bean工厂的后置处理器
this.registerBeanPostProcessors(beanFactory);
this.initMessageSource();
this.initApplicationEventMulticaster();
this.onRefresh();
this.registerListeners();
this.finishBeanFactoryInitialization(beanFactory);//此方法是真正的创建对象的方法，能够实例化所有的单例bean
this.finishRefresh();
} catch (BeansException var9) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
}
this.destroyBeans();
this.cancelRefresh(var9);
throw var9;
} finally {
this.resetCommonCaches();
}
}
}
finishBeanFactoryInitialization
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
}
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver((strVal) -> {
return this.getEnvironment().resolvePlaceholders(strVal);
});
}
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
String[] var3 = weaverAwareNames;
int var4 = weaverAwareNames.length;
for(int var5 = 0; var5 < var4; ++var5) {
String weaverAwareName = var3[var5];
this.getBean(weaverAwareName);
}
beanFactory.setTempClassLoader((ClassLoader)null);
beanFactory.freezeConfiguration();
beanFactory.preInstantiateSingletons();
}
接口：
void preInstantiateSingletons() throws BeansException;
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Pre-instantiating singletons in " + this);
}
List<String> beanNames = new ArrayList(this.beanDefinitionNames);
Iterator var2 = beanNames.iterator();//取出名字
while(true) {
String beanName;
Object bean;
do {
while(true) {
RootBeanDefinition bd;
do {
do {
do {
if (!var2.hasNext()) {
var2 = beanNames.iterator();
while(var2.hasNext()) {
beanName = (String)var2.next();
Object singletonInstance = this.getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, this.getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
return;
}
beanName = (String)var2.next();
bd = this.getMergedLocalBeanDefinition(beanName);
} while(bd.isAbstract());//单例抽象懒加载
} while(!bd.isSingleton());
} while(bd.isLazyInit());
if (this.isFactoryBean(beanName)) {
bean = this.getBean("&" + beanName);
break;
}
this.getBean(beanName);
}
} while(!(bean instanceof FactoryBean));
FactoryBean<?> factory = (FactoryBean)bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
SmartFactoryBean var10000 = (SmartFactoryBean)factory;
((SmartFactoryBean)factory).getClass();
isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
} else {
isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
}
if (isEagerInit) {
this.getBean(beanName);
}
}
}
getSingleton方法：
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);//
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
synchronized(this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
} return singletonObject;
}
3、怎么避免循环依赖？
三级缓存
- 一级缓存：singletonObjects，存放完全实例化属性赋值完成的Bean，直接可以使用。
- 二级缓存：earlySingletonObjects，存放早期Bean的引用，尚未属性装配的Bean
- 三级缓存：singletonFactories，三级缓存，存放实例化完成的Bean工厂。
假设A依赖B，B依赖A（注意：这里是set属性依赖）分以下步骤执行：
A依次执行doGetBean、查询缓存、createBean创建实例，实例化完成放入三级缓存singletonFactories中，接着执行populateBean方法装配属性，但是发现有一个属性是B的对象。因此再次调用doGetBean方法创建B的实例，依次执行doGetBean、查询缓存、createBean创建实例，实例化完成之后放入三级缓存singletonFactories中，执行populateBean装配属性，但是此时发现有一个属性是A对象。
因此再次调用doGetBean创建A的实例，但是执行到getSingleton查询缓存的时候，从三级缓存中查询到了A的实例(早期引用，未完成属性装配)，此时直接返回A，不用执行后续的流程创建A了，那么B就完成了属性装配，此时是一个完整的对象放入到一级缓存singletonObjects中。
B创建完成了，则A自然完成了属性装配，也创建完成放入了一级缓存singletonObjects中。