Spring 循环依赖三级缓存

攻心的子乐

已于 2022-02-22 18:04:14 修改

阅读量973

点赞数

文章标签： spring java 后端

于 2022-01-26 11:49:31 首次发布

本文链接：https://blog.csdn.net/qq_29883183/article/details/122698739

版权

太可惜了，Spring中的循环依赖问题，只有10%的人才算“真的懂” - 哔哩哔哩

# Spring是如何解决循环依赖的问题的？

三级缓存，提前暴露对象，aop

**总**：什么是循环依赖问题，A依赖B，B依赖C，C依赖A

**分**：先说明bean得创建过程：实例化，初始化（填充属性）

		1.先创建A对象，实例化A对象，此时A对象中的b属性为空

		2.从容器中查找B对象，如果找到了，直接赋值不存在循环依赖问题(不通)，找不到直接创建B对象

		3.实例化B对象，此时B对象中的a属性为空，填充属性a

		4.从容器中查找A对象，找不到，直接创建

		此时，如果仔细琢磨的话，会发现A对象，是存在的，只不过此时的A对象不是一个完整的状态，只完成了实例化但是未完成初始化，如果在程序调用过程中，拥有了某个对象的引用，能否在后期给他完成赋值操作，可以优先把非完整状态的对象优先赋值，等待后续操作来完成赋值，相当于提前暴露了某个不完整对象的引用，所以解决问题的核心在于实例化和初始化分开操作，这也是解决循环依赖问题的关键，

	当所有的对象都完成实例化和初始化操作之后，还要把完整对象放到容器中，此时在容器中存在对象的几种状态，完成实例化=但未完成初始化，完整状态，因为都在容器中，所以要使用不同的map结构来进行存储，此时就有了一级缓存和二级缓存，如果一级缓存中有了，那么二级缓存中就不会存在同名的对象，因为他们的查找顺序是1，2，3这样的方式来查找的。一级缓存中放的是完整对象，二级缓存中放的是非完整对象，

	为什么需要三级缓存？三级缓存的value类型是ObjectFactory，是一个函数式接口

，存在的意义是保证在整个容器的运行过程中同名的bean对象只能有一个。

	如果一个对象需要被代理，或者说需要生成代理对象，那么要不要优先生成一个普通对象？要

	普通对象和代理对象是不能同时出现在容器中的，因此当一个对象需要被代理的时候，就要使用代理对象覆盖掉之前的普通对象，在实际的调用过程中，是没有办法确定什么时候对象被使用，所以就要求某个对象被调用的时候，优先判断此对象是否需要被代理，类似于一种回调机制的实现，因此传入lambda表达式的时候，可以通过lambda表达式来执行对象的覆盖过程，getEarlyBeanReference()

	因此，所有的bean对象在创建的时候要优先放到三级缓存中，在后续的使用过程中，如果需要被代理则返回代理对象，如果不需要被代理，则直接返回普通对象

spring中，bean的初始化只是其生命周期的一部分（第一步），在bean初始化之后，spring会生成一个ObjectFactory<?>（这是一个函数式接口）存到三级缓存，它的作用是生产一个bean（getObject方法），所有的bean在初始化未完成（对于spring的bean生命周期来说）的时候都会先存一个ObjectFactory<?>到三级缓存。

当A被创建的时候，因为依赖于B这个时候spring会调用getBean("B")(递归操作)去获取B,因为B没有被加载，所以spring又会去加载B，当B被实例化后设置B的属性，因为B又是依赖于A的，这个时候spring会先从单例池中取A发现没有，又从二级缓存取，发现还没有，最后去三级缓存中取得ObjectFactory(前面说到所有的bean在初始化未完成的时候都会先存入到三级缓存)，执行ObjectFactory.getObject()这个方法会调用getEarlyBeanReference方法(函数式接口)，这个方法会返回一个bean实例。然后B取得了A完成创建，返回给A，A也得到了B，循环依赖问题被解决。

到这里我有个疑惑，为什么不直接在二级缓存中存bean的实例呢？为什么要使用ObjectFactory函数式接口呢？

查看源码后发现，getEarlyBeanReference这个方法会判断传入的这个类有没有被AOP增强，如果被AOP增强了，则返回一个被AOP包装过后的实例（在被AOP增强的时候，返回的是一个代理类(这个时候会重新创建一个实例（createProxy方法）)）。

如果直接在二级缓存中存入bean实例（此时没有被AOP增强），然后去设置了属性B（B这个时候会去三级缓存中找A（A这个时候没有被AOP增强）），B属性设置完成后，A最后会去被AOP增强（这个时候A会重新创建）然后放入到单例池，这个时候B中的A对象就跟单例池里的A对象不是一个对象了。

这个时候又有一个疑问，既然要提前被AOP包装，为什么不直接把AOP包装后的类放入到二级缓存呢？而要使用三级缓存呢？
这里应该跟spring的设计思想有关，spring想尽可能的按照常规的bean的生命周期来创建bean，除非要解决循环依赖，不然三级缓存的ObjectFactory永远都用不到(二级缓存也用不到)。最后在实例被加入到一级缓存的时候，会把二级缓存和三级缓存中的实例移除。

容器中的对象有2个状态: 1. 完整状态 2. 完成实例化但未完成初始化所以需要2个map结构来存储,就是一二级缓存. 一级缓存中有的对象, 二级缓存中就不会有同名的对象. 因为他们的查找顺序是123这样的方式来查找的. 一级缓存放的完整对象, 二级缓存放非完整对象.

为什么需要三级缓存?

三级缓存的value是ObjectFactory, 是一个函数式接口, 存在的意义是保证在整个容器的运行过程中

普通对象和代理对象是不能同时出现在容器中的，因此当一个对象需要被代理的时候，就要使用代理对象覆盖掉之前的普通对象，在实际的调用过程中，是没有办法确定什么时候对象被使用，所以就要求某个对象被调用的时候，优先判断此对象是否需要被代理，类似于一种回调机制的实现，因此传入lambda表达式的时候，可以通过lambda表达式来执行对象的覆盖过程，getEarlyBeanReference()

因此，所有的bean对象在创建的时候要优先放到三级缓存中，在后续的使用过程中，如果需要被代理则返回代理对象，如果不需要被代理，则直接返回普通对象

实例化和初始化分开, 提前暴漏非完整对象,

如果没有AOP, 二级缓存就够了.

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. */  // 三级缓存的value类型是 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);

/**
	 * 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
	 */
	//下面的代码是解决循环依赖的核心，后面细讲
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// Quick check for existing instance without full singleton lock
		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) {
								singletonObject = singletonFactory.getObject();
								this.earlySingletonObjects.put(beanName, singletonObject);
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}
}

循环依赖的发生于: 如下截图的2种情况(AB均采用构造器注入, B中注入A的方式为setter注入, A中注入B为构造器注入)

1.使用构造器注入, 引起循环依赖报错

注意: 构造注入，也是Spring团队推荐的Spring依赖注入的方式(依赖来自IDEA的提示),
虽然Spring官方推荐构造器注入, 但是没人用(可能引起循环依赖问题)

大家都用的springboot注解注入简单, Spring框架的三级缓存已经为我们解决了循环依赖的问题

启动springboot报错,循环依赖报错

@Component
public class Y {

    public Y(X a) {
        System.out.println("Y---create");
    }

    private X x;

}

@Component
public class X {

    public X(Y b) {
        System.out.println("X---create");
    }

    private Y y;

}

2.使用字段注入的方式, 启动springboot没问题, 调方法也没问题,

因为Spring的三级缓存已经给我们解决了循环依赖的问题

这里的构造方法并不是构造器注入,而是字段注入

@Component
public class X {

    public X() {
        System.out.println("X----create");
    }

    @Autowired
    private Y y;

    public void x(){
        System.out.println("XXXXXX");
    }

}

@Component
public class Y {

    public Y() {
        System.out.println("Y----create");
    }

    @Autowired
    private X x;

    public String y() {
        System.out.println("YYYYYY");
        return "YYYYYY";
    }
}

3. Setter注入也没有循环依赖的问题, Springboot启动正常

@Component
public class X {

    public X() {
        System.out.println("X----create");
    }

    private Y y;

    public void setY(Y y) {
        this.y = y;
    }
}

@Component
public class Y {

    public Y() {
        System.out.println("Y----create");
    }

    private X x;

    public void setX(X x) {
        this.x = x;
    }
}

攻心的子乐

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring 循环依赖三级缓存

/** * localhost:8080/user */ @GetMapping("/test") public void testYmlValueToModel() { aImpl.a(); bImpl.b(); }@Servicepublic class AImpl { @Autowired private BImpl bImpl; public String a(){ System.out.println(...
复制链接

扫一扫