循环依赖是什么

在平时的面试中，只要问到Spring，那么大概率肯定会问什么是循环依赖，Sping是如何解决循环依赖的。以及三级缓存机制是什么。所以为了从根本上解决这个问题，本篇主要详细介绍一下循环依赖的问题。

Spring Bean初始化过程

Spring 在创建Bean对象的时候，会按照一定的流程进行初始化。主要的话就是如下

• 根据配置文件，扫描固定的路径 比如bean.xml ，封装成BeanDefinition
• 根据BeanDefinition 推断出Class构造方法，反射得到一个原始对象。
• 对原始对象进行属性复制。以及对应的切面处理等。生产代理对象放入BeanFactory中。

循环依赖其实就是A、B两个类，A同时引用B，B同时引用A。
A初始化的时候，需要引用到B，然后会去创建B，但是B又引用到了A。所以就会出现循环依赖。
一句话就是：循环依赖是在SpringBean初始化声明周期而产生的问题

有哪些方式的循环依赖

我们知道Bean的属性注入，1.通过构造注入 2.通过setter方式注入。
并且因为Bean scope=“singleton” 、prototype 两种方式。所以就有三种方式。

• 1.scope = prototype 构造注入 (直接报错)
• 2.score = singleton 构造注入 （直接报错）
• 3.scope = singleton setteer注入 （三级缓存解决）

Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'serviceB' defined in class path resource [beans.xml]: Cannot resolve reference to bean 'serviceA' while setting bean property 'serviceA'; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'serviceA': Requested bean is currently in creation: Is there an unresolvable circular reference?

好了，来分析以下，scope = prototype的方式。对象是多例，无法解决。并且构造对象这种方式，就是鸡生蛋，蛋生鸡。无法解决。

所以大家常说的spring 循环依赖问题，默认就是单例下 使用setter方式。

Code

@Service
public class ServiceA {
	private ServiceB serviceB;

	public ServiceB getServiceB() {
		return serviceB;
	}

	public void setServiceB(ServiceB serviceB) {
		this.serviceB = serviceB;
	}

	public ServiceA() {
		System.out.println("serviceA构造成功");
	}
}

@Service
public class ServiceB {

	private ServiceA serviceA;

	public ServiceA getServiceA() {
		return serviceA;
	}

	public void setServiceA(ServiceA serviceA) {
		this.serviceA = serviceA;
	}

	public ServiceB() {
		System.out.println("serviceB构造成功");
	}
}

	<bean id="serviceA" class="com.qxlx.main.springbean.circulardend.ServiceA" scope="singleton">
	<property name="serviceB" ref="serviceB"/>
	</bean>


	<bean id="serviceB" class="com.qxlx.main.springbean.circulardend.ServiceB"  scope="singleton">
	<property name="serviceA" ref="serviceA"/>
	</bean>

三级缓存源码解读

三级缓存其实就是DefaultSingletonBeanRegistry中的三个Map。

实例化：创建了对象，但是还有属性的赋值。 new A()
初始化：将对象需要的属性赋值 a.setB(b);

三级缓存

  /** 享元模式的单例。缓存所有单实例对象，单例对象池。ioc容器-单例池； 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 ConcurrentHashMap<>(16);

第一级缓存〈也叫单例池）singletonObjects:存放已经经历了完整生命周期的Bean对象
第二级缓存: earlySingletonObjects，存放早期暴露出来的Bean对象，Bean的生命周期未结束（属性还未填充完整）
第三级缓存: Map<<String, ObiectFactory<<?>> singletonFactories，存放可以生成Bean的工厂

4大方法

整体流程

流程总结


整体流程，其实就是A创建的过程中需要B，所以将A对象自己放入三级缓存中，然后去实例化B。
2.B在实例化的时候，发现自己引用了属性A，所以从三级缓存中依此查询，查询一级缓存没有，在查询二级缓存也没有，发现三级缓存有，将A从三级缓存放入二级缓存，并将三级缓存中的A删除。
3.B创建完毕之后，将自己放入一级缓存中。然后A接着创建，直接从一级缓存中获取B。A创建完成，将自己放入一级缓存中。
整个过程其实就是依赖于如果发现是循环依赖的话，通过将对象提前暴露出来，存储缓存中，并且scope=singleton。所以可以解决这个问题。

小结

本篇主要介绍了Spring循环依赖的。为什么会有循环依赖的问题，以及循环依赖有哪些方式，Spring是如何通过三级缓存解决的循环依赖。

参考资料：
https://www.cnblogs.com/java-chen-hao/p/11139887.html
https://blog.csdn.net/qq_25448409/article/details/111247655?spm=1001.2014.3001.5502
https://blog.csdn.net/a745233700/article/details/110914620