SpringBoot：解决循环依赖

一枚尘世中迷途小书童

已于 2023-06-30 16:11:31 修改

阅读量1.2k

点赞数 2

分类专栏：源码解析文章标签： spring java 缓存

于 2023-06-21 11:15:55 首次发布

本文链接：https://blog.csdn.net/jpkopkop/article/details/131324165

版权

源码解析专栏收录该内容

15 篇文章 0 订阅

订阅专栏

SpringBoot：解决循环依赖

1、什么是循环依赖？

循环依赖其实就是循环引用，也就是两个或则两个以上的bean互相持有对方，最终形成闭环。比如A依赖于B，B依赖于C，C又依赖于A。如下图：

在这里插入图片描述

spring的单例对象的初始化主要分为三步：

1、实例化：其实也就是调用对象的构造方法实例化对象。
2、注入：填充属性，这一步主要是对bean的依赖属性进行填充。
3、初始化：属性注入后，执行自定义初始化。

2、Spring为了解决单例的循环依赖问题，使用了三级缓存

private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16);

这三级缓存分别指：
singletonObjects：单例对象的cache，一级缓存。

earlySingletonObjects ：提前暴光的单例对象的Cache，二级缓存。

singletonFactories ：单例对象工厂的cache，三级缓存。
我们在创建bean的时候，首先想到的是从cache中获取这个单例的bean，这个缓存就是singletonObjects。主要调用方法就是：

 @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                synchronized(this.singletonObjects) {
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                singletonObject = singletonFactory.getObject();
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }

        return singletonObject;
    }

分析getSingleton()的整个过程，Spring首先从一级缓存singletonObjects中获取。如果获取不到，并且对象正在创建中，就再从二级缓存earlySingletonObjects中获取。如果还是获取不到且允许singletonFactories通过getObject()获取，就从三级缓存singletonFactory.getObject()(三级缓存)获取，如果获取到了则：
从singletonFactories中移除，并放入earlySingletonObjects中。其实也就是从三级缓存移动到了二级缓存。

在这里插入图片描述

3.1、单例的setter注入

@Service
public class ServiceA {

	@Autowired
	private ServiceB serviceB;
}

@Service
public class ServiceB {

	@Autowired
	private ServiceA serviceA;
}

下面用一张图告诉你，spring是如何解决循环依赖的：

在这里插入图片描述

3.2、多例的setter注入

@Service
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class ServiceA {

	@Autowired
	private ServiceB serviceB;
}

@Service
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class ServiceB {

	@Autowired
	private ServiceA serviceA;
}

可能你会认为这种情况spring容器启动会报错，其实是不会，为什么呢？其实在AbstractApplicationContext类的refresh方法中告诉了我们答案，它会调用finishBeanFactoryInitialization方法，该方法的作用是为了spring容器启动的时候提前初始化一些bean。该方法的内部又调用了beanFactory.preInstantiateSingletons()方法：能够看出：非抽象、单例并且非懒加载的类才能被提前初始bean。而多例即SCOPE_PROTOTYPE类型的类，非单例，不会被提前初始化bean，所以程序能够正常启动。如何让它提前初始化bean呢？只需要再定义一个单例的类，在它里面注入serviceA:

@Service
public class ServiceC {

    @Autowired
    private ServiceA serviceA;
}

重新启动程序，执行结果：果然出现了循环依赖。

注意：这种循环依赖问题是无法解决的，因为它没有用缓存，每次都会生成一个新对象。

3.3、构造器注入

@Service
public class ServiceA {

	public ServiceA(ServiceB serviceB) {
	}
}

@Service
public class ServiceB {

	public ServiceB(ServiceA serviceA) {
	}
}

出现了循环依赖，为什么呢？看出构造器注入没能添加到三级缓存，也没有使用缓存，所以也无法解决循环依赖问题。

3.4、单例的代理对象setter注入

这种注入方式其实也比较常用，比如平时使用：@Async注解的场景，会通过AOP自动生成代理对象。

@Service
@EnableAsync
public class ServiceA {

	@Autowired
	private ServiceB serviceB;

	@Async
	public void test1() {
		System.out.println("async");
	}
}

@Service
public class ServiceB {

	@Autowired
	private ServiceA serviceA;
}

程序启动会报错，出现了循环依赖：

在这里插入图片描述

说白了，bean初始化完成之后，后面还有一步去检查：第二级缓存是否存在，代理对象和原始对象是否相等。到此发现第二级缓存存在并且代理对象和原始对象是不相等，因此抛出上面异常。如果这时候把ServiceA改个名字，改成：ServiceC，其他的都不变。

@Service
public class ServiceB {

	@Autowired
	private ServiceC serviceC;
}

@Service
@EnableAsync
public class ServiceC {

	@Autowired
	private ServiceB serviceB;

	@Async
	public void test1() {
		System.out.println("async");
	}
}

再重新启动一下程序，成功了，没有报错了!这又是为什么？
这就要从spring的bean加载顺序说起了，默认情况下，spring是按照文件完整路径递归查找的，按路径+文件名排序，排在前面的先加载。所以ServiceA比ServiceB先加载，而改了文件名称之后，ServiceB比ServiceC先加载。为什么ServiceB比ServiceC先加载就没问题呢？答案在下面这张图中：

在这里插入图片描述

这种情况ServiceC第二级缓存是空的，不需要跟原始对象判断，所以不会抛出循环依赖。

3.5、DependsOn循环依赖

@Service
@DependsOn("serviceB")
public class ServiceA {
	
}

@Service
@DependsOn("serviceA")
public class ServiceB {
	
}

这个例子中本来如果ServiceA和ServiceB都没有加@DependsOn注解是没问题的，反而加了这个注解会出现循环依赖问题。在AbstractBeanFactory类的doGetBean方法的这段代码中：初始化bean前，它会检查dependsOn的实例有没有循环依赖，如果有循环依赖则抛异常。