Spring源码解析（五）循环依赖问题

引言

循环依赖就是多个类之间互相依赖，比如A依赖B，B也依赖A，如果日常开发中我们用new的方式创建对象，这种循环依赖就会导致不断的在创建对象，导致内存溢出。

Spring是怎么解决循环依赖的问题的？我们结合Spring源码来看一下。

第一种：构造器参数循环引用，单例

创建两个测试类：

 public class UserServiceImpl implements UserService {
     private TestService testService;

     public UserServiceImpl() {
     }

     public UserServiceImpl(TestService testService) {
         this.testService = testService;
     }
 }

public class TestServiceImpl implements TestService {
    private UserService userService;

    public TestServiceImpl() {

    }

    public TestServiceImpl(UserService userService) {
        this.userService = userService;
    }

}

Spring 配置文件：

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

     <bean id="userService" class="org.springframework.example.service.impl.UserServiceImpl" lazy-init="true">
         <constructor-arg name="testService" ref="testService"></constructor-arg>
     </bean>
     <bean id="testService" class="org.springframework.example.service.impl.TestServiceImpl" lazy-init="true">
         <constructor-arg name="userService" ref="userService"></constructor-arg>
     </bean>
 </beans>

测试类：

public class ApplicationContextTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("classpath*:test*.xml");
        TestService testService= (TestService) context.getBean("testService");
        System.out.println(testService);
    }
}

例子很简单，两个类互相引用，通过构造器的方式初始化Bean并且两个都是单例。

我们看一下测试结果：

Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'testService' defined in file [D:\spring-framework-3.2.15.RELEASE\spring-framework-3.2.15.RELEASE\spring-test\build\resources\main\test1.xml]: Cannot resolve reference to bean 'userService' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'userService' defined in file [D:\spring-framework-3.2.15.RELEASE\spring-framework-3.2.15.RELEASE\spring-test\build\resources\main\test1.xml]: Cannot resolve reference to bean 'testService' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'testService': Requested bean is currently in creation: Is there an unresolvable circular reference?
    at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:336)
    at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessary(BeanDefinitionValueResolver.java:108)
    at org.springframework.beans.factory.support.ConstructorResolver.resolveConstructorArguments(ConstructorResolver.java:652)
    at org.springframework.beans.factory.support.ConstructorResolver.autowireConstructor(ConstructorResolver.java:145)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireConstructor(AbstractAutowireCapableBeanFactory.java:1109)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1009)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:492)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:461)
    at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:301)
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:223)
    at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:298)
    at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:191)
    at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1132)
    at org.springframework.example.test.ApplicationContextTest.main(ApplicationContextTest.java:22)
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'userService' defined in file [D:\spring-framework-3.2.15.RELEASE\spring-framework-3.2.15.RELEASE\spring-test\build\resources\main\test1.xml]: Cannot resolve reference to bean 'testService' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'testService': Requested bean is currently in creation: Is there an unresolvable circular reference?
    at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:336)
    at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessary(BeanDefinitionValueResolver.java:108)
    at org.springframework.beans.factory.support.ConstructorResolver.resolveConstructorArguments(ConstructorResolver.java:652)
    at org.springframework.beans.factory.support.ConstructorResolver.autowireConstructor(ConstructorResolver.java:145)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireConstructor(AbstractAutowireCapableBeanFactory.java:1109)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1009)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:492)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:461)
    at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:301)
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:223)
    at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:298)
    at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:191)
    at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:328)
    ... 13 more
Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'testService': Requested bean is currently in creation: Is there an unresolvable circular reference?
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.beforeSingletonCreation(DefaultSingletonBeanRegistry.java:327)
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:217)
    at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:298)
    at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:191)
    at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:328)    

下面通过源码分析一下原因：

在spring中创建单例Bean调用的是DefaultSingletonBeanRegistry，我们直接看DefaultSingletonBeanRegistry就好了。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "'beanName' 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 the 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 + "'");
                }
                /**1.创建bean之前singletonsCurrentlyInCreation put BeanName，该bean正在创建中*/
                beforeSingletonCreation(beanName);
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<Exception>();
                }
                try {
                    /**2.创建Bean*/
                    singletonObject = singletonFactory.getObject();
                }
                catch (BeanCreationException ex) {
                    if (recordSuppressedExceptions) {
                        for (Exception suppressedException : this.suppressedExceptions) {
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                    throw ex;
                }
                finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
                    /**3.bean创建完成以后singletonsCurrentlyInCreation删除beanName*/
                    afterSingletonCreation(beanName);
                }
                /**4.将单例Bean添加容器中*/
                addSingleton(beanName, singletonObject);
            }
            return (singletonObject != NULL_OBJECT ? singletonObject : null);
        }
    }

1.创建bean之前判断该bean是否正在创建中

protected void beforeSingletonCreation(String beanName) {
        if (!this.inCreationCheckExclusions.containsKey(beanName) &&
                this.singletonsCurrentlyInCreation.put(beanName, Boolean.TRUE) != null) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }

singletonsCurrentlyInCreation就是一个Map，如果第一次创建Bean，会将beanName添加到map中并返回前一个值null。比如我们现在先初始化UserService,那么map中就会存在<userService,true>
2.通过constructor初始化Bean，BeanDefinitionValueResolver

/**
     * Resolve a reference to another bean in the factory.
     */
    private Object resolveReference(Object argName, RuntimeBeanReference ref) {
        try {
            String refName = ref.getBeanName();
            refName = String.valueOf(evaluate(refName));
            if (ref.isToParent()) {
                if (this.beanFactory.getParentBeanFactory() == null) {
                    throw new BeanCreationException(
                            this.beanDefinition.getResourceDescription(), this.beanName,
                            "Can't resolve reference to bean '" + refName +
                            "' in parent factory: no parent factory available");
                }
                return this.beanFactory.getParentBeanFactory().getBean(refName);
            }
            else {
                /**先初始化ref引用的bean*/
                Object bean = this.beanFactory.getBean(refName);
                this.beanFactory.registerDependentBean(refName, this.beanName);
                return bean;
            }
        }
        catch (BeansException ex) {
            throw new BeanCreationException(
                    this.beanDefinition.getResourceDescription(), this.beanName,
                    "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
        }
    }

UserService还没有创建完成，需要先创建TestService，创建TestService又会走第1步，将testService添加到map中<testService,true>，这个时候来到第2步，又会先创建UserService，这个时候又到流程1，
发现Map中已存在<userService,true>,这个时候就会抛出BeanCurrentlyInCreationException。

第二种：set方法方式，单例

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

     <bean id="userService" class="org.springframework.example.service.impl.UserServiceImpl" lazy-init="true">
         <property name="testService" ref="testService"></property>
     </bean>
     <bean id="testService" class="org.springframework.example.service.impl.TestServiceImpl" lazy-init="true">
         <property name="userService" ref="userService"></property>
     </bean>
 </beans>

单例的实例化过程主要分为两步：创建bean实例，属性的依赖注入，之前通过带参数constructor实例化的时候，需要先实例化属性，所以导致了循环依赖。
set方法注入的方式是怎么避免的呢？接下来看一下AbstractAutowireCapableBeanFacotry：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        //省略.....if (instanceWrapper == null) {
            /**1.创建bean实例*/
            instanceWrapper = createBeanInstance(beanName, mbd, args);//通过Constructor初始化在此处就训陷入循环引用
        }
        //省略....................// Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        /**
         * 2.及早暴露单例bean引用，解决循环引用
         */
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            //创建匿名内部类，匿名内部类会将beanName、mbd，bean（final修饰）拷贝一份到内部类，已保证当前方法执行完成后局部变量退栈后内部类还可以访问。
            addSingletonFactory(beanName, new ObjectFactory<Object>() {
                public Object getObject() throws BeansException {
                    return getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }

        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
            /**
             * 3.依赖注入
             */
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                /**
                 * 9.执行自定义BeanProcesser和init-method
                 */
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }
     //省略.......

1.创建bean实例时，用的无参构造器属性且属性并没有注入值。
2.及早暴露单例bean引用，这一步就是解决循环引用的关键。

/** Cache of singleton objects: bean name --> bean instance */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);

    /** Cache of singleton factories: bean name --> ObjectFactory */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

    /** Cache of early singleton objects: bean name --> bean instance */
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

    /** Set of registered singletons, containing the bean names in registration order */
    private final Set<String> registeredSingletons = new LinkedHashSet<String>(64);

/**
     * Add the given singleton factory for building the specified singleton
     * if necessary.
     * <p>To be called for eager registration of singletons, e.g. to be able to
     * resolve circular references.
     * @param beanName the name of the bean
     * @param singletonFactory the factory for the singleton object
     */
    protected 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);
            }
        }
    }

this.singletonFactories.put(beanName, singletonFactory);这里把匿名内部类放到了map里，匿名内部类会将beanName、mbd，bean（final修饰）拷贝一份到内部类，通过

singletonFactory的getEarlyBeanReference方法可以获得未初始化完成的bean实例。这就相当于把未初始化完成的bean提前暴露出来。

/**
     * Obtain a reference for early access to the specified bean,
     * typically for the purpose of resolving a circular reference.
     * @param beanName the name of the bean (for error handling purposes)
     * @param mbd the merged bean definition for the bean
     * @param bean the raw bean instance
     * @return the object to expose as bean reference
     */
    protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
　　　　　//这是扩展点，如果不扩展相当于直接返回bean
        if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                    if (exposedObject == null) {
                        return exposedObject;
                    }
                }
            }
        }
        return exposedObject;
    }

3.依赖注入
bean创建完成后要为属性注入值

    /**先初始化ref引用的bean*/
                Object bean = this.beanFactory.getBean(refName);
                this.beanFactory.registerDependentBean(refName, this.beanName);
                return bean;

例如当前初始化的是A依赖B，
这个时候就会初始化依赖对象B，B初始化过程跟A是一样的，也会到依赖注入这一步，这个时候同样会初始化依赖对象A，bean在初始化之前会先在缓冲中取，这个时候就可以取到A，就不会循环继续初始化下去。

/**
     * Return the (raw) singleton object registered under the given name.
     * <p>Checks already instantiated singletons and also allows for an early
     * reference to a currently created singleton (resolving a circular reference).
     * @param beanName the name of the bean to look for
     * @param allowEarlyReference whether early references should be created or not
     * @return the registered singleton object, or {@code null} if none found
     */
    protected 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();
                        //单例bean只是创建了实例，并没有为属性赋值，提前暴露出来，防止循环依赖
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

总结：

初始化A对象：
　　　　--创建A对象
　　　　--将包含A对象的匿名内部对象ObjectFacotry放到singletonFactories（map）中。
　　　　--依赖注入，创建对象B
　　　　　　　　　　　　　　--创建B对象
　　　　　　　　　　　　　　--将包含B对象的匿名内部对象ObjectFacotry放到singletonFactories（map）中。

　　　　　　　　　　　　　　--依赖注入，创建对象A
　　　　　　　　　　　　　　　　　　　　--创建之前，判断缓存中是否存在
　　　　　　　　　　　　　　　　　　　　　　singletonFactory.getObject()获取A，将对象A放到earlySingletonObjects（Map）中，并返回
　　　　　　　　　　　　　　--B对象创建完毕，放到singletonObjects（Map）中
　　　　--A对象创建完毕，放到singletonObjects（Map）中

初始化B对象：
　　　　--创建前，判断缓存中是否存在

　　　　　　Object singletonObject = this.singletonObjects.get(beanName);直接返回B

第三种：set方法方式和constructor混合，单例

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

    <bean id="userService" class="org.springframework.example.service.impl.UserServiceImpl" lazy-init="true" >
       <constructor-arg ref="testService" index="0"></constructor-arg>
    </bean>
    <bean id="testService" class="org.springframework.example.service.impl.TestServiceImpl" lazy-init="true">
        <property name="userService" ref="userService"></property>
    </bean>
</beans>

我们通过单例Bean初始化过程的梳理，通过默认构造器初始化的单例Bean会提前暴露出来，其他bean引用它的时候是可以直接获取到的。
现在这种配置情况，context.getBean("userService");是会抛出循环引用异常的，而context.getBean("testService")是正常的。
我们看一下测试结果：

第四种：set方法方式，prototype

prototype类型的bean循环依赖会报异常。通过源码看一下，这个比较简单

　　　　　　/**prototype类型，判断benaName是不是创建中，出现了循环引用*/
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
　　　　　　　　//省略.......
　　　　　　　　/**
                 * 6.创建原型bean,scope="prototype"
                 */
                else if (mbd.isPrototype()) {
                    // It's a prototype -> create a new instance.
                    Object prototypeInstance = null;
                    try {
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }

    /** Names of beans that are currently in creation */
    private final ThreadLocal<Object> prototypesCurrentlyInCreation =
            new NamedThreadLocal<Object>("Prototype beans currently in creation");

    protected void beforePrototypeCreation(String beanName) {
        Object curVal = this.prototypesCurrentlyInCreation.get();
        if (curVal == null) {
            this.prototypesCurrentlyInCreation.set(beanName);
        }
        else if (curVal instanceof String) {
            Set<String> beanNameSet = new HashSet<String>(2);
            beanNameSet.add((String) curVal);
            beanNameSet.add(beanName);
            this.prototypesCurrentlyInCreation.set(beanNameSet);
        }
        else {
            Set<String> beanNameSet = (Set<String>) curVal;
            beanNameSet.add(beanName);
        }
    }

在创建prototype类型的bean之前会将beanName添加到prototypesCurrentlyInCreation，prototypesCurrentlyInCreation是ThreadLocal类型的，每个线程一个。所有创建中的BeanName都会放进去。

创建A对象

　　　　--判断benaName是不是创建中

　　　　--A 添加到prototypesCurrentlyInCreation

　　　　--创建A实例

　　　　--依赖注入

　　　　　　　　--创建依赖B

　　　　　　　　　　--判断benaName是不是创建中

　　　　　　　　　　--B添加到prototypesCurrentlyInCreation（此时prototypesCurrentlyInCreation对应的value值是个Set 包含了A和B）

　　　　　　　　　　--创建A实例

　　　　　　　　　　　　--判断benaName是不是创建中，这个时候就会抛出BeanCurrentlyInCreationException异常