说透 Spring循环依赖和3级缓存

Bean加载的总体流程

FactoryBean的使用

地位：FactoryBean接口是Spring重要的拓展接口

用途：用于复杂的初始化 或者 框架集成

使用：

自定义类继承接口FactoryBean

原理：spring的getBean方法会回调FactoryBean的getObject方法

缓存中获取单例bean

说明下3级缓存指的是什么：

从3级缓存中获取bean，原则是第一级没有去第二级，第二级没有去第三极查找。

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 从第一级缓存中查找
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 从第二级缓存中查找
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            // 加锁
            synchronized (this.singletonObjects) {
                // Consistent creation of early reference within full singleton lock
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    // 加锁之后需要重新检查 第一级缓存、第二级缓存（保证多线程下的原子性）
                    if (singletonObject == null) {
                        // 从第三极缓存中查找
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {

                            // 调用工厂方法【1、工厂模式下会调用；2、循环依赖下会调用】
                            singletonObject = singletonFactory.getObject();

                            this.earlySingletonObjects.put(beanName, singletonObject);
                            // 从singletonFactories中remove掉这个ObjectFactory
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

从bean的实例中获取对象

ObjectFactory 与 FactoryBean接口的比较

相同点：都有getObject方法

不同点：作用完全不相同。

不同点体现的代码：

• ObjectFactory

AbstractAutowireCapableBeanFactory#doCreateBean方法的代码片段（功能：加入第三极缓存）

// 默认下每个bean都会进入这个方法
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

DefaultSingletonBeanRegistry#getSingleton方法代码片段（功能：查找3级缓存）

// 从第三极缓存中查找
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {

    // 调用工厂方法【1、工厂模式下会调用；2、循环依赖下会调用】
    singletonObject = singletonFactory.getObject();

    this.earlySingletonObjects.put(beanName, singletonObject);
    // 从singletonFactories中remove掉这个ObjectFactory
    this.singletonFactories.remove(beanName);
}

• FactoryBean

FactoryBean起作用的调用链路：

getBean —> AbstractBeanFactory#getObjectForBeanInstance —> FactoryBeanRegistrySupport#getObjectFromFactoryBean —> doGetObjectFromFactoryBean

// 代码片段

private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
    // 执行FactoryBean的getObject方法。
    /**
     * 注意：跟函数式接口ObjectFactory的定义非常相似（在getBean方法中出现，getObject的作用是定义模板方法中的特殊操作）
     * [T getObject() throws BeansException;] 与 [T getObject() throws Exception;]
     */
    Object object = factory.getObject();
    return object;
}

获取单例

描述的DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)方法

1、检查缓存是否已经加载过

2、如没有加载，则记录beanName正在加载的状态

3、加载单例前记录加载状态

4、通过调用参数传入的ObjectFactory的getObject方法完成实例化bean

5、加载单例后的处理方法调用

6、将结果记录至缓存并删除加载bean过程中的所记录的各种辅助状态。

准备创建Bean

循环依赖

要理解spring是如何解决循环依赖的，我们需要先了解我们吧什么定义循环依赖。最简单的，bean1中有一个属性prop2，bean2中有一个属性prop1，prop2指向bean2，prop1指向bean1，这就是一个”最简单“的循环依赖的例子。

上面的例子太简单了，不能满足我们研究spring中3级缓存如何在循环依赖中的作用，所以，我们必须要把例子复杂起来一些。

测试环境准备

1、首先，我们把测试的代码贴出来

Bean_1.java、Bean_2.java、Bean_3.java文件：

@Data
public class Bean_1 {
    private Bean_2 prop_2;
    private Bean_3 prop_3;
}

@Data
public class Bean_2 {
    private Bean_1 prop_1;
}

@Data
public class Bean_3 {
    private Bean_1 prop_1;
}

application.xml文件：

<bean id="bean_1"
        class="com.firefish.springsourcecodedeepanalysis.cycle.setter.Bean_1"
        scope="singleton">
        <property name="prop_2" ref="bean_2"></property>
        <property name="prop_3" ref="bean_3"></property>
    </bean>

    <bean id="bean_2"
        class="com.firefish.springsourcecodedeepanalysis.cycle.setter.Bean_2"
        scope="singleton">
        <property name="prop_1" ref="bean_1"></property>
    </bean>

    <bean id="bean_3"
        class="com.firefish.springsourcecodedeepanalysis.cycle.setter.Bean_3"
        scope="singleton">
        <property name="prop_1" ref="bean_1"></property>
    </bean>

Main.java文件：

public class Main {
    public static void main(String[] args) {
        XmlBeanFactory context = new XmlBeanFactory(new ClassPathResource("com/firefish/springsourcecodedeepanalysis/cycle/setter/application.xml"));
        System.out.println(context.getBean("bean_3"));
    }
}

2、然后，我们把bean的关系也贴出来

3、到这里其实我们就具备了研究3级缓存和循环依赖的条件了，只要运行Main.java。

bean生命周期中关于循环依赖的介绍

循环依赖的解决与bean的生命周期息息相关，我们不得不介绍下与循环依赖关联的一些点。

下面是bean生命周期与循环依赖关系密切的流程：

1、从3层级缓存中查找bean（getSingleton方法）

2、doCreateBean 之前记录"正在加载bean"（beforeSingletonCreation方法）

3、实例化bean（createBeanInstance方法调用构造器）

4、加入到第三级缓存（addSingletonFactory方法）

5、属性填充、初始化、后置处理器（重点是属性填充）

6、结束beanA的创建，移除bean的创建状态

画图演示存在循环依赖下，bean在3级缓存中的迁移过程

以上面的代码为实例，在循环依赖下，下面将用图片的形式展示bean_1、bean_2、bean_3在bean生命周期执行过程中如何通过3级缓存解决循环依赖问题。

1、从3层级缓冲中查找bean_3，发现找不到，则创建bean_3；先记录bean_3正在创建中的状态，实例化bean_3，把bean_3加入第三级缓存中

2、对bean_3进行属性填充，发现依赖prop_1，进而去创建bean_1

3、从3层级缓冲中查找bean_1，发现找不到，则创建bean_1；先记录bean_1正在创建中的状态，实例化bean_1，把bean_1加入第三级缓存中

4、对bean_1进行属性填充，发现依赖prop_2、prop_3；依据属性填充的先后顺序，先getBean_2，后getBean_3；进而就去创建bean_2

5、从3层级缓冲中查找bean_2，发现找不到，则创建bean_2；先记录bean_2正在创建中的状态，实例化bean_2，把bean_2加入第三级缓存中

6、对bean_2进行属性填充，发现依赖prop_1；进而去getBean_1

7、发现bean_1已经在创建中了，从3级缓冲的第三级缓存中可以找到bean_1了，调用bean_1的getObject方法（这里完成应用SmartInstantiationAwareBeanPostProcessor接口处理器来增强原始bean的功能。aop就是通过这个实现的）。从这里开始似乎开始循环依赖的结束了…。

8、把可能增强后的bean_1加入到第二级缓存中（为什么？？？），现在的情况如下图了。

9、目前为止，完成了bean_2的属性填充，然后它的初始化等等流程…，最后完成了bean_2的完整创建，它被移动到第一级缓存供用户使用。

10、接着步骤4，bean_1的属性prop_3还没有完成，现在进行bean3获取，即getBean_3

11、发现bean_3已经在创建中了，从3级缓冲的第三级缓存中可以找到bean_3了，调用了bean_3的getObject方法，状态如下了。

12、到这里，完成了bean_1的prop_2、prop_3的属性填充，以为着bean_1也就完整了创建，状态如下：

13、最后完整了bean_3的创建

过程的状态图都演示完了，下面总结下各种map的作用吧。（多debug几遍源码可能更好理解）

几种map的作用

• singletonsCurrentlyInCreation（记录了那些bean正在创建中）
• singletonObjects（完整的bean的缓存）
• earlySingletonObjects

为什么需要earlySingletonObjects的缓存？？？

1、如果没有它，当多次依赖bean（如上文中的bean_1）将不得不从第三级缓存的getObject方法中重新创建新的bean，这就违反了”单例bean“；

2、对于这种中间状态的bean（如上文中的bean_1），总要有一个地方吧它缓存起来

总结：earlySingletonObjects的作用就是防止多次创建bean，也就是作为”半初始化“单例bean的一个中间缓存。

• singletonFactories

这个只有一个作用：应用 SmartInstantiationAwareBeanPostProcessor 接口完整bean的功能增强，如aop功能

总结

可以重点了解下循环依赖下，3个bean状态在3级缓存中的迁移情况，可以debug2遍看看；

了解后就不难理解这几种map的作用了。下面贴几张总结性的一些图，或许有用。