Spring源碼系列(二)–bean組件的源碼分析

• 2020 年 6 月 26 日
• 筆記
• spring

簡介

spring-bean 組件是 Spring IoC 的核心，我們可以使用它的 beanFactory 來獲取所需的對象，對象的實例化、屬性裝配和初始化等都可以交給 spring 來管理。 本文將從DefaultListableBeanFactory.getBean(Class)方法開始分析獲取 bean 的過程，主要內容如下，由於篇幅較長，可以根據需要選擇閱讀：

1. beanFactory 的設計
2. 多個 beanName 的處理
3. 獲取單例 bean
4. 創建單例 bean
5. bean 的實例化
6. bean 的屬性裝配
7. bean 的初始化（省略）

spring-bean 的源碼比較多，有些不影響整體分析思路的程式碼會被省略掉（程式碼中會註明），另外，想要分析所有的程式碼可能不大現實，所以，針對部分內容，我會點到為止，例如，本文只分析單例 bean 而不分析多例 bean。

前篇回顧

上篇部落格Spring源碼系列(一)–詳細介紹bean組件介紹了 bean 組件的一些重要理論概念，並通過例子演示如何使用 bean 組件。這裡回顧下，這幾個概念非常重要，是 bean 組件的理論基礎：

1. 實例化、屬性裝配和初始化的概念。 實例化指創建出一個新的對象；屬性裝配指給對象的成員屬性賦值； 初始化指調用對象的初始化方法。
2. 什麼是 bean：某個類的實例或描述對象，被註冊到了 Spring IoC 容器，這時通過 Spring IoC 容器獲取的這個類的對象就是 bean。
3. 什麼是 beanFactory：一個工廠，用於註冊 bean 和獲取 bean。
4. 什麼是 beanDefinition：一個描述對象，用來描述 bean 的實例化、屬性裝配、初始化等資訊。

beanFactory的設計

從客戶端來看，一個完整的 beanFactory 工廠包含以下基本功能:

1. 註冊別名。對應下圖的AliasRegistry介面。
2. 註冊單例對象。對應下圖的SingletonBeanRegistry介面。
3. 註冊BeanDefinition對象。對應下圖的BeanDefinitionRegistry介面。
4. 獲取 bean。對應下圖的BeanFactory介面。

在 spring-bean 組件中，DefaultListableBeanFactory就是一個完整的 beanFactory 工廠，也可以說是一個 IoC 容器。

BeanFactory還有幾個擴展介面，用的比較多的可能是ConfigurableBeanFactory和AutowireCapableBeanFactory：

1. HierarchicalBeanFactory用於提供父子工廠的支援。例如，當前 beanFactory 找不到 bean 時，會嘗試從 parent beanFactory 中獲取。
2. ConfigurableBeanFactory用於提供配置 beanFactory 的支援。例如，註冊BeanPostProcessor、註冊 TypeConverter、註冊OrderComparator等。
3. ListableBeanFactory用於提供批量獲取 bean 的支援（不包含父工廠的 bean）。例如，我們可以根據類型獲取 beanName-bean 的 map。
4. 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，會進行以下處理：

1. 如果存在通過registerSingleton註冊的 beanName，或者通過registerBeanDefinition註冊且 autowireCandidate = true 的 beanName，則僅保留它們，並剔除其他的 beanName；
2. 如果還是存在多個 beanName，檢查是否存在唯一一個通過registerBeanDefinition且isPrimary = true的（存在多個會報錯），存在的話將它作為匹配到的唯一 beanName；
3. 如果還是存在多個 beanName，通過我們註冊的OrderComparator來確定優先值最小的作為唯一 beanName，注意，通過registerSingleton註冊的和通過registerBeanDefinition註冊的，比較的對象是不一樣的；
4. 如果還是存在多個 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...)。這個方法里包括四個步驟：

1. 轉義name。主要指的是當 name 是別名或者是 「&」 + factory beanName 形式時進行轉義；
2. 如果是單例 bean 且構造參數為空，則會從 singletonObjects 中獲取已生成的 bean，或者從 earlySingletonObjects/singletonFactories 中獲取已經實例化但可能還沒裝配或初始化的 bean。如果獲取到的不是 null，直接返回對應的 bean 實例；
3. 如果當前 beanFactory 沒有指定的 beanName，則會去 parent beanFactory 中獲取；
4. 如果當前 bean 需要依賴其他 bean，則會先獲取依賴的 bean；
5. 根據 scope 選擇生成單例 bean 還是多例 bean；
6. 進行類型檢查，如果獲取的 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)。這個方法包括幾個過程，主要就是處理一些多執行緒問題：

2. 獲取指定 beanName 的 bean，如果已經存在，就不去創建，這時為了處理多執行緒同時創建 bean 的問題；
3. 如果當前 bean 已經在創建中，會拋出 BeanCurrentlyInCreationException，創建單例 bean 之前是有加鎖的，按理不會出現這種情況；
4. 創建單例 bean；
5. 如果創建成功，將 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[])。這個方法包括以下過程：

1. 解析 beanType，並且再次包裝RootBeanDefinition；
2. 執行我們註冊的InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法，如果返回了非空對象，則將其返回。也就是說我們可以在該方法中自定義完成 bean 的實例化、裝配和初始化。
3. 創建 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[])。這個方法主要包含以下過程：

1. 實例化 bean；
2. 執行我們註冊的MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法；
3. 如果是單例，將還沒裝配和初始化的 bean 先暴露出去，即放在singletonFactories中，如果其他執行緒進來獲取，可以將這個 bean 或 factoryBean 返回，而不需要等待；
4. 屬性裝配；
5. 初始化；
6. 將生成的 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[])。這個方法主要過程如下：

1. 解析 beanType，並對 beanType 進行一些必要的檢查；
2. 通過我們設置的 InstanceSupplier 或 FactoryMethod 來直接獲取 bean，如果有的話，直接返回該對象；
3. 如果構造參數為空，則可以復用已經解析好的構造對象（如果有的話）；
4. 執行我們註冊的SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors獲取構造對象數組；
5. 如果得到的數組不是空，或者 beanDefination 的裝配模式為構造注入，或者 beanDefination 包含構造參數，或者我們傳入的構造參數非空，則進入實例化 bean
6. 其他情況，使用無參構造來實例化。

	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中的參數值的類型不一定和構造方法中的匹配，包括兩種情況：

1. 類型不同，但可以通過TypeConverter轉換的類型。例如，在new User(int age, String name, Address address)的構造方法中，我可以在ConstructorArgumentValues添加2=new AddressVO()，這個時候只要 spring 能找到合適的轉換器就能轉換，這個轉換過程為：「解析未完成」（rawArguments） –》 “解析完成”（arguments）。
2. 類型不同，參數的值指向其他 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[])。這個方法程式碼比較多，為了更好地理解，可以分成兩種場景來看：

1. 入參里顯式指定構造參數。這種場景的參數值默認都是解析過的，所以不需要解析，該場景要求對應的構造對象的參數數量必須和指定的一樣。
2. 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)。這個方法包括以下過程：

1. 執行我們註冊的InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法，如果返回了 false，則不進行屬性裝配，直接返回；
2. 獲取 beanDefinition 中的PropertyValues對象，根據 beanDefinition 設置的注入類型，填充PropertyValues對象；
3. 執行我們註冊的InstantiationAwareBeanPostProcessor的postProcessProperties方法，可以對PropertyValues對象進行修改;
4. 依賴檢查（如果設置了）；
5. 進行屬性裝配。

	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)方法。和構造參數一樣，設置成員屬性的參數也需要經過「兩次轉換」，這裡就不詳細講解。這個方法主要包括以下過程：

1. 獲取屬性對象列表，如果這個列表的屬性對象都已經完成「兩次轉換」，則直接裝配屬性；
2. 遍歷屬性對象列表，分別進行兩次轉換，如果列表中沒有類似BeanDefinition、BeanDefinitionHolder等的對象，則設置PropertyValues對象已經轉換完成，下次調用這個方法不用再進行轉換；
3. 屬性裝配。

	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)。這個方法包括以下過程：

1. 獲取 propertyName 對應的PropertyAccessor對象，這裡將解析「嵌套對象形式」的 propertyName；
2. 創建PropertyTokenHolder對象，這裡將解析「索引形式」的 propertyName；
3. 使用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 的過程，本文未展開的內容包括：

1. 獲取和創建多例 bean；
2. 無參構造實例化；
3. 屬性裝配中，屬性值列表的填充（autowireByName和autowireByType）、屬性名為索引形式的屬性裝配
4. bean 的初始化。

感興趣的讀者可以自行分析。另外，以上內容如有錯誤，歡迎指正。

最後，感謝閱讀。

相關源碼請移步： spring-beans

本文為原創文章，轉載請附上原文出處鏈接：//www.cnblogs.com/ZhangZiSheng001/p/13196228.html