详解Spring循环依赖的解决方案
spring针对Bean之间的循环依赖,有自己的处理方案。关键点就是三级缓存。当然这种方案不能解决所有的问题,他只能解决Bean单例模式下非构造函数的循环依赖。
我们就从A->B->C-A这个初始化顺序,也就是A的Bean中需要B的实例,B的Bean中需要C的实例,C的Bean中需要A的实例,当然这种需要不是构造函数那种依赖。前提条件有了,我们就可以开始了。毫无疑问,我们会先初始化A.初始化的方法是org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
protectedTdoGetBean( finalStringname,finalClass requiredType,finalObject[]args,booleantypeCheckOnly) throwsBeansException{ finalStringbeanName=transformedBeanName(name); Objectbean; //Eagerlychecksingletoncacheformanuallyregisteredsingletons. ObjectsharedInstance=getSingleton(beanName);//关注点1 if(sharedInstance!=null&&args==null){ if(logger.isDebugEnabled()){ if(isSingletonCurrentlyInCreation(beanName)){ logger.debug("Returningeagerlycachedinstanceofsingletonbean'"+beanName+ "'thatisnotfullyinitializedyet-aconsequenceofacircularreference"); } else{ logger.debug("Returningcachedinstanceofsingletonbean'"+beanName+"'"); } } bean=getObjectForBeanInstance(sharedInstance,name,beanName,null); } else{ //Failifwe'realreadycreatingthisbeaninstance: //We'reassumablywithinacircularreference. if(isPrototypeCurrentlyInCreation(beanName)){ thrownewBeanCurrentlyInCreationException(beanName); } //Checkifbeandefinitionexistsinthisfactory. BeanFactoryparentBeanFactory=getParentBeanFactory(); if(parentBeanFactory!=null&&!containsBeanDefinition(beanName)){ //Notfound->checkparent. StringnameToLookup=originalBeanName(name); if(args!=null){ //Delegationtoparentwithexplicitargs. return(T)parentBeanFactory.getBean(nameToLookup,args); } else{ //Noargs->delegatetostandardgetBeanmethod. returnparentBeanFactory.getBean(nameToLookup,requiredType); } } if(!typeCheckOnly){ markBeanAsCreated(beanName); } try{ finalRootBeanDefinitionmbd=getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd,beanName,args); //Guaranteeinitializationofbeansthatthecurrentbeandependson. String[]dependsOn=mbd.getDependsOn(); if(dependsOn!=null){ for(StringdependsOnBean:dependsOn){ if(isDependent(beanName,dependsOnBean)){ thrownewBeanCreationException(mbd.getResourceDescription(),beanName, "Circulardepends-onrelationshipbetween'"+beanName+"'and'"+dependsOnBean+"'"); } registerDependentBean(dependsOnBean,beanName); getBean(dependsOnBean); } } //Createbeaninstance. if(mbd.isSingleton()){ //关注点2 sharedInstance=getSingleton(beanName,newObjectFactory
这个方法很长我们一点点说。先看我们的关注点1ObjectsharedInstance=getSingleton(beanName)根据名称从单例的集合中获取单例对象,我们看下这个方法,他最终是org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String,boolean)
protectedObjectgetSingleton(StringbeanName,booleanallowEarlyReference){ ObjectsingletonObject=this.singletonObjects.get(beanName); if(singletonObject==null&&isSingletonCurrentlyInCreation(beanName)){ synchronized(this.singletonObjects){ singletonObject=this.earlySingletonObjects.get(beanName); if(singletonObject==null&&allowEarlyReference){ ObjectFactory>singletonFactory=this.singletonFactories.get(beanName); if(singletonFactory!=null){ singletonObject=singletonFactory.getObject(); this.earlySingletonObjects.put(beanName,singletonObject); this.singletonFactories.remove(beanName); } } } } return(singletonObject!=NULL_OBJECT?singletonObject:null); }
大家一定要注意这个方法,很关键,我们开篇提到了三级缓存,使用点之一就是这里。到底是哪三级缓存呢,第一级缓存singletonObjects里面放置的是实例化好的单例对象。第二级earlySingletonObjects里面存放的是提前曝光的单例对象(没有完全装配好)。第三级singletonFactories里面存放的是要被实例化的对象的对象工厂。解释好了三级缓存,我们再看看逻辑。第一次进来this.singletonObjects.get(beanName)返回的肯定是null。然后isSingletonCurrentlyInCreation决定了能否进入二级缓存中获取数据。
publicbooleanisSingletonCurrentlyInCreation(StringbeanName){ returnthis.singletonsCurrentlyInCreation.contains(beanName); }
从singletonsCurrentlyInCreation这个Set中有没有包含传入的BeanName,前面没有地方设置,所以肯定不包含,所以这个方法返回false,后面的流程就不走了。getSingleton这个方法返回的是null。
下面我们看下关注点2.也是一个getSingleton只不过他是真实的创建Bean的过程,我们可以看到传入了一个匿名的ObjectFactory的对象,他的getObject方法中调用的是createBean这个真正的创建Bean的方法。当然我们可以先搁置一下,继续看我们的getSingleton方法
publicObjectgetSingleton(StringbeanName,ObjectFactory>singletonFactory){ Assert.notNull(beanName,"'beanName'mustnotbenull"); synchronized(this.singletonObjects){ ObjectsingletonObject=this.singletonObjects.get(beanName); if(singletonObject==null){ if(this.singletonsCurrentlyInDestruction){ thrownewBeanCreationNotAllowedException(beanName, "Singletonbeancreationnotallowedwhilethesingletonsofthisfactoryareindestruction"+ "(DonotrequestabeanfromaBeanFactoryinadestroymethodimplementation!)"); } if(logger.isDebugEnabled()){ logger.debug("Creatingsharedinstanceofsingletonbean'"+beanName+"'"); } beforeSingletonCreation(beanName); booleannewSingleton=false; booleanrecordSuppressedExceptions=(this.suppressedExceptions==null); if(recordSuppressedExceptions){ this.suppressedExceptions=newLinkedHashSet(); } try{ singletonObject=singletonFactory.getObject(); newSingleton=true; } catch(IllegalStateExceptionex){ //Hasthesingletonobjectimplicitlyappearedinthemeantime-> //ifyes,proceedwithitsincetheexceptionindicatesthatstate. singletonObject=this.singletonObjects.get(beanName); if(singletonObject==null){ throwex; } } catch(BeanCreationExceptionex){ if(recordSuppressedExceptions){ for(ExceptionsuppressedException:this.suppressedExceptions){ ex.addRelatedCause(suppressedException); } } throwex; } finally{ if(recordSuppressedExceptions){ this.suppressedExceptions=null; } afterSingletonCreation(beanName); } if(newSingleton){ addSingleton(beanName,singletonObject); } } return(singletonObject!=NULL_OBJECT?singletonObject:null); } }
这个方法的第一句ObjectsingletonObject=this.singletonObjects.get(beanName)从一级缓存中取数据,肯定是null。随后就调用的beforeSingletonCreation方法。
protectedvoidbeforeSingletonCreation(StringbeanName){ if(!this.inCreationCheckExclusions.contains(beanName)&&!this.singletonsCurrentlyInCreation.add(beanName)){ thrownewBeanCurrentlyInCreationException(beanName); } }
其中就有往singletonsCurrentlyInCreation这个Set中添加beanName的过程,这个Set很重要,后面会用到。随后就是调用singletonFactory的getObject方法进行真正的创建过程,下面我们看下刚刚上文提到的真正的创建的过程createBean,它里面的核心逻辑是doCreateBean.
protectedObjectdoCreateBean(finalStringbeanName,finalRootBeanDefinitionmbd,finalObject[]args){ //Instantiatethebean. BeanWrapperinstanceWrapper=null; if(mbd.isSingleton()){ instanceWrapper=this.factoryBeanInstanceCache.remove(beanName); } if(instanceWrapper==null){ instanceWrapper=createBeanInstance(beanName,mbd,args); } finalObjectbean=(instanceWrapper!=null?instanceWrapper.getWrappedInstance():null); Class>beanType=(instanceWrapper!=null?instanceWrapper.getWrappedClass():null); //Allowpost-processorstomodifythemergedbeandefinition. synchronized(mbd.postProcessingLock){ if(!mbd.postProcessed){ applyMergedBeanDefinitionPostProcessors(mbd,beanType,beanName); mbd.postProcessed=true; } } //Eagerlycachesingletonstobeabletoresolvecircularreferences //evenwhentriggeredbylifecycleinterfaceslikeBeanFactoryAware. //关注点3 booleanearlySingletonExposure=(mbd.isSingleton()&&this.allowCircularReferences&& isSingletonCurrentlyInCreation(beanName)); if(earlySingletonExposure){ if(logger.isDebugEnabled()){ logger.debug("Eagerlycachingbean'"+beanName+ "'toallowforresolvingpotentialcircularreferences"); } addSingletonFactory(beanName,newObjectFactory(){ @Override publicObjectgetObject()throwsBeansException{ returngetEarlyBeanReference(beanName,mbd,bean); } }); } //Initializethebeaninstance. ObjectexposedObject=bean; try{ populateBean(beanName,mbd,instanceWrapper); if(exposedObject!=null){ exposedObject=initializeBean(beanName,exposedObject,mbd); } } catch(Throwableex){ if(exinstanceofBeanCreationException&&beanName.equals(((BeanCreationException)ex).getBeanName())){ throw(BeanCreationException)ex; } else{ thrownewBeanCreationException(mbd.getResourceDescription(),beanName,"Initializationofbeanfailed",ex); } } if(earlySingletonExposure){ ObjectearlySingletonReference=getSingleton(beanName,false); if(earlySingletonReference!=null){ if(exposedObject==bean){ exposedObject=earlySingletonReference; } elseif(!this.allowRawInjectionDespiteWrapping&&hasDependentBean(beanName)){ String[]dependentBeans=getDependentBeans(beanName); Set actualDependentBeans=newLinkedHashSet (dependentBeans.length); for(StringdependentBean:dependentBeans){ if(!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)){ actualDependentBeans.add(dependentBean); } } if(!actualDependentBeans.isEmpty()){ thrownewBeanCurrentlyInCreationException(beanName, "Beanwithname'"+beanName+"'hasbeeninjectedintootherbeans["+ StringUtils.collectionToCommaDelimitedString(actualDependentBeans)+ "]initsrawversionaspartofacircularreference,buthaseventuallybeen"+ "wrapped.Thismeansthatsaidotherbeansdonotusethefinalversionofthe"+ "bean.Thisisoftentheresultofover-eagertypematching-considerusing"+ "'getBeanNamesOfType'withthe'allowEagerInit'flagturnedoff,forexample."); } } } } //Registerbeanasdisposable. try{ registerDisposableBeanIfNecessary(beanName,bean,mbd); } catch(BeanDefinitionValidationExceptionex){ thrownewBeanCreationException(mbd.getResourceDescription(),beanName,"Invaliddestructionsignature",ex); } returnexposedObject; }
createBeanInstance利用反射创建了对象,下面我们看看关注点3earlySingletonExposure属性值的判断,其中有一个判断点就是isSingletonCurrentlyInCreation(beanName)
publicbooleanisSingletonCurrentlyInCreation(StringbeanName){ returnthis.singletonsCurrentlyInCreation.contains(beanName); }
发现使用的是singletonsCurrentlyInCreation这个Set,上文的步骤中已经将BeanName已经填充进去了,所以可以查到,所以earlySingletonExposure这个属性是结合其他的条件综合判断为true,进行下面的流程addSingletonFactory,这里是为这个Bean添加ObjectFactory,这个BeanName(A)对应的对象工厂,他的getObject方法的实现是通过getEarlyBeanReference这个方法实现的。首先我们看下addSingletonFactory的实现
protectedvoidaddSingletonFactory(StringbeanName,ObjectFactory>singletonFactory){ Assert.notNull(singletonFactory,"Singletonfactorymustnotbenull"); synchronized(this.singletonObjects){ if(!this.singletonObjects.containsKey(beanName)){ this.singletonFactories.put(beanName,singletonFactory); this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } } }
往第三级缓存singletonFactories存放数据,清除第二级缓存根据beanName的数据。这里有个很重要的点,是往三级缓存里面set了值,这是Spring处理循环依赖的核心点。getEarlyBeanReference这个方法是getObject的实现,可以简单认为是返回了一个为填充完毕的A的对象实例。设置完三级缓存后,就开始了填充A对象属性的过程。下面这段描述,没有源码提示,只是简单的介绍一下。
填充A的时候,发现需要B类型的Bean,于是继续调用getBean方法创建,记性的流程和上面A的完全一致,然后到了填充C类型的Bean的过程,同样的调用getBean(C)来执行,同样到了填充属性A的时候,调用了getBean(A),我们从这里继续说,调用了doGetBean中的ObjectsharedInstance=getSingleton(beanName),相同的代码,但是处理逻辑完全不一样了。
protectedObjectgetSingleton(StringbeanName,booleanallowEarlyReference){ ObjectsingletonObject=this.singletonObjects.get(beanName); if(singletonObject==null&&isSingletonCurrentlyInCreation(beanName)){ synchronized(this.singletonObjects){ singletonObject=this.earlySingletonObjects.get(beanName); if(singletonObject==null&&allowEarlyReference){ ObjectFactory>singletonFactory=this.singletonFactories.get(beanName); if(singletonFactory!=null){ singletonObject=singletonFactory.getObject(); this.earlySingletonObjects.put(beanName,singletonObject); this.singletonFactories.remove(beanName); } } } } return(singletonObject!=NULL_OBJECT?singletonObject:null); }
还是从singletonObjects获取对象获取不到,因为A是在singletonsCurrentlyInCreation这个Set中,所以进入了下面的逻辑,从二级缓存earlySingletonObjects中取,还是没有查到,然后从三级缓存singletonFactories找到对应的对象工厂调用getObject方法获取未完全填充完毕的A的实例对象,然后删除三级缓存的数据,填充二级缓存的数据,返回这个对象A。C依赖A的实例填充完毕了,虽然这个A是不完整的。不管怎么样C式填充完了,就可以将C放到一级缓存singletonObjects同时清理二级和三级缓存的数据。同样的流程B依赖的C填充好了,B也就填充好了,同理A依赖的B填充好了,A也就填充好了。Spring就是通过这种方式来解决循环引用的。
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持毛票票。
声明:本文内容来源于网络,版权归原作者所有,内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:czq8825#qq.com(发邮件时,请将#更换为@)进行举报,并提供相关证据,一经查实,本站将立刻删除涉嫌侵权内容。