Spring循环依赖-出现的原因，发现机制和解决方法

SpringBean依赖注入——循环依赖

Spring循环依赖出现的原因

循环依赖的现象就是Spring的容器在创建Bean的生命周期中，出现了相互依赖的场景，A->B->A,
比如上面A的实例属性值是B的实例，B的实例属性值也是A的实例，
这样A在进行初始化并且属性赋值的时候发现依赖B，就去实例化B，发现在给B初始化进行属性赋值的时候，也依赖A，
这样就出现了最简单的循环依赖。

针对上面的问题：首先我们要知道循环依赖只发生在作用域是单例的场景里面，

即scope=“singleton”，

如果作用域是原型，即scope=“prototype”，也会报错，为什么呢？

因为scope="prototype"时，这时候对应的Bean是在使用的时候才会被创建出来，

不会提前被Spring的容器提前创建， 创建出来其生命周期也不受Spring容器的管理。

如果循环依赖会直接报错，（singleton一般是用于无状态的bean，prototype一般用于有状态的bean）如下源码所示：

public abstract class AbstractBeanFactory 
extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args,
			 boolean typeCheckOnly)
			throws BeansException {

		String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
				//.......省略代码
		}else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			// 这个操作就是判断如果bean是Prototype作用域的会直接报错
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
			// 省略代码。。。。
		}
	}
}

Spring循环依赖发生的条件

• 首先是发生在Spring容器中
• 涉及到的Bean都是在项目启动要被Spring容器提前创建和管理的

Spring循环依赖发现机制

Spring容器在创建A时，会先去“当前创建bean”池中判断是否已经在池中，如果不存在，就创建bean，在创建之前

会把正在创建的A，放在一个“当前创建bean池”中，

这个池子里面的Bean都是正在创建中的Bean，然后创建A的时候发先依赖B，就去实例化创建B，

同时也会将B放在“当前创建bean”池中，然后发先创建B依赖A，就会去创建A，

但是这时候发现A已经在“当前创建bean”池中了，就知道发生了循环依赖，这就是循环依赖的发现机制

简要说一下这个“当前创建bean”池是个什么，看下面AbstractBeanFactory类的部分代码

下面就看一下isPrototypeCurrentlyInCreation()

public class DefaultSingletonBeanRegistry
 extends SimpleAliasRegistry implements SingletonBeanRegistry {
 	/** Maximum number of suppressed exceptions to preserve. */
	private static final int SUPPRESSED_EXCEPTIONS_LIMIT = 100;

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

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

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

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





	// 这个就是上面说的“当前创建bean”池
	/** Names of beans that are currently in creation. */
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));





	/** Names of beans currently excluded from in creation checks. */
	private final Set<String> inCreationCheckExclusions =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/** Collection of suppressed Exceptions, available for associating related causes. */
	@Nullable
	private Set<Exception> suppressedExceptions;

	/** Flag that indicates whether we're currently within destroySingletons. */
	private boolean singletonsCurrentlyInDestruction = false;

	/** Disposable bean instances: bean name to disposable instance. */
	private final Map<String, Object> disposableBeans = new LinkedHashMap<>();

	/** Map between containing bean names: bean name to Set of bean names that the bean contains. */
	private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);

	/** Map between dependent bean names: bean name to Set of dependent bean names. */
	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

	/** Map between depending bean names: bean name to Set of bean names for the bean's dependencies. */
	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);


     // .......省略部分代码
	/**
	 * Return whether the specified singleton bean is currently in creation
	 * (within the entire factory).
	 * @param beanName the name of the bean
	 */
	public boolean isSingletonCurrentlyInCreation(String beanName) {
		return this.singletonsCurrentlyInCreation.contains(beanName);
	}

     // .....省略部分代码
}

从上面源代码我们不难不发现这个“当前创建bean”是个什么玩意儿了，是个存放了“当前创建bean”的name的set集合

Spring 循环依赖解决方案 ——三级缓存

// 一级缓存
/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 三级缓存
/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// 二级缓存
/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

• singletonObjects：一级缓存，里面放置的是已经完成所有创建动作的单例对象，也就是说这里存放的bean已经完成了所有创建的生命周期过程，在项目运行阶段当执行多次getBean()时就是从一级缓存中获取的。
• earlySingletonObjects：二级缓存，里面存放的只是进行了实例化的bean，还没有进行属性设置和初始化操作，也就是bean的创建还没有完成，还在进行中，这里是为了方便被别的bean引用
• singletonFactories：三级缓存，Spring中的每个bean创建都有自己专属的ObjectFactory工厂类，三级缓存缓存的就是对应的bean的工厂实例，可以通过该工厂实例的getObject()方法获取该bean的实例。

图片源地址，他的原文写的也很详细，可以看一下