文章目录
一、什么是循环依赖1、代码实例2、重要信息 二、源码分析1、初始化Student对Student中的ClassRoom进行Autowire操作 2、Student的自动注入ClassRoom时，又对ClassRoom的初始化3、ClassRoom的初始化，又执行自动注入Student的逻辑4、Student注入ClassRoom5、初始化完成的Bean放入一级缓存 三、总结1、二级缓存的用处2、汇总流程图！ 参考资料一、什么是循环依赖
多个bean之间相互依赖，形成了一个闭环。 比如:A依赖于B、B依赖于C、C依赖于A。
注意，这里不是函数的循环调用，是对象的相互依赖关系。循环调用其实就是一个死循环，除非有终结条件。
1、代码实例
public class ClassRoom {private String name;@Autowiredprivate Collection<Student> students;// get set}public class Student {private Long id;private String name;@Autowiredprivate ClassRoom classRoom;// get set}
public class CircularReferencesDemo {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();// 注册 Configuration Classcontext.register(CircularReferencesDemo.class);// 如果设置为 false，则抛出异常信息如：currently in creation: Is there an unresolvable circular reference?// 默认值为 truecontext.setAllowCircularReferences(true);// 启动 Spring 应用上下文context.refresh();System.out.println("Student : " + context.getBean(Student.class));System.out.println("ClassRoom : " + context.getBean(ClassRoom.class));// 关闭 Spring 应用上下文context.close();}@Beanpublic static Student student() {Student student = new Student();student.setId(1L);student.setName("张三");return student;}@Beanpublic static ClassRoom classRoom() {ClassRoom classRoom = new ClassRoom();classRoom.setName("C122");return classRoom;}}
我们看到以上实例ClassRoom和Student是互相依赖的。
Spring默认是打开处理循环依赖的开关的，我们可以使用setAllowCircularReferences方法手动设置关闭循环依赖。
开启解决循环依赖之后，以上代码是可以执行没有问题的。关闭循环依赖，以上就会出现循环依赖的异常，如果确认项目中没有循环依赖的问题可以关闭，以提高性能。
2、重要信息
本文的源码都是基于Spring5.2.2版本进行分析的，其他版本或许有些许出入，但是差别不大。
本文所说的循环引用，都是指的是单例Bean，原型Bean不在此分析中。
阅读本文需要明白一些前置知识点：
（1）单例的Bean初始化时机-finishBeanFactoryInitialization方法执行时：
Spring应用上下文生命周期详解及源码分析，Spring IOC容器启动及关闭过程超详细解释（上）
（2）Bean的生命周期需要熟悉：
Spring Bean生命周期——从源码角度详解Spring Bean的生命周期（上）
Spring Bean生命周期——从源码角度详解Spring Bean的生命周期（下）
（3）@Autowire注入流程
@Autowire源码分析，@Autowire是怎么实现依赖注入的
二、源码分析
我们先从IOC容器启动时执行的finishBeanFactoryInitialization方法开始入口，此方法是单例Bean的创建入口，然后执行preInstantiateSingletons方法正是开始创建单例Bean。
// org.springframework.context.support.AbstractApplicationContext#refresh@Overridepublic void refresh() throws BeansException, IllegalStateException {// 省略上面代码// Instantiate all remaining (non-lazy-init) singletons.// 关键方法！完成BeanFactory的初始化finishBeanFactoryInitialization(beanFactory); // 省略下面代码
// org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitializationprotected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// 省略上面代码// Instantiate all remaining (non-lazy-init) singletons.// 关键方法！初始化单例的BeanbeanFactory.preInstantiateSingletons();}
preInstantiateSingletons方法在DefaultListableBeanFactory中进行了实现。
// org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons@Overridepublic void preInstantiateSingletons() throws BeansException {// Trigger initialization of all non-lazy singleton beans...for (String beanName : beanNames) {RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {if (isFactoryBean(beanName)) {Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);if (bean instanceof FactoryBean) {final FactoryBean<?> factory = (FactoryBean<?>) bean;boolean isEagerInit;if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)((SmartFactoryBean<?>) factory)::isEagerInit,getAccessControlContext());}else {isEagerInit = (factory instanceof SmartFactoryBean &&((SmartFactoryBean<?>) factory).isEagerInit());}if (isEagerInit) {getBean(beanName);}}}else {// 关键方法！获取Bean的入口getBean(beanName);}}}// 省略下面代码
1、初始化Student
第一个首先是初始化我们的Student类，getBean会调用doGetBean，然后调用getSingleton方法（重点！解决循环依赖最重要的三级缓存）：
// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)@Nullableprotected Object getSingleton(String beanName, boolean allowEarlyReference) {Object singletonObject = this.singletonObjects.get(beanName); // 一级缓存if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {synchronized (this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName); // 二级缓存if (singletonObject == null && allowEarlyReference) {ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); // 三级缓存if (singletonFactory != null) {singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject;}
第一次调用getSingleton方法不会获取到Bean，获取的是null，走下面的单例bean创建逻辑：
// org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean// 省略上面代码// Create bean instance.if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args); // 关键方法！创建Bean，开始正式进入Bena的生命周期}catch (BeansException ex) {// Explicitly remove instance from singleton cache: It might have been put there// eagerly by the creation process, to allow for circular reference resolution.// Also remove any beans that received a temporary reference to the bean.destroySingleton(beanName);throw ex;}});bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);}// 省略下面代码
createBean方法会调用doCreateBean方法，doCreateBean方法会创建bean的实例，然后完成属性的初始化（@Autowire还未开始），然后会判断如果该Bean正在创建，就会调用addSingletonFactory方法：
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean// 省略上面创建bean的实例，然后完成属性的初始化（@Autowire还未开始）的代码// Eagerly cache singletons to be able to resolve circular references// even when triggered by lifecycle interfaces like BeanFactoryAware.boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// 省略下面@Autowire的代码
我们会发现，此处对allowCircularReferences 进行了判断，假如说我们打开了循环依赖的开关，会走这个逻辑。
addSingletonFactory方法，通过传入的单例对象工厂，
// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonFactoryprotected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(singletonFactory, "Singleton factory must not be null");synchronized (this.singletonObjects) {if (!this.singletonObjects.containsKey(beanName)) {// 判断一级缓存如果不存在this.singletonFactories.put(beanName, singletonFactory); // 放入三级缓存this.earlySingletonObjects.remove(beanName); // 从二级缓存删掉（其实并没有）this.registeredSingletons.add(beanName); // 放入正在注册的单例Bean列表}}}
我们注意到此时Student中的classRoom并没有被注入，但是id和name属性已经被初始化了。
对Student中的ClassRoom进行Autowire操作
我们回到doCreateBean方法，接下来会执行populateBean初始化属性值，会调用@Autowire的处理类AutowiredAnnotationBeanPostProcessor的postProcessProperties方法进行处理@Autowire注入。
// populateBean方法，此处省略部分代码PropertyDescriptor[] filteredPds = null;if (hasInstAwareBpps) {if (pvs == null) {pvs = mbd.getPropertyValues();}for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;// 关键方法！最终调用AutowiredAnnotationBeanPostProcessor的postProcessPropertiesPropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);if (pvsToUse == null) {if (filteredPds == null) {filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);if (pvsToUse == null) {return;}}pvs = pvsToUse;}}}
// org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#postProcessProperties@Overridepublic PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);try {metadata.inject(bean, beanName, pvs); // 关键方法}catch (BeanCreationException ex) {throw ex;}catch (Throwable ex) {throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);}return pvs;}
// org.springframework.beans.factory.annotation.InjectionMetadata#injectpublic void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {Collection<InjectedElement> checkedElements = this.checkedElements;Collection<InjectedElement> elementsToIterate =(checkedElements != null ? checkedElements : this.injectedElements);if (!elementsToIterate.isEmpty()) {for (InjectedElement element : elementsToIterate) {if (logger.isTraceEnabled()) {logger.trace("Processing injected element of bean '" + beanName + "': " + element);}element.inject(target, beanName, pvs); // 关键方法}}}
inject方法此处需要自动注入的是属性，需要获取该属性的value值也就是ClassRoom（此时ClassRoom尚未初始化）。
// org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject// 此处省略部分源码try {// value就是需要获取的ClassRoomvalue = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);}
// org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency@Override@Nullablepublic Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());if (Optional.class == descriptor.getDependencyType()) {return createOptionalDependency(descriptor, requestingBeanName);}else if (ObjectFactory.class == descriptor.getDependencyType() ||ObjectProvider.class == descriptor.getDependencyType()) {return new DependencyObjectProvider(descriptor, requestingBeanName);}else if (javaxInjectProviderClass == descriptor.getDependencyType()) {return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);}else {Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);if (result == null) {// 关键代码！会走该逻辑result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);}return result;}}
// doResolveDependency方法，省略部分源码，会调用resolveCandidateif (instanceCandidate instanceof Class) {instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);}
resolveCandidate会执行beanFactory.getBean方法，又开始了对ClassRoom的getBean操作，开始处理ClassRoom。
// public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)throws BeansException {return beanFactory.getBean(beanName);}
2、Student的自动注入ClassRoom时，又对ClassRoom的初始化
我们跳过上面的分析，来到addSingletonFactory方法：
我们发现，又将ClassRoom放入了三级缓存，此时三级缓存中有了Student和ClassRoom，但是都没有完成对ClassRoom和Student的自动注入工作。
3、ClassRoom的初始化，又执行自动注入Student的逻辑
此时，我们来到ClassRoom的populateBean属性初始化方法，仍然调用AutowiredAnnotationBeanPostProcessor的postProcessProperties方法，来完成对Student的自动注入。
省略我们分析Student的自动注入步骤，我们继续分析，自动注入的过程仍然会调用resolveDependency方法，然后调用doResolveDependency方法，然后调用resolveCandidate方法，又通过beanFactory.getBean来获取Student。
还记得我们上面分析的，doGetBean方法中调用的getSingleton方法的逻辑，此时从三级缓存中已经能够获取到Student了，但是该Student的ClassRoom仍然是null的，但是能够获取到Studen实例，并不影响我们ClassRoom对Student的注入！
// org.springframework.beans.factory.support.AbstractBeanFactory#doGetBeanprotected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {final String beanName = transformedBeanName(name);Object bean;// Eagerly check singleton cache for manually registered singletons.// 关键方法！Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {if (logger.isTraceEnabled()) {if (isSingletonCurrentlyInCreation(beanName)) {logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");}else {logger.trace("Returning cached instance of singleton bean '" + beanName + "'");}}bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);}
从三级缓存中获取到Student后，将Student从三级缓存移出，放入二级缓存。
此时，在ClassRoom的初始化自动注入Student的过程，获取到了我们的Student（还未注入CLassRoom），在Inject方法中，继续执行会发现通过反射，将Student写入了ClassRoom的属性。
// org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject@Overrideprotected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {Field field = (Field) this.member;Object value;if (this.cached) {value = resolvedCachedArgument(beanName, this.cachedFieldValue);}else {DependencyDescriptor desc = new DependencyDescriptor(field, this.required);desc.setContainingClass(bean.getClass());Set<String> autowiredBeanNames = new LinkedHashSet<>(1);Assert.state(beanFactory != null, "No BeanFactory available");TypeConverter typeConverter = beanFactory.getTypeConverter();try {value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);}catch (BeansException ex) {throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);}synchronized (this) {if (!this.cached) {if (value != null || this.required) {this.cachedFieldValue = desc;registerDependentBeans(beanName, autowiredBeanNames);if (autowiredBeanNames.size() == 1) {String autowiredBeanName = autowiredBeanNames.iterator().next();if (beanFactory.containsBean(autowiredBeanName) &&beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {this.cachedFieldValue = new ShortcutDependencyDescriptor(desc, autowiredBeanName, field.getType());}}}else {this.cachedFieldValue = null;}this.cached = true;}}}if (value != null) {ReflectionUtils.makeAccessible(field);field.set(bean, value); // 通过反射写入属性}}
此时完成了ClassRoom的初始化。
4、Student注入ClassRoom
此时ClassRoom在Student初始化过程，完成了初始化并注入Student实例，此时的Student还没有完成对ClassRoom的注入呢！
我们又回到Student的inject方法了（此时相当于是一个递归的过程）。
对ClassRoom的create的过程，会返回创建好的ClassRoom实例（初始化完成也注入完成），正好将ClassRoom注入到Student中。
此时完成对Student和ClassRoom的初始化过程。
也正式解决了Student和ClassRoom的循环依赖问题。
5、初始化完成的Bean放入一级缓存
我们再次回到doGetBean方法，这里调用了getSingleton方法，getSingleton方法最后面的finally中会调用addSingleton方法。
// Create bean instance.if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);}catch (BeansException ex) {// Explicitly remove instance from singleton cache: It might have been put there// eagerly by the creation process, to allow for circular reference resolution.// Also remove any beans that received a temporary reference to the bean.destroySingleton(beanName);throw ex;}});bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);}
addSingleton方法会将Bean放入一级缓存，同时删除二级缓存和三级缓存中的Bean，此时Bean初始化完成，同时也缓存完成，下次获取Bean直接从一级缓存获取即可，提高性能。
// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonprotected void addSingleton(String beanName, Object singletonObject) {synchronized (this.singletonObjects) {this.singletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}
关于Bean的缓存请移步：
Spring中Bean会被缓存吗？Spring的Bean是如何被缓存的？
三、总结
Spring解决循环依赖，正式靠着这三级缓存完成的，相当于一个递归初始化的过程：
在 Spring 底层 IoC 容器 BeanFactory 中处理循环依赖的方法主要借助于以下3个 Map 集合：
singletonObjects（一级 Map），里面保存了所有已经初始化好的单例 BeanearlySingletonObjects（二级 Map），里面会保存从三级 Map获取到的正在初始化的 Bean，保存的同时会移除三级 Map中对应的 ObjectFactory 实现类，在完全初始化好某个 Bean 时会移除二级 Map中对应的早期对象singletonFactories（三级 Map），里面保存了正在初始化的 Bean 对应的 ObjectFactory 实现类，调用其 getObject() 方法返回正在初始化的 Bean 对象（仅实例化还没完全初始化好）
而这三个缓存，其实也就是人们称的三级缓存，其实严格意义上并不能称为“缓存”，这三个缓存其实都是Map：
1、二级缓存的用处
此处解决循环依赖似乎并没有用到二级缓存，那么二级缓存是哪里用到的呢？
因为通过三级 Map获取 Bean 会有相关 SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference 的处理，避免重复处理。
例如在循环依赖中一个 Bean 可能被多个 Bean 依赖， A -> B（也依赖 A） -> C -> A，当你获取 A 这个 Bean 时，后续 B 和 C 都要注入 A，没有上面的二级 Map的话，三级 Map保存的 ObjectFactory 实现类会被调用两次，会重复处理，可能出现问题。这就是为什么需要3个 Map，另外这样做在性能上也有所提升 。
也是为了处理AOP动态代理的问题，也是一个对象被多个对象重复依赖，导致重复创建的问题：
假如 A 需要进行 AOP，因为代理对象每次都是生成不同的对象，如果干掉第二级缓存，只有第一、三级缓存：
B 找到 A 时，直接通过三级缓存的工厂的代理对象，生成对象 A1。
C 找到 A 时，直接通过三级缓存的工厂的代理对象，生成对象 A2。
看到问题没？你通过 A 的工厂的代理对象，生成了两个不同的对象 A1 和 A2，所以为了避免这种问题的出现，我们搞个二级缓存，把 A1 存下来，下次再获取时，直接从二级缓存获取，无需再生成新的代理对象。
2、汇总流程图！
参考资料
spring如何解决循环依赖
源码深度解析，Spring 如何解决循环依赖？
极客时间《小马哥讲 Spring 核心编程思想》
