簡介
spring-bean 組件是 Spring IoC 的核心，我們可以使用它的 beanFactory 來獲取所需的對象，對象的實例化、屬性裝配和初始化等都可以交給 spring 來管理。 本文將從DefaultListableBeanFactory.getBean(Class)方法開始分析獲取 bean 的過程，主要內容如下，由於篇幅較長，可以根據需要選擇閱讀：
- beanFactory 的設計
- 多個 beanName 的處理
- 獲取單例 bean
- 創建單例 bean
- bean 的實例化
- bean 的屬性裝配
- bean 的初始化（省略）
spring-bean 的源碼比較多，有些不影響整體分析思路的代碼會被省略掉（代碼中會註明），另外，想要分析所有的代碼可能不大現實，所以，針對部分內容，我會點到為止，例如，本文只分析單例 bean 而不分析多例 bean。
前篇回顧
上篇博客Spring源碼系列(一)–詳細介紹bean組件介紹了 bean 組件的一些重要理論概念，並通過例子演示如何使用 bean 組件。這裏回顧下，這幾個概念非常重要，是 bean 組件的理論基礎：
- 實例化、屬性裝配和初始化的概念。 實例化指創建出一個新的對象；屬性裝配指給對象的成員屬性賦值； 初始化指調用對象的初始化方法。
- 什麼是 bean：某個類的實例或描述對象，被註冊到了 Spring IoC 容器，這時通過 Spring IoC 容器獲取的這個類的對象就是 bean。
- 什麼是 beanFactory：一個工廠，用於註冊 bean 和獲取 bean。
- 什麼是 beanDefinition：一個描述對象，用來描述 bean 的實例化、屬性裝配、初始化等信息。
beanFactory的設計
從客戶端來看，一個完整的 beanFactory 工廠包含以下基本功能:
- 註冊別名。對應下圖的
AliasRegistry接口。
- 註冊單例對象。對應下圖的
SingletonBeanRegistry接口。
- 註冊
BeanDefinition對象。對應下圖的BeanDefinitionRegistry接口。
- 獲取 bean。對應下圖的
BeanFactory接口。
在 spring-bean 組件中，DefaultListableBeanFactory就是一個完整的 beanFactory 工廠，也可以說是一個 IoC 容器。
BeanFactory還有幾個擴展接口，用的比較多的可能是ConfigurableBeanFactory和AutowireCapableBeanFactory：
HierarchicalBeanFactory用於提供父子工廠的支持。例如，當前 beanFactory 找不到 bean 時，會嘗試從 parent beanFactory 中獲取。ConfigurableBeanFactory用於提供配置 beanFactory 的支持。例如，註冊BeanPostProcessor、註冊 TypeConverter、註冊OrderComparator等。ListableBeanFactory用於提供批量獲取 bean 的支持（不包含父工廠的 bean）。例如，我們可以根據類型獲取 beanName-bean 的 map。AutowireCapableBeanFactory用於提供實例化、屬性裝配、初始化等一系列管理 bean 生命周期的支持。 例如，該接口包含了 createBean、autowireBean、initializeBean、destroyBean 等方法。
當我們註冊 bean 時，根據註冊方式的不同，bean 的註冊信息會被放入兩個不同的地方。
class DefaultSingletonBeanRegistry {
// beanName=singletonObject鍵值對
// 除了registerSingleton的會放在這裏，registerBeanDefinition生成的單例bean實例也會放在這裏
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
}
class DefaultListableBeanFactory {
// beanName=beanDefination鍵值對
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
}
接下來開始分析源碼，註冊 bean 比較簡單，這裏就不看了，我們直接看 getBean(Class) 的代碼。
從getBean(requiredType)方法開始
進入到 DefaultListableBeanFactory.getBean(Class)方法，並逐漸展開。在DefaultListableBeanFactory.resolveBean(ResolvableType, Object[], boolean)方法中，如果當前 beanFactory 中獲取不到這個 bean，將嘗試從 parent beanFactory 中獲取，這也說明了一點：父子 beanFactory 中允許存在相同 beanName 的 bean，只是獲取時當前 beanFactory 的優先級更高一些。
public <T> T getBean(Class<T> requiredType) throws BeansException {
// 適配入參
// 可以看到，我們獲取bean時還可以指定構造參數
return getBean(requiredType, (Object[]) null);
}
public <T> T getBean(Class<T> requiredType, @Nullable Object... args) throws BeansException {
Assert.notNull(requiredType, "Required type must not be null");
// 繼續適配入參
// 這裏的第三個參數表示，如果指定類型對應的beanName不唯一時，true為返回null, false為拋出異常
Object resolved = resolveBean(ResolvableType.forRawClass(requiredType), args, false);
// 如果獲取不到這個bean，拋出異常
if (resolved == null) {
throw new NoSuchBeanDefinitionException(requiredType);
}
return (T) resolved;
}
private <T> T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
// 這裏的NamedBeanHolder就是簡單的對bean實例封裝了一層，不用太關注
NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull);
// 如果獲取得到bean實例，則返回
if (namedBean != null) {
return namedBean.getBeanInstance();
}
// 如果沒有，嘗試從parent beanFactory中獲取
// 這部分代碼省略······
return null;
}
存在多個beanName怎麼辦
通過 beanType 來獲取 bean，可能會存在一個類型關聯了多個 beanName 的情況，使用例子中我們說過，可以通過指定 beanDefination 的 isPrimary = true 或者註冊比較器的方式來解決。接下來我們看下具體的處理過程。
進入到DefaultListableBeanFactory.resolveNamedBean(ResolvableType, Object[], boolean)方法。如果指定類型匹配到了多個 beanName，會進行以下處理：
- 如果存在通過
registerSingleton註冊的 beanName，或者通過registerBeanDefinition註冊且 autowireCandidate = true 的 beanName，則僅保留它們，並剔除其他的 beanName；
- 如果還是存在多個 beanName，檢查是否存在唯一一個通過
registerBeanDefinition且isPrimary = true的（存在多個會報錯），存在的話將它作為匹配到的唯一 beanName；
- 如果還是存在多個 beanName，通過我們註冊的
OrderComparator來確定優先值最小的作為唯一 beanName，注意，通過registerSingleton註冊的和通過registerBeanDefinition註冊的，比較的對象是不一樣的；
- 如果還是存在多個 beanName，根據 nonUniqueAsNull，為 true 是返回 null，為 false 拋出
NoUniqueBeanDefinitionException異常。
private <T> NamedBeanHolder<T> resolveNamedBean(
ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) throws BeansException {
Assert.notNull(requiredType, "Required type must not be null");
// 獲取指定類型的所有beanName，可能匹配到多個
String[] candidateNames = getBeanNamesForType(requiredType);
// 如果指定類型匹配到了多個beanName，進行以下操作：
// 如果存在通過registerSingleton註冊的beanName，或者通過registerBeanDefinition註冊且 autowireCandidate = true的beanName，則僅保留它們，並剔除其他的beanName；
if (candidateNames.length > 1) {
List<String> autowireCandidates = new ArrayList<>(candidateNames.length);
for (String beanName : candidateNames) {
if (!containsBeanDefinition(beanName) || getBeanDefinition(beanName).isAutowireCandidate()) {
autowireCandidates.add(beanName);
}
}
if (!autowireCandidates.isEmpty()) {
candidateNames = StringUtils.toStringArray(autowireCandidates);
}
}
// 如果只剩下一個beanName，那就根據beanName和beanType獲取bean
if (candidateNames.length == 1) {
String beanName = candidateNames[0];
return new NamedBeanHolder<>(beanName, (T) getBean(beanName, requiredType.toClass(), args));
}
// 如果存在多個，則還要進一步處理
else if (candidateNames.length > 1) {
Map<String, Object> candidates = new LinkedHashMap<>(candidateNames.length);
// 遍歷候選的beanName
for (String beanName : candidateNames) {
// 如果該beanName是通過registerSingleton註冊的，且傳入構造參數為空
// 則獲取該bean實例，並放入candidates
if (containsSingleton(beanName) && args == null) {
Object beanInstance = getBean(beanName);
candidates.put(beanName, (beanInstance instanceof NullBean ? null : beanInstance));
}
else {
// 其他情況下，則獲取該beanName對應的類型，並放入candidates
// 注意，這裏的類型不一定是我們入參指定的類型，例如，如果我指定的是UserServiceFactoryBean.class，這裏返回的卻是UserService.class
candidates.put(beanName, getType(beanName));
}
}
// 如果裏面存在唯一一個通過registerBeanDefinition註冊的且isPrimary=true（存在多個會報錯），則將它作為匹配到的唯一beanName
String candidateName = determinePrimaryCandidate(candidates, requiredType.toClass());
// 如果還是確定不了，則通過我們註冊的OrderComparator來判斷candidates中value的優先數，挑選優先數最小的value對應的key作為唯一的beanName
if (candidateName == null) {
candidateName = determineHighestPriorityCandidate(candidates, requiredType.toClass());
}
if (candidateName != null) {
Object beanInstance = candidates.get(candidateName);
// 如果candidates中的value本身就是一個bean實例，那麼直接返回就好了
// 如果不是，則根據beanName和beanType獲取bean
if (beanInstance == null || beanInstance instanceof Class) {
beanInstance = getBean(candidateName, requiredType.toClass(), args);
}
return new NamedBeanHolder<>(candidateName, (T) beanInstance);
}
// 如果還是確定不了唯一beanName，且設置了nonUniqueAsNull=false（默認為false），則會拋錯
if (!nonUniqueAsNull) {
throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
}
}
return null;
}
根據beanName和beanType獲取bean
進入AbstractBeanFactory.getBean(String, Class<T>, Object...)。這個方法里包括四個步驟：
- 轉義name。主要指的是當 name 是別名或者是 “&” + factory beanName 形式時進行轉義；
- 如果是單例 bean 且構造參數為空，則會從 singletonObjects 中獲取已生成的 bean，或者從 earlySingletonObjects/singletonFactories 中獲取已經實例化但可能還沒裝配或初始化的 bean。如果獲取到的不是 null，直接返回對應的 bean 實例；
- 如果當前 beanFactory 沒有指定的 beanName，則會去 parent beanFactory 中獲取；
- 如果當前 bean 需要依賴其他 bean，則會先獲取依賴的 bean；
- 根據 scope 選擇生成單例 bean 還是多例 bean；
- 進行類型檢查，如果獲取的 bean 不匹配，會先用我們註冊的類型轉換器轉換，如果還是不匹配就拋出
BeanNotOfRequiredTypeException。
public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
throws BeansException {
// 適配入參
// 這裏最後一個參數指獲取的bean是否純粹用於類型檢查，如果是的話，beanFactory不會標記這個bean正在生成中，僅對單例bean有用
return doGetBean(name, requiredType, args, false);
}
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 轉義我們傳入的name，這裏包括兩個內容：
// 1. 如果是別名，需要轉換為別名對象的beanName;
// 2. 如果是“&”+factoryBeanName,則需要去掉前面的“&”
final String beanName = transformedBeanName(name);
Object bean;
// 獲取單例
// 注意，這裏獲取到的有可能是已經初始化，也有可能是還沒初始化，甚至還沒裝配的bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// 省略日誌部分······
// 獲取bean，因為sharedInstance有可能是factoryBean，如果我們要的是factoryBean對應的bean，則還要getObject
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 如果當前線程已經在生成beanName對應的bean，就會拋錯
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 如果當前beanFactory沒有指定的beanName，則會去parent beanFactory中獲取
// 這部分省略······
// 這裏標記指定bean正在創建中，一般對單例bean才有意義
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 獲取指定beanName對應的RootBeanDefinition對象
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 檢查RootBeanDefinition，目前就是檢查是否對應的類型為抽象類，是的話拋錯
checkMergedBeanDefinition(mbd, beanName, args);
// 如果當前bean需要依賴其他bean，則會先獲取依賴的bean
// 這部分省略······
// 創建單例bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
// 進入創建bean或factoryBean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
// 獲取bean實例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 創建多例bean
else if (mbd.isPrototype()) {
Object prototypeInstance = null;
try {
// 標記當前線程正在創建這個bean
beforePrototypeCreation(beanName);
// 進入創建bean或factoryBean
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 去掉當前線程中這個bean正在創建的標記
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 接下來這種一般是自定義Scope的情況，這裏省略不討論
else {
// ·······
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 如果獲取到的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) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
由於單例 bean 和多例 bean 的創建差不多，本文只選擇單例的來分析。
獲取單例bean
進入DefaultSingletonBeanRegistry.getSingleton(String, ObjectFactory)。這個方法包括幾個過程，主要就是處理一些多線程問題：
- 獲取指定 beanName 的 bean，如果已經存在，就不去創建，這時為了處理多線程同時創建 bean 的問題；
- 如果當前 bean 已經在創建中，會拋出 BeanCurrentlyInCreationException，創建單例 bean 之前是有加鎖的，按理不會出現這種情況；
- 創建單例 bean；
- 如果創建成功，將 bean 實例加入 singletonObjects，並且刪除掉 singletonFactories 和 earlySingletonObjects 中對應的鍵值對。
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
// 這裏我不是很理解，為什麼使用singletonObjects作為鎖
// 因為從earlySingletonObjects/singletonFactories中獲取已經實例化但可能還沒裝配或初始化的 bean時，用的鎖也是singletonObjects，這樣的話，提前暴露的機制好像就廢掉了啊？？？TODO
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 如果當前beanFactory的單例正在銷毀，則不允許創建單例
if (this.singletonsCurrentlyInDestruction) {
// 省略拋錯······
}
// 判斷當前bean是不是已經在創建中，是的話拋出BeanCurrentlyInCreationException
// 由於加了鎖，這種情況應該是不會發生的
beforeSingletonCreation(beanName);
boolean newSingleton = false;
// 省略部分代碼······
try {
// 這裏的執行的是createBean方法
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
// 這種情況我不是很理解，singletonObjects的操作不應該被鎖住了嗎？TODO
catch (IllegalStateException ex) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
// 如果拋出的是BeanCreationException，
catch (BeanCreationException ex) {
// 省略部分代碼······
throw ex;
}
finally {
// 省略部分代碼······
// 如果當前bean不處於創建狀態中，會拋出IllegalStateException
afterSingletonCreation(beanName);
}
// 如果創建成功，將bean實例加入singletonObjects，並且刪除掉singletonFactories和earlySingletonObjects中對應的鍵值對
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
以上方法中，如果獲取不到已生成的單例 bean，則會開始創建 bean。
創建單例bean
進入AbstractAutowireCapableBeanFactory.createBean(String, RootBeanDefinition, Object[])。這個方法包括以下過程：
- 解析 beanType，並且再次包裝
RootBeanDefinition；
- 執行我們註冊的
InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法，如果返回了非空對象，則將其返回。也就是說我們可以在該方法中自定義完成 bean 的實例化、裝配和初始化。
- 創建 bean。
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
// 解析當前RootBeanDefinition對應生成的bean類型，並進行再次包裝
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 省略部分代碼······
try {
// 執行我們註冊的InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法。也就是說我們可以在該方法中自定義完成 bean 的實例化、裝配和初始化。
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 如果該方法返回bean，那就直接返回
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 創建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
進入AbstractAutowireCapableBeanFactory.doCreateBean(String, RootBeanDefinition, Object[])。這個方法主要包含以下過程：
- 實例化 bean；
- 執行我們註冊的
MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法；
- 如果是單例，將還沒裝配和初始化的 bean 先暴露出去，即放在singletonFactories中，如果其他線程進來獲取，可以將這個 bean 或 factoryBean 返回，而不需要等待；
- 屬性裝配；
- 初始化；
- 將生成的 bean 放入 disposableBeans 中。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
// 實例化
// 如果是單例，嘗試從factoryBeanInstanceCache中獲取
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 實例化bean
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 執行我們註冊的MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法
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先暴露出去，即放在singletonFactories中
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
Object exposedObject = bean;
try {
// 屬性裝配
populateBean(beanName, mbd, instanceWrapper);
// 初始化
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);
}
}
// 省略部分代碼······
// 將生成的bean或factoryBean放入disposableBeans中
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
接下來將展開 bean 的實例化、屬性裝配和初始化。其中，實例化和屬性裝配的代碼比較複雜，我們重點分析，至於初始化部分，則留給讀者自行閱讀。
實例化
進入AbstractAutowireCapableBeanFactory.createBeanInstance(String, RootBeanDefinition, Object[])。這個方法主要過程如下：
- 解析 beanType，並對 beanType 進行一些必要的檢查；
- 通過我們設置的 InstanceSupplier 或 FactoryMethod 來直接獲取 bean，如果有的話，直接返回該對象；
- 如果構造參數為空，則可以復用已經解析好的構造對象（如果有的話）；
- 執行我們註冊的
SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors獲取構造對象數組；
- 如果得到的數組不是空，或者 beanDefination 的裝配模式為構造注入，或者 beanDefination 包含構造參數，或者我們傳入的構造參數非空，則進入實例化 bean
- 其他情況，使用無參構造來實例化。
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 解析bean類型
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 如果bean類型不是public的，則拋錯
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());
}
// 通過RootBeanDefinition中定義的Supplier來獲取實例化bean
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 通過RootBeanDefinition中定義FactoryMethod來實例化bean
if (mbd.getFactoryMethodName() != null) {
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) {
return autowireConstructor(beanName, mbd, null, null);
}
else {
return instantiateBean(beanName, mbd);
}
}
// 執行我們註冊的SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors獲取Constructor對象數組（如果有的話）
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
// 如果得到的數組不是空，或者beanDefination的裝配模式為構造注入，或者beanDefination包含構造參數，或者我們傳入的構造參數非空，則進入實例化bean或factoryBean
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// 省略部分代碼······
// 使用無參構造實例化bean或factoryBean
return instantiateBean(beanName, mbd);
}
實例化的方法包括有參構造實例化和無參構造實例化兩種，本文只討論有參構造實例化的情況。
ConstructorArgumentValues和ArgumentsHolder
在繼續分析之前，有必要了解下ConstructorArgumentValues和ArgumentsHolder這兩個類。
首先，ConstructorArgumentValues用於定義構造方法的參數列表的值。spring 中，ConstructorArgumentValues一般被定義在 BeanDefinition對象中，它影響着 bean 的實例化，是 bean 實例化時選擇構造對象的依據。
public class ConstructorArgumentValues {
// 索引+參數值
// 例如，對應new User(int age, String name, String address)的構造方法，可以包含元素：0=new ValueHolder(18),2=new ValueHolder("北京")
private final Map<Integer, ValueHolder> indexedArgumentValues = new LinkedHashMap<>();
// 通用參數值
// 例如，對應new User(int age, String name, String address)的構造方法，如果indexedArgumentValues中不包含name的值，則可以在genericArgumentValues中查找，我們只需要添加元素：new ValueHolder("zzs001", String.class)
private final List<ValueHolder> genericArgumentValues = new ArrayList<>();
// 內部類，代表一個參數的值
public static class ValueHolder implements BeanMetadataElement {
@Nullable
private Object value;
@Nullable
private String type;
@Nullable
private String name;
@Nullable
private Object source;
private boolean converted = false;
}
ArgumentsHolder是ConstructorResolver的內部類，和ConstructorArgumentValues一樣，它也是用來定義構造方法的參數列表的值，區別在於，ConstructorArgumentValues的值是“未解析的”，而ArgumentsHolder包含了“未解析”（preparedArguments）、“解析未完成”（rawArguments）和”解析完成”（arguments）三種值。
為什麼會這樣呢？因為ConstructorArgumentValues中的參數值的類型不一定和構造方法中的匹配，包括兩種情況：
- 類型不同，但可以通過
TypeConverter轉換的類型。例如，在new User(int age, String name, Address address)的構造方法中，我可以在ConstructorArgumentValues添加2=new AddressVO()，這個時候只要 spring 能找到合適的轉換器就能轉換，這個轉換過程為：“解析未完成”（rawArguments） –》 “解析完成”（arguments）。
- 類型不同，參數的值指向其他 bean ，當然也可以是其他 spring 可識別的引用。例如，
new User(int age, String name, Address address)的構造方法中，我可以在ConstructorArgumentValues添加2=new RootBeanDefinition(Address.class)，這個轉換過程為：“未解析”（preparedArguments） –》“解析未完成”（rawArguments）。
private static class ArgumentsHolder {
public final Object[] rawArguments;
public final Object[] arguments;
public final Object[] preparedArguments;
public boolean resolveNecessary = false;
}
理解完這兩個類之後，我們繼續分析實例化的源碼。
有參構造實例化
進入到AbstractAutowireCapableBeanFactory.autowireConstructor(String, RootBeanDefinition, Constructor<?>[], Object[])方法。這裏創建了一個ConstructorResolver對象並直接調用它的 autowireConstructor 方法。
protected BeanWrapper autowireConstructor(
String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
進入ConstructorResolver.autowireConstructor(String, RootBeanDefinition, Constructor<?>[], Object[])。這個方法代碼比較多，為了更好地理解，可以分成兩種場景來看：
- 入參里顯式指定構造參數。這種場景的參數值默認都是解析過的，所以不需要解析，該場景要求對應的構造對象的參數數量必須和指定的一樣。
BeanDefinition對象中指定ConstructorArgumentValues。這種場景的參數值需要經過兩步轉換，該場景要求對應的構造對象的參數數量不小於指定的數量。
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);
// 定義最終用於實例化對象的構造器
Constructor<?> constructorToUse = null;
// 定義存放（“未解析”、“解析未完成”、“解析完成”）構造參數的對象
ArgumentsHolder argsHolderToUse = null;
// 定義最終用於實例化對象的構造參數
Object[] argsToUse = null;
// 入參顯式聲明了構造參數（場景一），則不需要解析參數列表值，但需解析構造對象
if (explicitArgs != null) {
argsToUse = explicitArgs;
}
else {
Object[] argsToResolve = null;
// BeanDefinition對象中指定ConstructorArgumentValues（場景二），如果參數列表值或構造對象已經解析，則不需要再解析
synchronized (mbd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
// Found a cached constructor...
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
if (argsToResolve != null) {
argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
}
}
// 進入解析參數列表值和構造對象
if (constructorToUse == null || argsToUse == null) {
// 如果入參里沒有顯式指定構造對象的數組，使用反射方式獲取
Constructor<?>[] candidates = chosenCtors;
if (candidates == null) {
Class<?> beanClass = mbd.getBeanClass();
try {
// BeanDefinition中可以定義是否包括非public的方法
candidates = (mbd.isNonPublicAccessAllowed() ?
beanClass.getDeclaredConstructors() : beanClass.getConstructors());
}
catch (Throwable ex) {
// 省略代碼······
}
}
// 如果數組中只有一個無參構造，且入參和BeanDefinition中都未指定參數列表值，則標記該BeanDefinition對象的構造參數已解析，並實例化bean
if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
// 省略代碼······
}
// 判斷是否需要解析構造
boolean autowiring = (chosenCtors != null ||
mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
// 這裏存放“解析未完成”的參數列表值
ConstructorArgumentValues resolvedValues = null;
// 獲取要求構造參數的最小數量
int minNrOfArgs;
// 入參顯式聲明了構造參數（場景一），minNrOfArgs即為指定數組的長度
if (explicitArgs != null) {
minNrOfArgs = explicitArgs.length;
}
else {
// BeanDefinition對象中指定ConstructorArgumentValues（場景二），則需要計算minNrOfArgs，並進行“未解析” --> “解析未完成”的轉換
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
resolvedValues = new ConstructorArgumentValues();
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
}
// 根據參數數量從小到大排列
AutowireUtils.sortConstructors(candidates);
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Constructor<?>> ambiguousConstructors = null;
LinkedList<UnsatisfiedDependencyException> causes = null;
// 遍歷候選的構造對象
for (Constructor<?> candidate : candidates) {
// 獲取當前構造對象的參數數量
int parameterCount = candidate.getParameterCount();
// 如果上一個循環已經找到匹配的構造對象，則跳出循環1
if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
break;
}
// 如果當前構造對象的參數數量小於minNrOfArgs，則遍歷下一個
// 注意，入參里顯式指定構造參數（場景一）要求對應的構造對象的參數數量必須和指定的一樣。BeanDefinition對象中指定ConstructorArgumentValues（場景二）要求對應的構造對象的參數數量不小於指定的數量
if (parameterCount < minNrOfArgs) {
continue;
}
ArgumentsHolder argsHolder;
// 獲取當前構造對象的參數類型數組
Class<?>[] paramTypes = candidate.getParameterTypes();
// BeanDefinition對象中指定ConstructorArgumentValues（場景二）的情況
if (resolvedValues != null) {
// 進行“解析未完成”->“解析完成”的轉換
try {
// 這裡是為了處理JDK6的ConstructorProperties註解，其他情況都會返回null。
String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
if (paramNames == null) {
ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
if (pnd != null) {
// 獲取當前構造對象的參數名數組
paramNames = pnd.getParameterNames(candidate);
}
}
// 創建ArgumentsHolder對象
argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
}
catch (UnsatisfiedDependencyException ex) {
// 省略代碼······
continue;
}
}
// 入參里顯式指定構造參數（場景一）的情況
else {
// 如果當前構造參數的數量小於指定參數的數量，則繼續循環
if (parameterCount != explicitArgs.length) {
continue;
}
// 創建ArgumentsHolder對象，因為不需要解析參數，所以，這種情況raw、prepared、resolved都是一樣的
argsHolder = new ArgumentsHolder(explicitArgs);
}
// 計算指定參數和當前構造的參數類型的差異值
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// 差異值小於閾值
if (typeDiffWeight < minTypeDiffWeight) {
// 得到匹配的構造對象和構造參數
constructorToUse = candidate;
argsHolderToUse = argsHolder;
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
ambiguousConstructors = null;
}
// 差異值大於閾值，這種不考慮
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
// 省略代碼······
}
}
// 如果找不到合適的構造對象，則會拋錯
if (constructorToUse == null) {
// 省略代碼······
}
else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
// 省略代碼······
}
// BeanDefinition對象中指定ConstructorArgumentValues（場景二），為了復用解析好的構造和參數列表，需要標記當前BeanDefinition的構造參數已解析
if (explicitArgs == null && argsHolderToUse != null) {
argsHolderToUse.storeCache(mbd, constructorToUse);
}
}
Assert.state(argsToUse != null, "Unresolved constructor arguments");
// 接下來就是使用構造對象和參數來實例化對象，就不往下看了。
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
return bw;
}
實例化部分比較難，主要還得先理解一些抽象概念，例如：兩個場景、參數的轉換等。
屬性裝配
進入AbstractAutowireCapableBeanFactory.populateBean(String, RootBeanDefinition, BeanWrapper)。這個方法包括以下過程：
- 執行我們註冊的
InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法，如果返回了 false，則不進行屬性裝配，直接返回；
- 獲取 beanDefinition 中的
PropertyValues對象，根據 beanDefinition 設置的注入類型，填充PropertyValues對象；
- 執行我們註冊的
InstantiationAwareBeanPostProcessor的postProcessProperties方法，可以對PropertyValues對象進行修改;
- 依賴檢查（如果設置了）；
- 進行屬性裝配。
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;
}
}
// 執行我們註冊的InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法，如果返回了false，則不進行屬性裝配，直接返回
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
// 獲取BeanDefinition對象中的PropertyValues，包含了name=value的PropertyValue對象的列表
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 根據我們設置的注入方式，填充
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 按名字裝配
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// 按類型裝配
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// beanFactory中是否註冊了InstantiationAwareBeanPostProcessors
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// BeanDefinition對象中是否設置了依賴檢查
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
// 如果為空，再次從BeanDefinition對象中獲取，TODO？
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 執行我們註冊的InstantiationAwareBeanPostProcessor的postProcessProperties方法，可以對PropertyValues對象進行修改
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
// 省略部分代碼······
pvs = pvsToUse;
}
}
}
// 如果BeanDefinition對象中設置了依賴檢查，則需要檢查依賴設置
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
// 執行屬性裝配
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
這個方法中主要涉及autowireByName、autowireByType和applyPropertyValues三個方法，前兩個暫時不展開，只講最後一個方法。
幾個重要的知識點
在分析applyPropertyValues方法之前，我們需要知道一下幾個知識點。這裏以User這個類來展開例子。
public class User {
private String name;
private int age;
private Address address;
private List<String> hobbies;
}
class Address {
private String region;
private String desc;
}
propertyName的幾種形式
當我們給 beanDefinition設置屬性值時，一般都會這樣採用這樣的賦值，這裏成為“普通形式”。
rootBeanDefinition.getPropertyValues().add("name", "zzs001");
rootBeanDefinition.getPropertyValues().add("age", 18);
rootBeanDefinition.getPropertyValues().add("address", new Address("", ""));
rootBeanDefinition.getPropertyValues().add("hobbies", new ArrayList());
針對類型為 object、list、array、map 等成員屬性，spring 還支持其他的賦值方式，如下，分別成為“嵌套對象形式”和“索引形式”：
// 嵌套對象形式
rootBeanDefinition.getPropertyValues().add("address.region", "");
rootBeanDefinition.getPropertyValues().add("address.desc", "");
// 索引形式
rootBeanDefinition.getPropertyValues().add("hobbies[0]", "");
正是由於 propertyName 引入了多種的形式，所以，原本簡單的賦值行為被搞得非常複雜。例如，嵌套對象形式還可以是這樣：foo.user.address.region，幾乎可以一直嵌套下去。
PropertyAccessor
propertyAccessor 對象一般綁定了一個實例對象，通過PropertyAccessor接口的方法可以對對象的屬性進行存取操作。屬性裝配中最終對成員屬性賦值就是調用它的setPropertyValue方法。AbstractNestablePropertyAccessor中維護了一個 map，key 為當前綁定對象的屬性名（不包含嵌套和索引），value 就是對於的PropertyAccessor對象。
public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyAccessor {
private Map<String, AbstractNestablePropertyAccessor> nestedPropertyAccessors;
}
在上面的例子中，
rootBeanDefinition.getPropertyValues().add("name", "zzs001");
rootBeanDefinition.getPropertyValues().add("age", 18);
這種形式共用一個綁定了User類型實例的PropertyAccessor對象。
// 嵌套對象形式
rootBeanDefinition.getPropertyValues().add("address.region", "");
rootBeanDefinition.getPropertyValues().add("address.desc", "");
這種形式共用一個綁定了Address類型實例的PropertyAccessor對象，該對象和”address”這個名字關聯起來維護在 nestedPropertyAccessors 中。
// 索引形式
rootBeanDefinition.getPropertyValues().add("hobbies[0]", "");
這種形式也是一個綁定了User類型實例的PropertyAccessor對象，該對象和”hobbies”這個名字關聯起來維護在 nestedPropertyAccessors 中。
PropertyTokenHolder
PropertyTokenHolder是AbstractNestablePropertyAccessor的內部類，它更多的是針對“索引形式”的 propertyName。例如，”hobbies[0]”對於的PropertyTokenHolder中，actualName = hobbies，canonicalName = [0]，keys = {0}。
protected static class PropertyTokenHolder {
public PropertyTokenHolder(String name) {
this.actualName = name;
this.canonicalName = name;
}
public String actualName;
public String canonicalName;
@Nullable
public String[] keys;
}
接下來繼續分析屬性裝配的代碼。
applyPropertyValues
進入AbstractAutowireCapableBeanFactory.applyPropertyValues(String, BeanDefinition, BeanWrapper, PropertyValues)方法。和構造參數一樣，設置成員屬性的參數也需要經過“兩次轉換”，這裏就不詳細講解。這個方法主要包括以下過程：
- 獲取屬性對象列表，如果這個列表的屬性對象都已經完成“兩次轉換”，則直接裝配屬性；
- 遍歷屬性對象列表，分別進行兩次轉換，如果列表中沒有類似
BeanDefinition、BeanDefinitionHolder等的對象，則設置PropertyValues對象已經轉換完成，下次調用這個方法不用再進行轉換；
- 屬性裝配。
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
// 如果沒有需要注入的屬性，直接返回
if (pvs.isEmpty()) {
return;
}
// 省略部分代碼······
MutablePropertyValues mpvs = null;
// 獲取屬性對象列表
List<PropertyValue> original;
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
// 如果所有屬性對象已經完成“兩次轉換”，則直接裝配屬性
if (mpvs.isConverted()) {
try {
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());
}
// 獲取我們註冊的類型轉換器
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
// 創建第一次轉換所用的解析器
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// 定義一個列表，用於存放完成“兩次轉換”的屬性對象
// 這注意，這裏並沒有進行所謂的複製，不要被命名迷惑了
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
// 遍歷屬性對象
for (PropertyValue pv : original) {
// 當前屬性對象已經完成“兩次轉換”，直接添加到列表
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
String propertyName = pv.getName();
Object originalValue = pv.getValue();
// 省略部分代碼······
// 第一次轉換
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
// 如果當前屬性為可寫屬性，且屬性名不是類似於foo.bar或addresses[0]的形式，則需要進行第二次轉換
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// 如果轉換后的屬性對象和初始對象一樣，一般指的是普通對象，而不是BeanDefinition、BeanDefinitionHolder等
if (resolvedValue == originalValue) {
// 如果需要第二次轉換，則設置復用的目標對象
if (convertible) {
pv.setConvertedValue(convertedValue);
}
// 將原屬性對象添加到列表
deepCopy.add(pv);
}
// 這種情況不考慮
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));
}
}
}
// 如果不包含BeanDefinition、BeanDefinitionHolder等對象，則設置PropertyValues為已轉換，這樣下次調用這個方法，就不需要進行任何的轉換了
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
// 屬性裝配
try {
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
進入AbstractPropertyAccessor.setPropertyValues(PropertyValues)方法。這裏遍歷屬性對象列表，逐個進賦值操作。
public void setPropertyValues(PropertyValues pvs) throws BeansException {
// 入參適配
// 後面兩個參數分別代表：是否忽略NotWritablePropertyException異常、是否忽略NullValueInNestedPathException異常
setPropertyValues(pvs, false, false);
}
public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
throws BeansException {
// 獲取屬性對象列表
List<PropertyValue> propertyValues = (pvs instanceof MutablePropertyValues ?
((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));
for (PropertyValue pv : propertyValues) {
// 省略try-catch的代碼和其他異常相關的代碼······
setPropertyValue(pv);
}
}
setPropertyValue
進入AbstractNestablePropertyAccessor.setPropertyValue(PropertyValue)。這個方法包括以下過程：
- 獲取 propertyName 對應的
PropertyAccessor對象，這裏將解析“嵌套對象形式”的 propertyName；
- 創建
PropertyTokenHolder對象，這裏將解析“索引形式”的 propertyName；
- 使用
PropertyAccessor對象進行賦值操作。
public void setPropertyValue(PropertyValue pv) throws BeansException {
// 適配入參
setPropertyValue(pv.getName(), pv.getValue());
}
public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
AbstractNestablePropertyAccessor nestedPa;
try {
// 獲取propertyName對應的PropertyAccessor對象，這裏將解析“嵌套對象形式”的propertyName
// 如果緩存里有的話，將復用
nestedPa = getPropertyAccessorForPropertyPath(propertyName);
}
catch (NotReadablePropertyException ex) {
throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
"Nested property in path '" + propertyName + "' does not exist", ex);
}
// 創建PropertyTokenHolder對象，這裏將解析“索引形式”的propertyName
PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
// 使用PropertyAccessor對象進行賦值操作
nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
}
進入AbstractNestablePropertyAccessor.setPropertyValue(PropertyTokenHolder, PropertyValue)方法。這裏根據 propertyName 是否為“索引形式”調用不同的方法。
protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
if (tokens.keys != null) {
processKeyedProperty(tokens, pv);
}
else {
processLocalProperty(tokens, pv);
}
}
這裏我們不看 propertyName 為“索引形式”的方法，只看processLocalProperty。
private void processLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) {
// 獲取actualName對應的PropertyHandler對象，如果有緩存則復用
PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
if (ph == null || !ph.isWritable()) {
// 省略部分代碼······
}
Object oldValue = null;
try {
Object originalValue = pv.getValue();
Object valueToApply = originalValue;
if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
// 因為我們的屬性參數都是轉換過的，所以這裏不再看轉換的代碼
if (pv.isConverted()) {
valueToApply = pv.getConvertedValue();
}
else {
// 省略部分代碼······
}
pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
}
// 接下來就是通過反射方式給屬性賦值，後續再展開
ph.setValue(valueToApply);
}
catch (Exception ex) {
// 省略部分代碼······
}
}
屬性裝配的代碼分析就點到為止吧。
最後補充
以上基本看完 spring-bean 的源碼。針對 getBean 的過程，本文未展開的內容包括：
- 獲取和創建多例 bean；
- 無參構造實例化；
- 屬性裝配中，屬性值列表的填充（autowireByName和autowireByType）、屬性名為索引形式的屬性裝配
- bean 的初始化。
感興趣的讀者可以自行分析。另外，以上內容如有錯誤，歡迎指正。
最後，感謝閱讀。
相關源碼請移步： spring-beans
本文為原創文章，轉載請附上原文出處鏈接：https://www.cnblogs.com/ZhangZiSheng001/p/13196228.html
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※為什麼 USB CONNECTOR 是電子產業重要的元件?
※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!
※台北網頁設計公司全省服務真心推薦
※想知道最厲害的網頁設計公司"嚨底家"!
※新北清潔公司,居家、辦公、裝潢細清專業服務
※推薦評價好的iphone維修中心
