一篇文章搞懂Spring单例循环依赖加载

一篇文章搞懂Spring单例循环依赖加载

上一篇文章搞懂Spring ApplicationContext加载过程主要讲了ApplicationContext中refresh()方法的源码，提到了在BeanFactory加载完的最后会调用DefaultListableBeanFactory.preInstantiateSingletons()方法预加载单例Bean。本篇文章继续看一下DefaultListableBeanFactory.preInstantiateSingletons()方法的源码，最终调用的是AbstractBeanFactory.doGetBean()方法、顺便解读Spring处理循环依赖的相关源码。相关源码可以从AbstractBeanFactory.doGetBean()作为入口往下看。

1. DefaultSingletonBeanRegistry.getSingleton(String beanName)

@Nullable
    public Object getSingleton(String beanName) {
        return this.getSingleton(beanName, true);
    }

    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                synchronized(this.singletonObjects) {
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                singletonObject = singletonFactory.getObject();
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        return singletonObject;
    }

这段代码是获取单例bean的关键代码，主要逻辑是：
尝试从一级缓存this.singletonObjects中获取bean->若获取失败则尝试从二级缓存this.earlySingletonObjects获取bean->若还是获取失败，则从this.singletonFactories获取对应的ObjectFactory，调用其get方法，最后把获取到的实例塞到earlySingletonObjects中。
当时看到这段代码我有以下这些疑问：
1、对应Bean的ObjectFactory是在哪初始化，塞到singletonFactories中的呢？
2、为啥获取到实例后是添加到earlySingletonObjects中而不是singletonObjects呢？
带着这些疑问，我在后面的代码中找到答案，在AbstractAutowireCapableBeanFactory.doCreateBean()中：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
......
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }

            this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
            });
        }
......
}

比如有以下循环依赖：A->B->A，则加载A时，会先把A设置为SingletonCurrentlyInCreation状态，然后加载B，把B设置为SingletonCurrentlyInCreation状态，发现B依赖A，此时又会去加载A，发现A是在SingletonCurrentlyInCreation状态，发生了循环依赖，Spring就是通过SingletonCurrentlyInCreation这个状态来判断是否发生循环依赖的。结合以上代码，发生循环依赖后，就会调用this.getEarlyBeanReference(beanName, mbd, bean);方法来生成临时实例，整个过程是个递归的过程。
注：之前一直有个疑问，就是getSingleton方法中怎么保证我获取的beanA跟一开始加载的bean是同一个bean，一开始以为是通过缓存实现的，找了半天没找到，后面发现是通过闭包实现的：

this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
})

这里设置ObjectFactory的时候把当前的bean传入了
调用流程图：

为何是三级缓存？

Spring 单例加载有三级缓存，分别是：
一级：final Map<String, Object> singletonObjects
二级：Map<String, Object> earlySingletonObjects
三级：Map<String, ObjectFactory<?>> singletonFactories
其实理论上二级缓存就可以解决循环依赖的问题，那为什么引入三级缓存呢？
主要是为了处理InstantiationAwareBeanPostProcessors，看一下代码：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        SmartInstantiationAwareBeanPostProcessor bp;
        if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
            for(Iterator var5 = this.getBeanPostProcessorCache().smartInstantiationAware.iterator(); var5.hasNext(); exposedObject = bp.getEarlyBeanReference(exposedObject, beanName)) {
                bp = (SmartInstantiationAwareBeanPostProcessor)var5.next();
            }
        }

        return exposedObject;
    }

若存在循环依赖，在方法DefaultSingletonBeanRegistry.
getSingleton(String beanName)中，会调用ObjectFactory.getObject方法触发二级缓存，看代码可以得出，在对象实例化前，会调用所有的InstantiationAwareBeanPostProcessors。
至于为什么一定要三级缓存，不使用二级缓存呢？可以看下一篇文章：为什么Spring要使用三级缓存解决循环依赖？