第Spring源碼解析Bean屬性填充目錄前言屬性填充執(zhí)行回調(diào)方法及后置處理器

前言

在上一篇文章中，我們分析了Spring中Bean的實例化過程，在結尾我們知道了雖然bean的實例化完成了，但是其中的屬性還沒有被注入，今天我們就接著來分析屬性是如何被注入的。

屬性填充

實例化完成后，回到上面第3條的doCreateBean方法中，看一下用BeanWrapper產(chǎn)生的原生對象，里面dao這個屬性還是null值。

回歸一下之前的代碼，接下來要調(diào)用populateBean方法進行屬性的填充：

ObjectexposedObject=bean;

try{

populateBean(beanName,mbd,instanceWrapper);

exposedObject=initializeBean(beanName,exposedObject,mbd);

}

看一下populateBean中的核心代碼：

for(BeanPostProcessorbp:getBeanPostProcessors()){

if(bpinstanceofInstantiationAwareBeanPostProcessor){

InstantiationAwareBeanPostProcessoribp=(InstantiationAwareBeanPostProcessor)bp;

pvs=ibp.postProcessPropertyValues(pvs,filteredPds,bw.getWrappedInstance(),beanName);

if(pvs==null){

return;

}

這里通過getBeanPostProcessors方法獲得當前注冊的所有后置處理器，如果屬于InstantiationAwareBeanPostProcessor類型，則調(diào)用它的postProcessPropertyValues方法。通過遍歷，可以知道當前spring中存在7個后置處理器：

我們主要來看一下AutowiredAnnotationBeanPostProcessor，因為它負責對添加了@Autowired、@Value等注解的屬性進行依賴的填充。進入它的postProcessPropertyValues方法：

publicPropertyValuespostProcessPropertyValues(

PropertyValuespvs,PropertyDescriptor[]pds,Objectbean,StringbeanName)throwsBeanCreationException{

InjectionMetadatametadata=findAutowiringMetadata(beanName,bean.getClass(),pvs);

try{

metadata.inject(bean,beanName,pvs);

//異常處理代碼省略...

returnpvs;

}

這里的InjectionMetadata可以理解為要注入的屬性的元數(shù)據(jù)，在它里面維護了一個Collection，來存放所有需要注入的bean：

privatefinalCollectionInjectedElementinjectedElements;

進入findAutowiringMetadata方法：

privateInjectionMetadatafindAutowiringMetadata(StringbeanName,Classclazz,@NullablePropertyValuespvs){

StringcacheKey=(StringUtils.hasLength(beanName)beanName:clazz.getName());

InjectionMetadatametadata=this.injectionMetadataCache.get(cacheKey);

//省略非重要代碼...

returnmetadata;

}

在執(zhí)行完這一步后，就把需要填充的屬性放進了剛才提到的injectedElements中：

接下來，繼續(xù)執(zhí)行InjectionMetadata的inject方法，在其中遍歷所有需要注入的屬性的列表，遍歷調(diào)用AutowiredAnnotationBeanPostProcessor的inject方法：

protectedvoidinject(Objectbean,@NullableStringbeanName,@NullablePropertyValuespvs)throwsThrowable{

Fieldfield=(Field)this.member;

Objectvalue;

if(this.cached){

value=resolvedCachedArgument(beanName,this.cachedFieldValue);

else{

DependencyDescriptordesc=newDependencyDescriptor(field,this.required);

desc.setContainingClass(bean.getClass());

SetStringautowiredBeanNames=newLinkedHashSet(1);

Assert.state(beanFactory!=null,"NoBeanFactoryavailable");

TypeConvertertypeConverter=beanFactory.getTypeConverter();

try{//用beanFactory解決依賴

value=beanFactory.resolveDependency(desc,beanName,autowiredBeanNames,typeConverter);

//后面代碼省略...

這里創(chuàng)建了一個DependencyDescriptor，用來維護注入屬性與它的容器類containingClass的關系，里面最重要的就是存放了注入屬性的類型、名稱，以及containingClass的類型等信息。

調(diào)用resolveDependency方法，其中沒有做什么實質(zhì)性的工作，繼續(xù)調(diào)用了doResolveDependency方法：

publicObjectdoResolveDependency(DependencyDescriptordescriptor,@NullableStringbeanName,

@NullableSetStringautowiredBeanNames,@NullableTypeConvertertypeConverter)throwsBeansException{

InjectionPointpreviousInjectionPoint=ConstructorResolver.setCurrentInjectionPoint(descriptor);

try{

Objectshortcut=descriptor.resolveShortcut(this);

if(shortcut!=null){

returnshortcut;

//依賴的屬性值的類型

Classtype=descriptor.getDependencyType();

Objectvalue=getAutowireCandidateResolver().getSuggestedValue(descriptor);

if(value!=null){

if(valueinstanceofString){

StringstrVal=resolveEmbeddedValue((String)value);

BeanDefinitionbd=(beanName!=nullcontainsBean(beanName)getMergedBeanDefinition(beanName):null);

value=evaluateBeanDefinitionString(strVal,bd);

TypeConverterconverter=(typeConverter!=nulltypeConverter:getTypeConverter());

return(descriptor.getField()!=null

converter.convertIfNecessary(value,type,descriptor.getField()):

converter.convertIfNecessary(value,type,descriptor.getMethodParameter()));

ObjectmultipleBeans=resolveMultipleBeans(descriptor,beanName,autowiredBeanNames,typeConverter);

if(multipleBeans!=null){

returnmultipleBeans;

//把匹配的值和類型拿出來，放到一個map中

MapString,ObjectmatchingBeans=findAutowireCandidates(beanName,type,descriptor);

if(matchingBeans.isEmpty()){

if(isRequired(descriptor)){

raiseNoMatchingBeanFound(type,descriptor.getResolvableType(),descriptor);

returnnull;

StringautowiredBeanName;

ObjectinstanceCandidate;

//如果有超過一個匹配的，可能會有錯誤

if(matchingBeans.size()1){

autowiredBeanName=determineAutowireCandidate(matchingBeans,descriptor);

if(autowiredBeanName==null){

if(isRequired(descriptor)||!indicatesMultipleBeans(type)){

returndescriptor.resolveNotUnique(type,matchingBeans);

else{

returnnull;

instanceCandidate=matchingBeans.get(autowiredBeanName);

else{

Map.EntryString,Objectentry=matchingBeans.entrySet().iterator().next();

autowiredBeanName=entry.getKey();

instanceCandidate=entry.getValue();

if(autowiredBeanNames!=null){

//把找到的bean的名字放到set中

autowiredBeanNames.add(autowiredBeanName);

if(instanceCandidateinstanceofClass){

//實際獲取注入的bean

instanceCandidate=descriptor.resolveCandidate(autowiredBeanName,type,this);

Objectresult=instanceCandidate;

if(resultinstanceofNullBean){

if(isRequired(descriptor)){

raiseNoMatchingBeanFound(type,descriptor.getResolvableType(),descriptor);

result=null;

if(!ClassUtils.isAssignableValue(type,result)){

thrownewBeanNotOfRequiredTypeException(autowiredBeanName,type,instanceCandidate.getClass());

returnresult;

finally{

ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);

}

通過findAutowireCandidates方法，獲取與注入屬性匹配的值和類型，放到一個Map當中，再通過它的beanName，調(diào)用resolveCandidate方法，實際獲取注入的bean實例。這一操作底層調(diào)用的也是BeanFactory的getBean方法。

回到inject方法，使用反射將注入的bean實例賦值給屬性：

ReflectionUtils.makeAccessible(field);

field.set(bean,value);

在執(zhí)行完populateBean方法后，依賴的屬性已經(jīng)被注入成功了。

執(zhí)行回調(diào)方法及后置處理器

在bean實例化完成后，執(zhí)行各種回調(diào)和后置管理器方法：

protectedObjectinitializeBean(finalStringbeanName,finalObjectbean,@NullableRootBeanDefinitionmbd){

if(System.getSecurityManager()!=null){

AccessController.doPrivileged((PrivilegedActionObject)()-{

invokeAwareMethods(beanName,bean);

returnnull;

},getAccessControlContext());

else{

//若bean實現(xiàn)了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware接口，執(zhí)行回調(diào)方法

invokeAwareMethods(beanName,bean);

ObjectwrappedBean=bean;

if(mbd==null||!mbd.isSynthetic()){

//執(zhí)行所有后置處理器的before方法

wrappedBean=applyBeanPostProcessorsBeforeInitialization(wrappedBean,beanName);

try{

//執(zhí)行bean生命周期回調(diào)中的init-method

//若bean實現(xiàn)了InitializingBean接口，執(zhí)行afterPropertiesSet方法

in