Spring中的循环依赖解决详解
本文内容纲要:
前言
说起Spring中循环依赖的解决办法,相信很多园友们都或多或少的知道一些,但当真的要详细说明的时候,可能又没法一下将它讲清楚。本文就试着尽自己所能,对此做出一个较详细的解读。另,需注意一点,下文中会出现类的实例化跟类的初始化两个短语,为怕园友迷惑,事先声明一下,本文的实例化是指刚执行完构造器将一个对象new出来,但还未填充属性值的状态,而初始化是指完成了属性的依赖注入。
一、先说说Spring解决的循环依赖是什么
Java中的循环依赖分两种,一种是构造器的循环依赖,另一种是属性的循环依赖。
构造器的循环依赖就是在构造器中有属性循环依赖,如下所示的两个类就属于构造器循环依赖:
1@Service
2publicclassStudent{
3@Autowired
4privateTeacherteacher;
5
6publicStudent(Teacherteacher){
7System.out.println("Studentinit1:"+teacher);
8}
9
10publicvoidlearn(){
11System.out.println("Studentlearn");
12}
13}
1@Service
2publicclassTeacher{
3@Autowired
4privateStudentstudent;
5
6publicTeacher(Studentstudent){
7System.out.println("Teacherinit1:"+student);
8
9}
10
11publicvoidteach(){
12System.out.println("teach:");
13student.learn();
14}
15}
这种循环依赖没有什么解决办法,因为JVM虚拟机在对类进行实例化的时候,需先实例化构造器的参数,而由于循环引用这个参数无法提前实例化,故只能抛出错误。
Spring解决的循环依赖就是指属性的循环依赖,如下所示:
1@Service
2publicclassTeacher{
3@Autowired
4privateStudentstudent;
5
6publicTeacher(){
7System.out.println("Teacherinit1:"+student);
8
9}
10
11publicvoidteach(){
12System.out.println("teach:");
13student.learn();
14}
15
16}
1@Service
2publicclassStudent{
3@Autowired
4privateTeacherteacher;
5
6publicStudent(){
7System.out.println("Studentinit:"+teacher);
8}
9
10publicvoidlearn(){
11System.out.println("Studentlearn");
12}
13}
测试扫描类:
1@ComponentScan(value="myPackage")
2publicclassScanConfig{
3
4}
测试启动类:
1publicclassSpringTest{
2
3publicstaticvoidmain(String[]args){
4AnnotationConfigApplicationContextapplicationContext=newAnnotationConfigApplicationContext(ScanConfig.class);
5applicationContext.getBean(Teacher.class).teach();
6
7}
8}
测试类执行结果:
1Studentinit:null
2Teacherinit:null
3teach:
4Studentlearn
可以看到,在构造器执行的时候未完成属性的注入,而在调用方法的时候已经完成了注入。下面就一起看看Spring内部是在何时完成的属性注入,又是如何解决的循环依赖。
二、循环依赖与属性注入
1、对于非懒加载的类,是在refresh方法中的finishBeanFactoryInitialization(beanFactory)方法完成的包扫描以及bean的初始化,下面就一起追踪下去。
1protectedvoidfinishBeanFactoryInitialization(ConfigurableListableBeanFactorybeanFactory){
2//其他代码
3
4//Instantiateallremaining(non-lazy-init)singletons.
5beanFactory.preInstantiateSingletons();
6}
可以看到调用了beanFactory的一个方法,此处的beanFactory就是指我们最常见的那个DefaultListableBeanFactory,下面看它里面的这个方法。
2、DefaultListableBeanFactory的preInstantiateSingletons方法
1publicvoidpreInstantiateSingletons()throwsBeansException{
2
3List<String>beanNames=newArrayList<>(this.beanDefinitionNames);
4
5//Triggerinitializationofallnon-lazysingletonbeans...
6for(StringbeanName:beanNames){
7RootBeanDefinitionbd=getMergedLocalBeanDefinition(beanName);
8if(!bd.isAbstract()&&bd.isSingleton()&&!bd.isLazyInit()){//判断为非抽象类、是单例、非懒加载才给初始化
9if(isFactoryBean(beanName)){
10//无关代码(针对FactoryBean的处理)
11}
12else{
13//重要!!!普通bean就是在这里初始化的
14getBean(beanName);
15}
16}
17}
18
19//其他无关代码
20}
可以看到,就是在此方法中循环Spring容器中所有的bean,依次对其进行初始化,初始化的入口就是getBean方法
3、AbstractBeanFactory的getBean跟doGetBean方法
追踪getBean方法:
1publicObjectgetBean(Stringname)throwsBeansException{
2returndoGetBean(name,null,null,false);
3}
可见引用了重载的doGetBean方法,继续追踪之:
1protected<T>TdoGetBean(finalStringname,@NullablefinalClass<T>requiredType,
2@NullablefinalObject[]args,booleantypeCheckOnly)throwsBeansException{
3
4finalStringbeanName=transformedBeanName(name);
5Objectbean;
6
7//方法1)从三个map中获取单例类
8ObjectsharedInstance=getSingleton(beanName);
9//省略无关代码
10}
11else{
12//如果是多例的循环引用,则直接报错
13if(isPrototypeCurrentlyInCreation(beanName)){
14thrownewBeanCurrentlyInCreationException(beanName);
15}
16//省略若干无关代码
17try{
18//Createbeaninstance.
19if(mbd.isSingleton()){
20//方法2)获取单例对象
21sharedInstance=getSingleton(beanName,()->{
22try{//方法3)创建ObjectFactory中getObject方法的返回值
23returncreateBean(beanName,mbd,args);
24}
25catch(BeansExceptionex){
26//Explicitlyremoveinstancefromsingletoncache:Itmighthavebeenputthere
27//eagerlybythecreationprocess,toallowforcircularreferenceresolution.
28//Alsoremoveanybeansthatreceivedatemporaryreferencetothebean.
29destroySingleton(beanName);
30throwex;
31}
32});
33bean=getObjectForBeanInstance(sharedInstance,name,beanName,mbd);
34}
35}
36//省略若干无关代码
37return(T)bean;
38}
该方法比较长,对于解决循环引用来说,上面标出来的3个方法起到了至关重要的作用,下面我们挨个攻克。
3.1)getSingleton(beanName)方法:注意该方法跟方法2)是重载方法,名字一样内部逻辑却大相径庭。
1protectedObjectgetSingleton(StringbeanName,booleanallowEarlyReference){
2ObjectsingletonObject=this.singletonObjects.get(beanName);//步骤A
3if(singletonObject==null&&isSingletonCurrentlyInCreation(beanName)){
4synchronized(this.singletonObjects){
5singletonObject=this.earlySingletonObjects.get(beanName);//步骤B
6if(singletonObject==null&&allowEarlyReference){
7ObjectFactory<?>singletonFactory=this.singletonFactories.get(beanName);//步骤C
8if(singletonFactory!=null){
9singletonObject=singletonFactory.getObject();
10this.earlySingletonObjects.put(beanName,singletonObject);
11this.singletonFactories.remove(beanName);
12}
13}
14}
15}
16returnsingletonObject;
17}
通过上面的步骤可以看出这三个map的优先级。其中singletonObjects里面存放的是初始化之后的单例对象;earlySingletonObjects中存放的是一个已完成实例化未完成初始化的早期单例对象;而singletonFactories中存放的是ObjectFactory对象,此对象的getObject方法返回值即刚完成实例化还未开始初始化的单例对象。所以先后顺序是,单例对象先存在于singletonFactories中,后存在于earlySingletonObjects中,最后初始化完成后放入singletonObjects中。
当debug到此处时,以上述Teacher和Student两个循环引用的类为例,如果第一个走到这一步的是Teacher,则从此处这三个map中get到的值都是空,因为还未添加进去。这个方法主要是给循环依赖中后来过来的对象用。
3.2)getSingleton(StringbeanName,ObjectFactory<?>singletonFactory)方法:
1publicObjectgetSingleton(StringbeanName,ObjectFactory<?>singletonFactory){
2Assert.notNull(beanName,"Beannamemustnotbenull");
3synchronized(this.singletonObjects){
4ObjectsingletonObject=this.singletonObjects.get(beanName);
5if(singletonObject==null){
6//省略无关代码
7beforeSingletonCreation(beanName);//步骤A
8booleannewSingleton=false;
9//省略无关代码
10try{
11singletonObject=singletonFactory.getObject();//步骤B
12newSingleton=true;
13}
14//省略无关代码
15finally{
16if(recordSuppressedExceptions){
17this.suppressedExceptions=null;
18}
19afterSingletonCreation(beanName);//步骤C
20}
21if(newSingleton){
22addSingleton(beanName,singletonObject);//步骤D
23}
24}
25returnsingletonObject;
26}
27}
获取单例对象的主要逻辑就是此方法实现的,主要分为上面四个步骤,继续挨个看:
步骤A:
1protectedvoidbeforeSingletonCreation(StringbeanName){
2//判断,并首次将beanName即teacher放入singletonsCurrentlyInCreation中
3if(!this.inCreationCheckExclusions.contains(beanName)&&!this.singletonsCurrentlyInCreation.add(beanName)){
4thrownewBeanCurrentlyInCreationException(beanName);
5}
6}
步骤C:
1protectedvoidafterSingletonCreation(StringbeanName){
2//得到单例对象后,再讲beanName从singletonsCurrentlyInCreation中移除
3if(!this.inCreationCheckExclusions.contains(beanName)&&!this.singletonsCurrentlyInCreation.remove(beanName)){
4thrownewIllegalStateException("Singleton'"+beanName+"'isn'tcurrentlyincreation");
5}
6}
步骤D:
1protectedvoidaddSingleton(StringbeanName,ObjectsingletonObject){
2synchronized(this.singletonObjects){
3this.singletonObjects.put(beanName,singletonObject);//添加单例对象到map中
4this.singletonFactories.remove(beanName);//从早期暴露的工厂中移除,此map在解决循环依赖中发挥了关键的作用
5this.earlySingletonObjects.remove(beanName);//从早期暴露的对象map中移除
6this.registeredSingletons.add(beanName);//添加到已注册的单例名字集合中
7}
8}
步骤B:
此处调用了ObjectFactory的getObject方法,此方法是在哪里实现的呢?返回的又是什么?且往回翻,找到3中的方法3,对java8函数式编程有过了解的园友应该能看出来,方法3【createBean(beanName,mbd,args)】的返回值就是getObject方法的返回值,即方法3返回的就是我们需要的单例对象,下面且追踪方法3而去。
3.3)AbstractAutowireCapableBeanFactory#createBean(java.lang.String,org.springframework.beans.factory.support.RootBeanDefinition,java.lang.Object[])方法
1protectedObjectcreateBean(StringbeanName,RootBeanDefinitionmbd,@NullableObject[]args)
2throwsBeanCreationException{
3
4//省略无关代码
5try{
6ObjectbeanInstance=doCreateBean(beanName,mbdToUse,args);
7returnbeanInstance;
8}
9//省略无关代码
10}
去掉无关代码之后,关键方法只有doCreateBean方法,追踪之:
1protectedObjectdoCreateBean(finalStringbeanName,finalRootBeanDefinitionmbd,final@NullableObject[]args)
2throwsBeanCreationException{
3
4BeanWrapperinstanceWrapper=null;
5//省略代码
6if(instanceWrapper==null){
7//实例化bean
8instanceWrapper=createBeanInstance(beanName,mbd,args);
9}
10booleanearlySingletonExposure=(mbd.isSingleton()&&this.allowCircularReferences&&
11isSingletonCurrentlyInCreation(beanName));
12if(earlySingletonExposure){
13//重点!!!将实例化的对象添加到singletonFactories中
14addSingletonFactory(beanName,()->getEarlyBeanReference(beanName,mbd,bean));
15}
16//初始化bean
17ObjectexposedObject=bean;
18try{
19populateBean(beanName,mbd,instanceWrapper);//也很重要
20exposedObject=initializeBean(beanName,exposedObject,mbd);
21}
22//省略无关代码
23returnexposedObject;
24}
上面注释中标出的重点是此方法的关键。在addSingletonFactory方法中,将第二个参数ObjectFactory存入了singletonFactories供其他对象依赖时调用。然后下面的populateBean方法对刚实例化的bean进行属性注入(该方法关联较多,本文暂时不展开追踪了,有兴趣的园友自行查看即可),如果遇到Spring中的对象属性,则再通过getBean方法获取该对象。至此,循环依赖在Spring中的处理过程已经追溯完毕,下面我们总结一下。
小结
属性注入主要是在populateBean方法中进行的。对于循环依赖,以我们上文中的Teacher中注入了Student、Student中注入了Teacher为例来说明,假定Spring的加载顺序为先加载Teacher,再加载Student。
getBean方法触发Teacher的初始化后:
a.首先走到3中的方法1),此时map中都为空,获取不到实例;
b.然后走到方法2)中,步骤A、步骤C、步骤D为控制map中数据的方法,实现简单,可暂不关注。其中步骤B的getObject方法触发对方法3)的调用;
c.在方法3)中,先通过createBeanInstance实例化Teacher对象,又将该实例化的对象通过addSingletonFactory方法放入singletonFactories中,完成Teacher对象早期的暴露;
d.然后在方法3)中通过populateBean方法对Teacher对象进行属性的注入,发现它有一个Student属性,则触发getBean方法对Student进行初始化
e.重复a、b、c步骤,只是此时要初始化的是Student对象
f.走到d的时候,调用populateBean对Student对象进行属性注入,发现它有一个Teacher属性,则触发getBean方法对Teacher进行初始化;
g.对Teacher进行初始化,又来到a,但此时map已经不为空了,因为之前在c步骤中已经将Teacher实例放入了singletonFactories中,a中得到Teacher实例后返回;
h.完成f中对Student的初始化,继而依次往上回溯完成Teacher的初始化;
完成Teacher的初始化后,Student的初始化就简单了,因为map中已经存了这个单例。
至此,Spring循环依赖的总结分析结束,一句话来概括一下:Spring通过将实例化后的对象提前暴露给Spring容器中的singletonFactories,解决了循环依赖的问题。
本文内容总结:
原文链接:https://www.cnblogs.com/zzq6032010/p/11406405.html