Spring 自動裝配之依賴注入
依賴注入發(fā)生的時間
當(dāng)Spring IOC 容器完成了Bean 定義資源的定位、載入和解析注冊以后，IOC 容器中已經(jīng)管理類Bean定義的相關(guān)數(shù)據(jù)，但是此時IOC 容器還沒有對所管理的Bean 進行依賴注入，依賴注入在以下兩種情況發(fā)生：
1)、用戶第一次調(diào)用getBean()方法時，IOC 容器觸發(fā)依賴注入。
2)、當(dāng)用戶在配置文件中將<bean>元素配置了lazy-init=false 屬性，即讓容器在解析注冊Bean 定義時進行預(yù)實例化，觸發(fā)依賴注入。
BeanFactory 接口定義了Spring IOC 容器的基本功能規(guī)范，是Spring IOC 容器所應(yīng)遵守的最底層和最基本的編程規(guī)范。BeanFactory 接口中定義了幾個getBean()方法，就是用戶向IOC 容器索取管理的Bean 的方法，我們通過分析其子類的具體實現(xiàn)，理解Spring IOC 容器在用戶索取Bean 時如何完成依賴注入。
image.png
在BeanFactory 中我們可以看到getBean(String...)方法，但它具體實現(xiàn)在AbstractBeanFactory 中。
尋找獲取Bean 的入口
AbstractBeanFactory 的getBean()相關(guān)方法的源碼如下：
//獲取IOC 容器中指定名稱的Bean
@Override
public Object getBean(String name) throws BeansException {
//doGetBean 才是真正向IOC 容器獲取被管理Bean 的過程
return doGetBean(name, null, null, false);
}
//獲取IOC 容器中指定名稱和類型的Bean
@Override
public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
//doGetBean 才是真正向IOC 容器獲取被管理Bean 的過程
return doGetBean(name, requiredType, null, false);
}
//獲取IOC 容器中指定名稱和參數(shù)的Bean
@Override
public Object getBean(String name, Object... args) throws BeansException {
//doGetBean 才是真正向IOC 容器獲取被管理Bean 的過程
return doGetBean(name, null, args, false);
}
//獲取IOC 容器中指定名稱、類型和參數(shù)的Bean
public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
throws BeansException {
//doGetBean 才是真正向IOC 容器獲取被管理Bean 的過程
return doGetBean(name, requiredType, args, false);
}
@SuppressWarnings("unchecked")
//真正實現(xiàn)向IOC 容器獲取Bean 的功能，也是觸發(fā)依賴注入功能的地方
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//根據(jù)指定的名稱獲取被管理Bean 的名稱，剝離指定名稱中對容器的相關(guān)依賴
//如果指定的是別名，將別名轉(zhuǎn)換為規(guī)范的Bean 名稱
final String beanName = transformedBeanName(name);
Object bean;
//先從緩存中取是否已經(jīng)有被創(chuàng)建過的單態(tài)類型的Bean
//對于單例模式的Bean 整個IOC 容器中只創(chuàng)建一次，不需要重復(fù)創(chuàng)建
Object sharedInstance = getSingleton(beanName);
//IOC 容器創(chuàng)建單例模式Bean 實例對象
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
//如果指定名稱的Bean 在容器中已有單例模式的Bean 被創(chuàng)建
//直接返回已經(jīng)創(chuàng)建的Bean
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
} else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//獲取給定Bean 的實例對象，主要是完成FactoryBean 的相關(guān)處理
//注意：BeanFactory 是管理容器中Bean 的工廠，而FactoryBean 是
//創(chuàng)建創(chuàng)建對象的工廠Bean，兩者之間有區(qū)別
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
//緩存沒有正在創(chuàng)建的單例模式Bean
//緩存中已經(jīng)有已經(jīng)創(chuàng)建的原型模式Bean
//但是由于循環(huán)引用的問題導(dǎo)致實例化對象失敗
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//對IOC 容器中是否存在指定名稱的BeanDefinition 進行檢查，首先檢查是否
//能在當(dāng)前的BeanFactory 中獲取的所需要的Bean，如果不能則委托當(dāng)前容器
//的父級容器去查找，如果還是找不到則沿著容器的繼承體系向父級容器查找
BeanFactory parentBeanFactory = getParentBeanFactory();
//當(dāng)前容器的父級容器存在，且當(dāng)前容器中不存在指定名稱的Bean
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
//解析指定Bean 名稱的原始名稱
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
} else if (args != null) {
//委派父級容器根據(jù)指定名稱和顯式的參數(shù)查找
return (T) parentBeanFactory.getBean(nameToLookup, args);
} else {
//委派父級容器根據(jù)指定名稱和類型查找
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
//創(chuàng)建的Bean 是否需要進行類型驗證，一般不需要
if (!typeCheckOnly) {
//向容器標(biāo)記指定的Bean 已經(jīng)被創(chuàng)建
markBeanAsCreated(beanName);
}
try {
//根據(jù)指定Bean 名稱獲取其父級的Bean 定義
//主要解決Bean 繼承時子類合并父類公共屬性問題
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
//獲取當(dāng)前Bean 所有依賴Bean 的名稱
String[] dependsOn = mbd.getDependsOn();
//如果當(dāng)前Bean 有依賴Bean
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//遞歸調(diào)用getBean 方法，獲取當(dāng)前Bean 的依賴Bean
registerDependentBean(dep, beanName);
//把被依賴Bean 注冊給當(dāng)前依賴的Bean
getBean(dep);
}
}
//創(chuàng)建單例模式Bean 的實例對象
if (mbd.isSingleton()) {
//這里使用了一個匿名內(nèi)部類，創(chuàng)建Bean 實例對象，并且注冊給所依賴的對象
sharedInstance = getSingleton(beanName, () -> {
try {
//創(chuàng)建一個指定Bean 實例對象，如果有父級繼承，則合并子類和父類的定義
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
//顯式地從容器單例模式Bean 緩存中清除實例對象
destroySingleton(beanName);
throw ex;
}
});
//獲取給定Bean 的實例對象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//IOC 容器創(chuàng)建原型模式Bean 實例對象
else if (mbd.isPrototype()) {
//原型模式(Prototype)是每次都會創(chuàng)建一個新的對象
Object prototypeInstance = null;
try {
//回調(diào)beforePrototypeCreation 方法，默認(rèn)的功能是注冊當(dāng)前創(chuàng)建的原型對象
beforePrototypeCreation(beanName);
//創(chuàng)建指定Bean 對象實例
prototypeInstance = createBean(beanName, mbd, args);
} finally {
//回調(diào)afterPrototypeCreation 方法，默認(rèn)的功能告訴IOC 容器指定Bean 的原型對象不再創(chuàng)建
afterPrototypeCreation(beanName);
}
//獲取給定Bean 的實例對象
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//要創(chuàng)建的Bean 既不是單例模式，也不是原型模式，則根據(jù)Bean 定義資源中
//配置的生命周期范圍，選擇實例化Bean 的合適方法，這種在Web 應(yīng)用程序中
//比較常用，如：request、session、application 等生命周期
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
//Bean 定義資源中沒有配置生命周期范圍，則Bean 定義不合法
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
//這里又使用了一個匿名內(nèi)部類，獲取一個指定生命周期范圍的實例
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
});
//獲取給定Bean 的實例對象
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
} catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
//對創(chuàng)建的Bean 實例對象進行類型檢查
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
} catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
通過上面對向IOC 容器獲取Bean 方法的分析，我們可以看到在Spring 中，如果Bean 定義的單例模式(Singleton)，則容器在創(chuàng)建之前先從緩存中查找，以確保整個容器中只存在一個實例對象。如果Bean定義的是原型模式(Prototype)，則容器每次都會創(chuàng)建一個新的實例對象。除此之外，Bean 定義還可以擴展為指定其生命周期范圍。
上面的源碼只是定義了根據(jù)Bean 定義的模式，采取的不同創(chuàng)建Bean 實例對象的策略，具體的Bean實例對象的創(chuàng)建過程由實現(xiàn)了ObjectFactory 接口的匿名內(nèi)部類的createBean() 方法完成，ObjectFactory 使用委派模式， 具體的Bean 實例創(chuàng)建過程交由其實現(xiàn)類AbstractAutowireCapableBeanFactory 完成，我們繼續(xù)分析AbstractAutowireCapableBeanFactory的createBean()方法的源碼，理解其創(chuàng)建Bean 實例的具體實現(xiàn)過程。
開始實例化
AbstractAutowireCapableBeanFactory 類實現(xiàn)了ObjectFactory 接口，創(chuàng)建容器指定的Bean 實例對象，同時還對創(chuàng)建的Bean 實例對象進行初始化處理。其創(chuàng)建Bean 實例對象的方法源碼如下：
//創(chuàng)建Bean 實例對象
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
//判斷需要創(chuàng)建的Bean 是否可以實例化，即是否可以通過當(dāng)前的類加載器加載
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//校驗和準(zhǔn)備Bean 中的方法覆蓋
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of Method overrides failed", ex);
}
try {
//如果Bean 配置了初始化前和初始化后的處理器，則試圖返回一個需要創(chuàng)建Bean 的代理對象
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
//創(chuàng)建Bean 的入口
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (BeanCreationException ex) {
throw ex;
} catch (ImplicitlyAppearedSingletonException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
//真正創(chuàng)建Bean 的方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
//封裝被創(chuàng)建的Bean 對象
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
//獲取實例化對象的類型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
//調(diào)用PostProcessor 后置處理器
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
//向容器中緩存單例模式的Bean 對象，以防循環(huán)引用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//這里是一個匿名內(nèi)部類，為了防止循環(huán)引用，盡早持有對象的引用
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
//Bean 對象的初始化，依賴注入在此觸發(fā)
//這個exposedObject 在初始化完成之后返回作為依賴注入完成后的Bean
Object exposedObject = bean;
try {
//將Bean 實例對象封裝，并且Bean 定義中配置的屬性值賦值給實例對象
populateBean(beanName, mbd, instanceWrapper);
//初始化Bean 對象
exposedObject = initializeBean(beanName, exposedObject, mbd);
} catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
} else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
//獲取指定名稱的已注冊的單例模式Bean 對象
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
//根據(jù)名稱獲取的已注冊的Bean 和正在實例化的Bean 是同一個
if (exposedObject == bean) {
//當(dāng)前實例化的Bean 初始化完成
exposedObject = earlySingletonReference;
}
//當(dāng)前Bean 依賴其他Bean，并且當(dāng)發(fā)生循環(huán)引用時不允許新創(chuàng)建實例對象
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
//獲取當(dāng)前Bean 所依賴的其他Bean
for (String dependentBean : dependentBeans) {
//對依賴Bean 進行類型檢查
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
//注冊完成依賴注入的Bean
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
通過上面的源碼注釋，我們看到具體的依賴注入實現(xiàn)其實就在以下兩個方法中：
1)、createBeanInstance()方法，生成Bean 所包含的java 對象實例。
2)、populateBean()方法，對Bean 屬性的依賴注入進行處理。
下面繼續(xù)分析這兩個方法的代碼實現(xiàn)。
選擇Bean 實例化策略
在createBeanInstance()方法中，根據(jù)指定的初始化策略，使用簡單工廠、工廠方法或者容器的自動裝配特性生成Java 實例對象，創(chuàng)建對象的源碼如下：
//創(chuàng)建Bean 的實例對象
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
//檢查確認(rèn)Bean 是可實例化的
Class<?> beanClass = resolveBeanClass(mbd, beanName);
//使用工廠方法對Bean 進行實例化
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
if (mbd.getFactoryMethodName() != null) {
//調(diào)用工廠方法實例化
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
//使用容器的自動裝配方法進行實例化
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
//配置了自動裝配屬性，使用容器的自動裝配實例化
//容器的自動裝配是根據(jù)參數(shù)類型匹配Bean 的構(gòu)造方法
return autowireConstructor(beanName, mbd, null, null);
} else {
//使用默認(rèn)的無參構(gòu)造方法實例化
return instantiateBean(beanName, mbd);
}
}
//使用Bean 的構(gòu)造方法進行實例化
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//使用容器的自動裝配特性，調(diào)用匹配的構(gòu)造方法實例化
return autowireConstructor(beanName, mbd, ctors, args);
}
//使用默認(rèn)的無參構(gòu)造方法實例化
return instantiateBean(beanName, mbd);
}
//使用默認(rèn)的無參構(gòu)造方法實例化Bean 對象
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
//獲取系統(tǒng)的安全管理接口，JDK 標(biāo)準(zhǔn)的安全管理API
if (System.getSecurityManager() != null) {
//這里是一個匿名內(nèi)置類，根據(jù)實例化策略創(chuàng)建實例對象
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
} else {
//將實例化的對象封裝起來
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
} catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
經(jīng)過對上面的代碼分析，我們可以看出，對使用工廠方法和自動裝配特性的Bean 的實例化相當(dāng)比較清楚，調(diào)用相應(yīng)的工廠方法或者參數(shù)匹配的構(gòu)造方法即可完成實例化對象的工作，但是對于我們最常使用的默認(rèn)無參構(gòu)造方法就需要使用相應(yīng)的初始化策略(JDK 的反射機制或者CGLib)來進行初始化了，在方法getInstantiationStrategy().instantiate()中就具體實現(xiàn)類使用初始策略實例化象。
執(zhí)行Bean 實例化
在使用默認(rèn)的無參構(gòu)造方法創(chuàng)建Bean 的實例化對象時，方法getInstantiationStrategy().instantiate()調(diào)用了SimpleInstantiationStrategy 類中的實例化Bean 的方法，其源碼如下：
//使用初始化策略實例化Bean 對象
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// Don't override the class with CGLib if no overrides.
//如果Bean 定義中沒有方法覆蓋，則就不需要CGLib 父類類的方法
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
//獲取對象的構(gòu)造方法或工廠方法
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
//如果沒有構(gòu)造方法且沒有工廠方法
if (constructorToUse == null) {
//使用JDK 的反射機制，判斷要實例化的Bean 是否是接口
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
//這里是一個匿名內(nèi)置類，使用反射機制獲取Bean 的構(gòu)造方法
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) () -> clazz.getDeclaredConstructor());
} else {
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
} catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
//使用BeanUtils 實例化，通過反射機制調(diào)用”構(gòu)造方法.newInstance(arg)”來進行實例化
return BeanUtils.instantiateClass(constructorToUse);
} else {
// Must generate CGLib subclass.
//使用CGLib 來實例化對象
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
通過上面的代碼分析，我們看到了如果Bean 有方法被覆蓋了，則使用JDK 的反射機制進行實例化，否則，使用CGLib 進行實例化。
instantiateWithMethodInjection() 方法調(diào)用SimpleInstantiationStrategy 的子類CGLibSubclassingInstantiationStrategy 使用CGLib 來進行初始化，其源碼如下：
//使用CGLib 進行Bean 對象實例化
public Object instantiate(@Nullable Constructor<?> ctor, @Nullable Object... args) {
//創(chuàng)建代理子類
Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
Object instance;
if (ctor == null) {
instance = BeanUtils.instantiateClass(subclass);
} else {
try {
Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
instance = enhancedSubclassConstructor.newInstance(args);
} catch (Exception ex) {
throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
"Failed to invoke constructor for CGLib enhanced subclass [" + subclass.getName() + "]", ex);
}
}
Factory factory = (Factory) instance;
factory.setCallbacks(new Callback[]{NoOp.INSTANCE,
new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
return instance;
}
private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {
//CGLib 中的類
Enhancer enhancer = new Enhancer();
//將Bean 本身作為其基類
enhancer.setSuperclass(beanDefinition.getBeanClass());
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
if (this.owner instanceof ConfigurableBeanFactory) {
ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader();
enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
}
enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
enhancer.setCallbackTypes(CALLBACK_TYPES);
//使用CGLib 的createClass 方法生成實例對象
return enhancer.createClass();
}
CGLib 是一個常用的字節(jié)碼生成器的類庫，它提供了一系列API 實現(xiàn)Java 字節(jié)碼的生成和轉(zhuǎn)換功能。我們在學(xué)習(xí)JDK 的動態(tài)代理時都知道，JDK 的動態(tài)代理只能針對接口，如果一個類沒有實現(xiàn)任何接口，要對其進行動態(tài)代理只能使用CGLib。
準(zhǔn)備依賴注入
在前面的分析中我們已經(jīng)了解到Bean 的依賴注入主要分為兩個步驟，首先調(diào)用createBeanInstance()方法生成Bean 所包含的Java 對象實例。然后，調(diào)用populateBean()方法，對Bean 屬性的依賴注入進行處理。
上面我們已經(jīng)分析了容器初始化生成Bean 所包含的Java 實例對象的過程，現(xiàn)在我們繼續(xù)分析生成對象后，Spring IOC 容器是如何將Bean 的屬性依賴關(guān)系注入Bean 實例對象中并設(shè)置好的，回到AbstractAutowireCapableBeanFactory 的populateBean()方法，對屬性依賴注入的代碼如下：
//將Bean 屬性設(shè)置到生成的實例對象上
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
} else {
return;
}
}
boolean continueWithPropertyPopulation = true;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
//獲取容器在解析Bean 定義資源時為BeanDefiniton 中設(shè)置的屬性值
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
if (pvs != null) {
//對屬性進行注入
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
//解析并注入依賴屬性的過程
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
if (pvs.isEmpty()) {
return;
}
//封裝屬性值
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
if (System.getSecurityManager() != null) {
if (bw instanceof BeanWrapperImpl) {
//設(shè)置安全上下文，JDK 安全機制
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
}
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
//屬性值已經(jīng)轉(zhuǎn)換
if (mpvs.isConverted()) {
try {
//為實例化對象設(shè)置屬性值
bw.setPropertyValues(mpvs);
return;
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
//獲取屬性值對象的原始類型值
original = mpvs.getPropertyValueList();
} else {
original = Arrays.asList(pvs.getPropertyValues());
}
//獲取用戶自定義的類型轉(zhuǎn)換
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
//創(chuàng)建一個Bean 定義屬性值解析器，將Bean 定義中的屬性值解析為Bean 實例對象的實際值
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
//為屬性的解析值創(chuàng)建一個拷貝，將拷貝的數(shù)據(jù)注入到實例對象中
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
for (PropertyValue pv : original) {
//屬性值不需要轉(zhuǎn)換
if (pv.isConverted()) {
deepCopy.add(pv);
}
//屬性值需要轉(zhuǎn)換
else {
String propertyName = pv.getName();
//原始的屬性值，即轉(zhuǎn)換之前的屬性值
Object originalValue = pv.getValue();
//轉(zhuǎn)換屬性值，例如將引用轉(zhuǎn)換為IOC 容器中實例化對象引用
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
//轉(zhuǎn)換之后的屬性值
Object convertedValue = resolvedValue;
//屬性值是否可以轉(zhuǎn)換
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
//使用用戶自定義的類型轉(zhuǎn)換器轉(zhuǎn)換屬性值
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
//存儲轉(zhuǎn)換后的屬性值，避免每次屬性注入時的轉(zhuǎn)換工作
if (resolvedValue == originalValue) {
if (convertible) {
//設(shè)置屬性轉(zhuǎn)換之后的值
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
//屬性是可轉(zhuǎn)換的，且屬性原始值是字符串類型，且屬性的原始類型值不是
//動態(tài)生成的字符串，且屬性的原始值不是集合或者數(shù)組類型
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
//重新封裝屬性的值
deepCopy.add(pv);
} else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
//標(biāo)記屬性值已經(jīng)轉(zhuǎn)換過
mpvs.setConverted();
}
//進行屬性依賴注入
try {
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
分析上述代碼，我們可以看出，對屬性的注入過程分以下兩種情況：
1)、屬性值類型不需要強制轉(zhuǎn)換時，不需要解析屬性值，直接準(zhǔn)備進行依賴注入。
2)、屬性值需要進行類型強制轉(zhuǎn)換時，如對其他對象的引用等，首先需要解析屬性值，然后對解析后的屬性值進行依賴注入。
對屬性值的解析是在BeanDefinitionValueResolver 類中的resolveValueIfNecessary()方法中進行的，對屬性值的依賴注入是通過bw.setPropertyValues()方法實現(xiàn)的，在分析屬性值的依賴注入之前，我們先分析一下對屬性值的解析過程。
解析屬性注入規(guī)則
當(dāng)容器在對屬性進行依賴注入時，如果發(fā)現(xiàn)屬性值需要進行類型轉(zhuǎn)換，如屬性值是容器中另一個Bean實例對象的引用，則容器首先需要根據(jù)屬性值解析出所引用的對象，然后才能將該引用對象注入到目標(biāo)實例對象的屬性上去，對屬性進行解析的由resolveValueIfNecessary()方法實現(xiàn)，其源碼如下：
//解析屬性值，對注入類型進行轉(zhuǎn)換
@Nullable
public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
//對引用類型的屬性進行解析
if (value instanceof RuntimeBeanReference) {
RuntimeBeanReference ref = (RuntimeBeanReference) value;
//調(diào)用引用類型屬性的解析方法
return resolveReference(argName, ref);
}
//對屬性值是引用容器中另一個Bean 名稱的解析
else if (value instanceof RuntimeBeanNameReference) {
String refName = ((RuntimeBeanNameReference) value).getBeanName();
refName = String.valueOf(doEvaluate(refName));
//從容器中獲取指定名稱的Bean
if (!this.beanFactory.containsBean(refName)) {
throw new BeanDefinitionStoreException(
"Invalid bean name '" + refName + "' in bean reference for " + argName);
}
return refName;
}
//對Bean 類型屬性的解析，主要是Bean 中的內(nèi)部類
else if (value instanceof BeanDefinitionHolder) {
BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
} else if (value instanceof BeanDefinition) {
BeanDefinition bd = (BeanDefinition) value;
String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
ObjectUtils.getIdentityHexString(bd);
return resolveInnerBean(argName, innerBeanName, bd);
}
//對集合數(shù)組類型的屬性解析
else if (value instanceof ManagedArray) {
ManagedArray array = (ManagedArray) value;
//獲取數(shù)組的類型
Class<?> elementType = array.resolvedElementType;
if (elementType == null) {
//獲取數(shù)組元素的類型
String elementTypeName = array.getElementTypeName();
if (StringUtils.hasText(elementTypeName)) {
try {
//使用反射機制創(chuàng)建指定類型的對象
elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
array.resolvedElementType = elementType;
} catch (Throwable ex) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error resolving array type for " + argName, ex);
}
}
//沒有獲取到數(shù)組的類型，也沒有獲取到數(shù)組元素的類型
//則直接設(shè)置數(shù)組的類型為Object
else {
elementType = Object.class;
}
}
//創(chuàng)建指定類型的數(shù)組
return resolveManagedArray(argName, (List<?>) value, elementType);
}
//解析list 類型的屬性值
else if (value instanceof ManagedList) {
return resolveManagedList(argName, (List<?>) value);
}
//解析set 類型的屬性值
else if (value instanceof ManagedSet) {
return resolveManagedSet(argName, (Set<?>) value);
}
//解析map 類型的屬性值
else if (value instanceof ManagedMap) {
return resolveManagedMap(argName, (Map<?, ?>) value);
}
//解析props 類型的屬性值，props 其實就是key 和value 均為字符串的map
else if (value instanceof ManagedProperties) {
Properties original = (Properties) value;
//創(chuàng)建一個拷貝，用于作為解析后的返回值
Properties copy = new Properties();
original.forEach((propKey, propValue) -> {
if (propKey instanceof TypedStringValue) {
propKey = evaluate((TypedStringValue) propKey);
}
if (propValue instanceof TypedStringValue) {
propValue = evaluate((TypedStringValue) propValue);
}
if (propKey == null || propValue == null) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error converting Properties key/value pair for " + argName + ": resolved to null");
}
copy.put(propKey, propValue);
});
return copy;
}
//解析字符串類型的屬性值
else if (value instanceof TypedStringValue) {
TypedStringValue typedStringValue = (TypedStringValue) value;
Object valueObject = evaluate(typedStringValue);
try {
//獲取屬性的目標(biāo)類型
Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
if (resolvedTargetType != null) {
//對目標(biāo)類型的屬性進行解析，遞歸調(diào)用
return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
}
//沒有獲取到屬性的目標(biāo)對象，則按Object 類型返回
else {
return valueObject;
}
} catch (Throwable ex) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error converting typed String value for " + argName, ex);
}
} else if (value instanceof NullBean) {
return null;
} else {
return evaluate(value);
}
}
//解析引用類型的屬性值
@Nullable
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
try {
Object bean;
//獲取引用的Bean 名稱
String refName = ref.getBeanName();
refName = String.valueOf(doEvaluate(refName));
//如果引用的對象在父類容器中，則從父類容器中獲取指定的引用對象
if (ref.isToParent()) {
if (this.beanFactory.getParentBeanFactory() == null) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Can't resolve reference to bean '" + refName +
"' in parent factory: no parent factory available");
}
bean = this.beanFactory.getParentBeanFactory().getBean(refName);
}
//從當(dāng)前的容器中獲取指定的引用Bean 對象，如果指定的Bean 沒有被實例化
//則會遞歸觸發(fā)引用Bean 的初始化和依賴注入
else {
bean = this.beanFactory.getBean(refName);
//將當(dāng)前實例化對象的依賴引用對象
this.beanFactory.registerDependentBean(refName, this.beanName);
}
if (bean instanceof NullBean) {
bean = null;
}
return bean;
} catch (BeansException ex) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
}
}
//解析array 類型的屬性
private Object resolveManagedArray(Object argName, List<?> ml, Class<?> elementType) {
//創(chuàng)建一個指定類型的數(shù)組，用于存放和返回解析后的數(shù)組
Object resolved = Array.newInstance(elementType, ml.size());
for (int i = 0; i < ml.size(); i++) {
//遞歸解析array 的每一個元素，并將解析后的值設(shè)置到resolved 數(shù)組中，索引為i
Array.set(resolved, i,
resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));
}
return resolved;
}
通過上面的代碼分析，我們明白了Spring 是如何將引用類型，內(nèi)部類以及集合類型等屬性進行解析的，屬性值解析完成后就可以進行依賴注入了，依賴注入的過程就是Bean 對象實例設(shè)置到它所依賴的Bean對象屬性上去。而真正的依賴注入是通過bw.setPropertyValues()方法實現(xiàn)的，該方法也使用了委托模式， 在BeanWrapper 接口中至少定義了方法聲明， 依賴注入的具體實現(xiàn)交由其實現(xiàn)類BeanWrapperImpl 來完成，下面我們就分析依BeanWrapperImpl 中賴注入相關(guān)的源碼。
注入賦值
BeanWrapperImpl 類主要是對容器中完成初始化的Bean 實例對象進行屬性的依賴注入，即把Bean對象設(shè)置到它所依賴的另一個Bean 的屬性中去。然而，BeanWrapperImpl 中的注入方法實際上由AbstractNestablePropertyAccessor 來實現(xiàn)的，其相關(guān)源碼如下：
//實現(xiàn)屬性依賴注入功能
protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
if (tokens.keys != null) {
processKeyedProperty(tokens, pv);
} else {
processLocalProperty(tokens, pv);
}
}
//實現(xiàn)屬性依賴注入功能
@SuppressWarnings("unchecked")
private void processKeyedProperty(PropertyTokenHolder tokens, PropertyValue pv) {
//調(diào)用屬性的getter(readerMethod)方法，獲取屬性的值
Object propValue = getPropertyHoldingValue(tokens);
PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
if (ph == null) {
throw new InvalidPropertyException(
getRootClass(), this.nestedPath + tokens.actualName, "No property handler found");
}
Assert.state(tokens.keys != null, "No token keys");
String lastKey = tokens.keys[tokens.keys.length - 1];
//注入array 類型的屬性值
if (propValue.getClass().isArray()) {
Class<?> requiredType = propValue.getClass().getComponentType();
int arrayIndex = Integer.parseInt(lastKey);
Object oldValue = null;
try {
if (isExtractOldValueForEditor() && arrayIndex < Array.getLength(propValue)) {
oldValue = Array.get(propValue, arrayIndex);
}
Object convertedValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
requiredType, ph.nested(tokens.keys.length));
//獲取集合類型屬性的長度
int length = Array.getLength(propValue);
if (arrayIndex >= length && arrayIndex < this.autoGrowCollectionLimit) {
Class<?> componentType = propValue.getClass().getComponentType();
Object newArray = Array.newInstance(componentType, arrayIndex + 1);
System.arraycopy(propValue, 0, newArray, 0, length);
setPropertyValue(tokens.actualName, newArray);
//調(diào)用屬性的getter(readerMethod)方法，獲取屬性的值
propValue = getPropertyValue(tokens.actualName);
}
//將屬性的值賦值給數(shù)組中的元素
Array.set(propValue, arrayIndex, convertedValue);
} catch (IndexOutOfBoundsException ex) {
throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
"Invalid array index in property path '" + tokens.canonicalName + "'", ex);
}
}
//注入list 類型的屬性值
else if (propValue instanceof List) {
//獲取list 集合的類型
Class<?> requiredType = ph.getCollectionType(tokens.keys.length);
List<Object> list = (List<Object>) propValue;
//獲取list 集合的size
int index = Integer.parseInt(lastKey);
Object oldValue = null;
if (isExtractOldValueForEditor() && index < list.size()) {
oldValue = list.get(index);
}
//獲取list 解析后的屬性值
Object convertedValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
requiredType, ph.nested(tokens.keys.length));
int size = list.size();
//如果list 的長度大于屬性值的長度，則多余的元素賦值為null
if (index >= size && index < this.autoGrowCollectionLimit) {
for (int i = size; i < index; i++) {
try {
list.add(null);
} catch (NullPointerException ex) {
throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
"Cannot set element with index " + index + " in List of size " +
size + ", accessed using property path '" + tokens.canonicalName +
"': List does not support filling up gaps with null elements");
}
}
list.add(convertedValue);
} else {
try {
//將值添加到list 中
list.set(index, convertedValue);
} catch (IndexOutOfBoundsException ex) {
throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
"Invalid list index in property path '" + tokens.canonicalName + "'", ex);
}
}
}
//注入map 類型的屬性值
else if (propValue instanceof Map) {
//獲取map 集合key 的類型
Class<?> mapKeyType = ph.getMapKeyType(tokens.keys.length);
//獲取map 集合value 的類型
Class<?> mapValueType = ph.getMapValueType(tokens.keys.length);
Map<Object, Object> map = (Map<Object, Object>) propValue;
TypeDescriptor typeDescriptor = TypeDescriptor.valueOf(mapKeyType);
//解析map 類型屬性key 值
Object convertedMapKey = convertIfNecessary(null, null, lastKey, mapKeyType, typeDescriptor);
Object oldValue = null;
if (isExtractOldValueForEditor()) {
oldValue = map.get(convertedMapKey);
}
//解析map 類型屬性value 值
Object convertedMapValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
mapValueType, ph.nested(tokens.keys.length));
//將解析后的key 和value 值賦值給map 集合屬性
map.put(convertedMapKey, convertedMapValue);
} else {
throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
"Property referenced in indexed property path '" + tokens.canonicalName +
"' is neither an array nor a List nor a Map; returned value was [" + propValue + "]");
}
}
private Object getPropertyHoldingValue(PropertyTokenHolder tokens) {
Assert.state(tokens.keys != null, "No token keys");
PropertyTokenHolder getterTokens = new PropertyTokenHolder(tokens.actualName);
getterTokens.canonicalName = tokens.canonicalName;
getterTokens.keys = new String[tokens.keys.length - 1];
System.arraycopy(tokens.keys, 0, getterTokens.keys, 0, tokens.keys.length - 1);
Object propValue;
try {
//獲取屬性值
propValue = getPropertyValue(getterTokens);
} catch (NotReadablePropertyException ex) {
throw new NotWritablePropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
"Cannot access indexed value in property referenced " +
"in indexed property path '" + tokens.canonicalName + "'", ex);
}
if (propValue == null) {
if (isAutoGrowNestedPaths()) {
int lastKeyIndex = tokens.canonicalName.lastIndexOf('[');
getterTokens.canonicalName = tokens.canonicalName.substring(0, lastKeyIndex);
propValue = setDefaultValue(getterTokens);
} else {
throw new NullValueInNestedPathException(getRootClass(), this.nestedPath + tokens.canonicalName,
"Cannot access indexed value in property referenced " +
"in indexed property path '" + tokens.canonicalName + "': returned null");
}
}
return propValue;
}
通過對上面注入依賴代碼的分析，我們已經(jīng)明白了Spring IOC 容器是如何將屬性的值注入到Bean 實例對象中去的：
1)、對于集合類型的屬性，將其屬性值解析為目標(biāo)類型的集合后直接賦值給屬性。
2)、對于非集合類型的屬性，大量使用了JDK 的反射機制，通過屬性的getter()方法獲取指定屬性注入以前的值，同時調(diào)用屬性的setter()方法為屬性設(shè)置注入后的值?？吹竭@里相信很多人都明白了Spring的setter()注入原理。
至此Spring IOC 容器對Bean 定義資源文件的定位，載入、解析和依賴注入已經(jīng)全部分析完畢，現(xiàn)在Spring IOC 容器中管理了一系列靠依賴關(guān)系聯(lián)系起來的Bean，程序不需要應(yīng)用自己手動創(chuàng)建所需的對象，Spring IOC 容器會在我們使用的時候自動為我們創(chuàng)建，并且為我們注入好相關(guān)的依賴，這就是Spring 核心功能的控制反轉(zhuǎn)和依賴注入的相關(guān)功能。
