Spring源码解析（五）循环依赖问题
引言
循环依赖就是多个类之间互相依赖，比如A依赖B，B也依赖A，如果日常开发中我们用new的方式创建对象，这种循环依赖就会导致不断的在创建对象，导致内存溢出。
Spring是怎么解决循环依赖的问题的？我们结合Spring源码来看一下。
第一种：构造器参数循环引用，单例
创建两个测试类：
1 public class UserServiceImpl implements UserService { 2 private TestService testService; 3 4 public UserServiceImpl() { 5 } 6 7 public UserServiceImpl(TestService testService) { 8 this.testService = testService; 9 } 10 }
public class TestServiceImpl implements TestService { private UserService userService; public TestServiceImpl() { } public TestServiceImpl(UserService userService) { this.userService = userService; } }
Spring 配置文件：
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xsi:schemaLocation="http://www.springframework.org/schema/beans 5 http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"> 6 7 <bean id="userService" class="org.springframework.example.service.impl.UserServiceImpl" lazy-init="true"> 8 <constructor-arg name="testService" ref="testService"></constructor-arg> 9 </bean> 10 <bean id="testService" class="org.springframework.example.service.impl.TestServiceImpl" lazy-init="true"> 11 <constructor-arg name="userService" ref="userService"></constructor-arg> 12 </bean> 13 </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方法方式，单例
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xsi:schemaLocation="http://www.springframework.org/schema/beans 5 http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"> 6 7 <bean id="userService" class="org.springframework.example.service.impl.UserServiceImpl" lazy-init="true"> 8 <property name="testService" ref="testService"></property> 9 </bean> 10 <bean id="testService" class="org.springframework.example.service.impl.TestServiceImpl" lazy-init="true"> 11 <property name="userService" ref="userService"></property> 12 </bean> 13 </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异常
