java spring ioc 实例_Spring 源码阅读(IOC容器)-bean的实例化以及注入

3.Bean的实例化以及注入过程分析

Bean的实例以及注入是在getBean时触发的，由于外部容器是与外部调用交互的桥梁，我们首先从外部容器入手，AbstractApplicationContext类实现了getBean方法，代码如下：

AbstractApplicationContext下的代码：

publicObjectgetBean(Stringname)throwsBeansException{

//Bean的获取外部容器交给了内部容器returngetBeanFactory().getBean(name);

}

内部容器由DefaultListableBeanFactory承当，但真实的getBean方法实现是由其父类AbstractBeanFactory实现的sssssssssssssssssssssss。

AbstractBeanFactory下的代码:

publicObjectgetBean(Stringname,ClassrequiredType,Object[]args)throwsBeansException{

returndoGetBean(name,requiredType,args,false);

}

3.1 doGetBean方法分析

protectedObjectdoGetBean(

finalStringname,finalClassrequiredType,finalObject[]args,booleantypeCheckOnly)throwsBeansException{

//把当前传入的beanName转化为标准beanName,例如把去除&引用(如果带&表示要获取FactoryBean)、alias转化为标准的beanName等finalStringbeanName=transformedBeanName(name);

Objectbean=null;

//Eagerlychecksingletoncacheformanuallyregisteredsingletons.

//先从singleton对象缓存中查找，如果未找到接着到早期的singleton对象缓存查找，如果还是没有找到，接下来先获得beanName的singletonFactory，然后调用getObject获得对象。ObjectsharedInstance=getSingleton(beanName);

if(sharedInstance!=null){

/**//*获得给定bean实例的对象。这里的处理过程是这样的：

(1)如果sharedInstance不是FactoryBean实例，而是个普通bean，那么直接返回;

(2)如果sharedInstance是FactoryBean实例，且name要求返回FactoryBean实例，那么直接返回;

(3)否则从本地缓存获得合并BeanDefinition,如果本地缓存不存在合并BeanDefinition，则从本地缓存取得BeanDefinition，构造合并BeanDefinition，然后通过factoryBean获得bean*/bean=getObjectForBeanInstance(sharedInstance,name,beanName,null);

}else{

//检查beanName所代表的bean是否处于正在创建阶段，主要是防止循环引用

if(isPrototypeCurrentlyInCreation(beanName)){

thrownewBeanCurrentlyInCreationException(beanName);

}

//首先检查父工厂是否存在，如果父工厂存在，且当前工厂不存在该beanName的BeanDefinition，那么当前工厂将委托父工厂完成getBean的任务.BeanFactoryparentBeanFactory=getParentBeanFactory();

if(parentBeanFactory!=null&&!containsBeanDefinition(beanName)){

//转化为标准的beanNameStringnameToLookup=originalBeanName(name);

if(args!=null){

//Delegationtoparentwithexplicitargs.returnparentBeanFactory.getBean(nameToLookup,args);

}

else{

//从父工厂获得bean，过程与本方法类似，相当于递归returnparentBeanFactory.getBean(nameToLookup,requiredType);

}}

if(!typeCheckOnly){

//是否要类型检查，如果不检查，直接把beanName标记为已创建markBeanAsCreated(beanName);

}

/**//*通过beanName，从mergedBeanDefinitions(针对mergeBeanDefinition的缓存)中取出合并的BeanDefinition，mergedBeanDefinition主要指两个BeanDefinition的合并，比如父子两个的合并*/finalRootBeanDefinitionmbd=getMergedLocalBeanDefinition(beanName);

checkMergedBeanDefinition(mbd,beanName,args);

//Guaranteeinitializationofbeansthatthecurrentbeandependson.String[]dependsOn=mbd.getDependsOn();

if(dependsOn!=null){//如果bean存在依赖bean，先构建依赖bean

for(inti=0;i{

StringdependsOnBean=dependsOn[i];

getBean(dependsOnBean);

registerDependentBean(dependsOnBean,beanName);

}}

//Createbeaninstance.

if(mbd.isSingleton()){//

sharedInstance=getSingleton(beanName,newObjectFactory(){

publicObjectgetObject()throwsBeansException{

try{

/**//*所有生成Bean都有BeanWrapper封装，bean的生成采用策略模式，CglibSubclassingInstantiationStrategy实现是默认的策略

1.如果配置为工厂方法创建(配置了factory-mother的)，由java反射Mehthod的invoke完成bean的创建。

2.如果采用构造子配置创建(配置了constructor-arg的)，如果bean对应的类包含多个构造子，采用cglib动态字节码构造；如果只有唯一的构造子，那么采用java反射Constructor的newInstance方法

3.如果是普通bean配置,直接通过反射Class默认的Constructor，然后调用newInstance获得bean.*/returncreateBean(beanName,mbd,args);

}

catch(BeansExceptionex){

//Explicitlyremoveinstancefromsingletoncache:Itmighthavebeenputthere.

//eagerlybythecreationprocess,toallowforcircularreferenceresolution.

//Alsoremoveanybeansthatreceivedatemporaryreferencetothebean.destroySingleton(beanName);

throwex;

}}});

/**//*由于当前构造的bean可能是FactoryBean，所以要通过以下方法获得真实需要的bean

(1)如果sharedInstance不是FactoryBean实例，而是个普通bean，那么直接返回;

(2)如果sharedInstance是FactoryBean实例，且name要求返回FactoryBean实例，那么直接返回;

(3)否则从本地缓存获得合并BeanDefinition,如果本地缓存不存在合并BeanDefinition，则从本地缓存取得BeanDefinition，构造合并BeanDefinition，然后通过factoryBean获得bean*/bean=getObjectForBeanInstance(sharedInstance,name,beanName,mbd);

}elseif(mbd.isPrototype()){

//It'saprototype->createanewinstance.ObjectprototypeInstance=null;

try{

beforePrototypeCreation(beanName);//维护prototypesCurrentlyInCreation，主要把beanName加入到其中prototypeInstance=createBean(beanName,mbd,args);

}

finally{

afterPrototypeCreation(beanName);

}bean=getObjectForBeanInstance(prototypeInstance,name,beanName,mbd);

}else{

StringscopeName=mbd.getScope();

finalScopescope=(Scope)this.scopes.get(scopeName);

if(scope==null){

thrownewIllegalStateException("NoScoperegisteredforscope'"+scopeName+"'");

}

try{

ObjectscopedInstance=scope.get(beanName,newObjectFactory(){

publicObjectgetObject()throwsBeansException{

beforePrototypeCreation(beanName);

try{

returncreateBean(beanName,mbd,args);

}

finally{

afterPrototypeCreation(beanName);

}}});

bean=getObjectForBeanInstance(scopedInstance,name,beanName,mbd);

}

catch(IllegalStateExceptionex){

thrownewBeanCreationException(beanName,

"Scope'"+scopeName+"'isnotactiveforthecurrentthread;"+"considerdefiningascopedproxyforthisbeanifyouintendtorefertoitfromasingleton",

ex);

}}}

//Checkifrequiredtypematchesthetypeoftheactualbeaninstance.

if(requiredType!=null&&bean!=null&&!requiredType.isAssignableFrom(bean.getClass())){

thrownewBeanNotOfRequiredTypeException(name,requiredType,bean.getClass());

}returnbean;

}

3.1.1 getObjectForBeanInstance方法分析

该方法从名称上就能看出，其实现的功能是从一个给定的bean实例，获取客户端调用所真实想要的bean。由于Spring能够管理各式的bean，当bean是FactoryBean实例的时候，客户端调用可以通过&+beanName的方式获得FactoryBean实例，而如果bean实例是普通的bean，那么该方法直接返回。

protectedObjectgetObjectForBeanInstance(

ObjectbeanInstance,Stringname,StringbeanName,RootBeanDefinitionmbd){

/**//*如果bean是工厂解除参照(即name带有&)，且不是FactoryBean实例，那么抛出异常。这里的意思就是说如果name带有&，而传进来的又不是FactoryBean实例*/

if(BeanFactoryUtils.isFactoryDereference(name)&&!(beanInstanceinstanceofFactoryBean)){

thrownewBeanIsNotAFactoryException(transformedBeanName(name),beanInstance.getClass());

}

/**//*现在我们拥有了bean实例，它可能是一个普通bean或者一个FactoryBean.如果是一个工厂bean，我们使用它创建一个bean实例，除非调用者确实想要工厂的引用。

如果bean实例未实现FactoryBean，或者要求返回BeanFactory自身，那么直接返回。*/

if(!(beanInstanceinstanceofFactoryBean)||BeanFactoryUtils.isFactoryDereference(name)){

returnbeanInstance;

}

/**//*以下的代码意味着处理非普通bean，而是FactoryBean之类的*/Objectobject=null;

if(mbd==null){//

/**//*这里主要是从一个FactoryBean到object映射的缓存中，取出由FactoryBean创建的object.这种映射关系是由factoryBeanObjectCache(映射关系：FactoryBeanname-->object，例如’myJndi’--->myJndiObject)字段维护，该字段位于FactoryBeanRegistrySupport中*/object=getCachedObjectForFactoryBean(beanName);

}

if(object==null){

FactoryBeanfactory=(FactoryBean)beanInstance;

/**//*containsBeanDefinition方法是由默认内部工厂DefaultListableBeanFactory实现，因为BeanDefinition是缓存在它之下的*/

if(mbd==null&&containsBeanDefinition(beanName)){

/**//*从本地获得指定beanName的合并BeanDefinition，所谓的合并BeanDefinition就是指子类的BeanDefinition与父类BeanDefinition的合并。*/mbd=getMergedLocalBeanDefinition(beanName);

}

/**//*判断beanDefinition是否是合成的，即是否与其他beanDefinition进行了合并*/booleansynthetic=(mbd!=null&&mbd.isSynthetic());

//从factoryBean获得beanobject=getObjectFromFactoryBean(factory,beanName,!synthetic);

}returnobject;

}

3.1.1.1 合并BeanDefinition获取的分析

在容器初始化阶段，对解释资源获得的BeanDefinition是由GenericBeanDefinition来定义，其只能刻画bean自身的一些特性。但bean与bean之间还存在着继承、方法覆盖、包含等一些复杂的关系。而这些关系的刻画是由RootBeanDefinition来负责的。RootBeanDefinition也就是我们下面所说的mergedBeanDefinition，mergedBeanDefinition是指对具有继承关系的bean所对应的BeanDefinition的合成，以达到完成表达一个bean的目的。

mergedBeanDefinition在获得后也将被缓存，其被缓存在mergedBeanDefinitions字段中。

protectedRootBeanDefinitiongetMergedLocalBeanDefinition(StringbeanName)throwsBeansException{

//Quickcheckontheconcurrentmapfirst,withminimallocking.RootBeanDefinitionmbd=(RootBeanDefinition)this.mergedBeanDefinitions.get(beanName);

if(mbd!=null){

returnmbd;

}returngetMergedBeanDefinition(beanName,getBeanDefinition(beanName));

}

protectedRootBeanDefinitiongetMergedBeanDefinition(StringbeanName,BeanDefinitionbd)

throwsBeanDefinitionStoreException{

returngetMergedBeanDefinition(beanName,bd,null);

}

/**//*以下是真正的合并BeanDefinition处理*/protectedRootBeanDefinitiongetMergedBeanDefinition(

StringbeanName,BeanDefinitionbd,BeanDefinitioncontainingBd)

throwsBeanDefinitionStoreException{

synchronized(this.mergedBeanDefinitions){//同步mergedBeanDefinitionsRootBeanDefinitionmbd=null;

/**//*如果containingBd为空，先从缓存中查找，containingBd代表的包含bean的beanDefinition，那么什么是包含bean呢？比如B是A的内部类，那么A的实例就是B的实例的包含bean，这里的containingBd所代表的就是那个A。*/

if(containingBd==null){

//这里说明了合并BeanDefinition的处理顺序是先里后外。mbd=(RootBeanDefinition)this.mergedBeanDefinitions.get(beanName);

}

if(mbd==null){//如果缓存中不存在

if(bd.getParentName()==null){//且无父类

//如果当前BeanDefinition不存在parentName，说明该类不存在父类，直接把该类对应的BeanDefinition拷贝到合并BeanDefinitionmbd=newRootBeanDefinition(bd);

}

else{

BeanDefinitionpbd=null;

try{

StringparentBeanName=transformedBeanName(bd.getParentName());//对beanName进行标准化

if(!beanName.equals(parentBeanName)){//如果父类的名称与当前类的名称不相等

//获得父类的合并BeanDefinition

//这里说明了合并BeanDefinition的处理顺序是先父后子pbd=getMergedBeanDefinition(parentBeanName);

}

else{

if(getParentBeanFactory()instanceofConfigurableBeanFactory){//如果相等，则从父工厂中获取pbd=((ConfigurableBeanFactory)getParentBeanFactory()).getMergedBeanDefinition(parentBeanName);

}

else{

thrownewNoSuchBeanDefinitionException(bd.getParentName(),

"Parentname'"+bd.getParentName()+"'isequaltobeanname'"+beanName+"':cannotberesolvedwithoutanAbstractBeanFactoryparent");

}}}

catch(NoSuchBeanDefinitionExceptionex){

thrownewBeanDefinitionStoreException(bd.getResourceDescription(),beanName,

"Couldnotresolveparentbeandefinition'"+bd.getParentName()+"'",ex);

}//进行深度复制mbd=newRootBeanDefinition(pbd);

//用子的BeanDefinition覆盖父亲的mbd.overrideFrom(bd);

}

if(containingBd!=null&&!containingBd.isSingleton()&&mbd.isSingleton()){

//如果包含bean存在，且包含Bean不是单例的(也就是意味着是原型的)，而当前bean却是单例的，那么当前bean的scope应与包含bean的一致。mbd.setScope(containingBd.getScope());

}

if(containingBd==null&&isCacheBeanMetadata()&&isBeanEligibleForMetadataCaching(beanName)){

this.mergedBeanDefinitions.put(beanName,mbd);//置入缓存}}

returnmbd;

}}

3.1.1.2 getObjectFromFactoryBean方法分析

//主要是从FactoryBean获得object

protectedObjectgetObjectFromFactoryBean(FactoryBeanfactory,StringbeanName,booleanshouldPostProcess){

if(factory.isSingleton()&&containsSingleton(beanName)){

//如果facoryBean是单例的话，需要维护factoryBean与object的关系。我们在这里整理一下几个缓存的关系

//<1>factoryBeanObjectCache里存在的一定是由FactoryBean所创建的bean，其对应关系为beanName-->bean实例；

synchronized(getSingletonMutex()){

Objectobject=this.factoryBeanObjectCache.get(beanName);

if(object==null){

//这里通过调用factory.getObject()获取对象object=doGetObjectFromFactoryBean(factory,beanName,shouldPostProcess);

this.factoryBeanObjectCache.put(beanName,(object!=null?object:NULL_OBJECT));

}return(object!=NULL_OBJECT?object:null);

}}

else{

returndoGetObjectFromFactoryBean(factory,beanName,shouldPostProcess);

}}

3.1.2 getSingleton方法分析

publicObjectgetSingleton(StringbeanName,ObjectFactorysingletonFactory){

synchronized(this.singletonObjects){

ObjectsingletonObject=this.singletonObjects.get(beanName);

if(singletonObject==null){

if(this.singletonsCurrentlyInDestruction){

//如果当前工厂的单例缓存处于销毁状态，抛出异常thrownewBeanCreationNotAllowedException(beanName,

"Singletonbeancreationnotallowedwhilethesingletonsofthisfactoryareindestruction"+"(DonotrequestabeanfromaBeanFactoryinadestroymethodimplementation!)");

}//把beanName加入到正在创建状态队列中，用以标识beanName正在创建中beforeSingletonCreation(beanName);

booleanrecordSuppressedExceptions=(this.suppressedExceptions==null);

if(recordSuppressedExceptions){

this.suppressedExceptions=newLinkedHashSet();

}

try{

//这里将要调用creatBean方法singletonObject=singletonFactory.getObject();

}

catch(BeanCreationExceptionex){

if(recordSuppressedExceptions){

for(Iteratorit=this.suppressedExceptions.iterator();it.hasNext();){

ex.addRelatedCause((Exception)it.next());

}}throwex;

}

finally{

if(recordSuppressedExceptions){

this.suppressedExceptions=null;

}//把beanName从正在创建队列中删除afterSingletonCreation(beanName);}addSingleton(beanName,singletonObject);

}return(singletonObject!=NULL_OBJECT?singletonObject:null);

}}

3.1.3 createBean方法分析

protectedObjectcreateBean(finalStringbeanName,finalRootBeanDefinitionmbd,finalObject[]args)

throwsBeanCreationException{

AccessControlContextacc=AccessController.getContext();

returnAccessController.doPrivileged(newPrivilegedAction(){

publicObjectrun(){

//检查BeanDefinition中的beanClass是否存在，如果不存在则通过工具类对className处理获得resolveBeanClass(mbd,beanName);

//Preparemethodoverrides.

//预处理方法的overload情况(对应lookup-method、replaced-method元素)，如果方法在当前beanClass上实现的数量、在beanClass实现的接口声明的数量、在beanClass超类上声明或实现的数量相加的和等于1,那么将overload设为false。如果对lookup-method不熟悉请参看后面的lookup-method使用示例。

//

try{

mbd.prepareMethodOverrides();

}

catch(BeanDefinitionValidationExceptionex){

……

}

try{

//GiveBeanPostProcessorsachancetoreturnaproxyinsteadofthetargetbeaninstance.

//如果bean配置了PostProcessor，那么这里返回的是一个proxyObjectbean=resolveBeforeInstantiation(beanName,mbd);

if(bean!=null){

returnbean;

}}

catch(Throwableex){

thrownewBeanCreationException(mbd.getResourceDescription(),beanName,

"BeanPostProcessorbeforeinstantiationofbeanfailed",ex);

}//所有生成Bean都有BeanWrapper封装，bean的生成采用策略模式，CglibSubclassingInstantiationStrategy实现是默认的策略

//1.如果配置为工厂方法创建(配置了factory-mother的)，由java反射Mehthod的invoke完成bean的创建。

//2.如果采用构造子配置创建(配置了constructor-arg的)，如果bean对应的类包含多个构造子，采用cglib动态字节码构造；如果只有唯一的构造子，那么采用java反射Constructor的newInstance方法

//3.如果是普通bean配置,直接通过反射Class默认的Constructor，然后调用newInstance获得bean.ObjectbeanInstance=doCreateBean(beanName,mbd,args);

if(logger.isDebugEnabled()){

logger.debug("Finishedcreatinginstanceofbean'"+beanName+"'");

}returnbeanInstance;

}},acc);

}

3.1.3.1 doCreateBean方法分析

protectedObjectdoCreateBean(finalStringbeanName,finalRootBeanDefinitionmbd,finalObject[]args){

//Instantiatethebean.BeanWrapperinstanceWrapper=null;

if(mbd.isSingleton()){//如果是singleton类型的，先删除factoryBeaninstanceWrapper=(BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);

}

if(instanceWrapper==null){

//所有生成Bean都有BeanWrapper封装，bean的生成采用策略模式，CglibSubclassingInstantiationStrategy实现是默认的策略

//1.如果配置为工厂方法创建(配置了factory-mother的)，由java反射Mehthod的invoke完成bean的创建。

//2.如果采用构造子配置创建(配置了constructor-arg的)，如果bean对应的类包含多个构造子，采用cglib动态字节码构造；如果只有唯一的构造子，那么采用java反射Constructor的newInstance方法

//3.如果是普通bean配置,直接通过反射Class默认的Constructor，然后调用newInstance获得bean.instanceWrapper=createBeanInstance(beanName,mbd,args);

}finalObjectbean=(instanceWrapper!=null?instanceWrapper.getWrappedInstance():null);

ClassbeanType=(instanceWrapper!=null?instanceWrapper.getWrappedClass():null);

//Allowpost-processorstomodifythemergedbeandefinition.

synchronized(mbd.postProcessingLock){

if(!mbd.postProcessed){

applyMergedBeanDefinitionPostProcessors(mbd,beanType,beanName);

mbd.postProcessed=true;

}}

booleanearlySingletonExposure=(mbd.isSingleton()&&this.allowCircularReferences&&isSingletonCurrentlyInCreation(beanName));

if(earlySingletonExposure){

if(logger.isDebugEnabled()){

logger.debug("Eagerlycachingbean'"+beanName+"'toallowforresolvingpotentialcircularreferences");

}

addSingletonFactory(beanName,newObjectFactory(){

publicObjectgetObject()throwsBeansException{

returngetEarlyBeanReference(beanName,mbd,bean);

}});

}

//Initializethebeaninstance.ObjectexposedObject=bean;

try{

populateBean(beanName,mbd,instanceWrapper);

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);

SetactualDependentBeans=newLinkedHashSet(dependentBeans.length);

for(inti=0;i{

StringdependentBean=dependentBeans[i];

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.registerDisposableBeanIfNecessary(beanName,bean,mbd);

returnexposedObject;

}

posted on -01-30 16:04 zhangxl 阅读(3197) 评论(0) 编辑 收藏 所属分类: Spring