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

簡介

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還有幾個擴展接口,用的比較多的可能是ConfigurableBeanFactoryAutowireCapableBeanFactory

  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,檢查是否存在唯一一個通過registerBeanDefinitionisPrimary = 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)。這個方法包括幾個過程,主要就是處理一些多線程問題:

  1. 獲取指定 beanName 的 bean,如果已經存在,就不去創建,這時為了處理多線程同時創建 bean 的問題;
  2. 如果當前 bean 已經在創建中,會拋出 BeanCurrentlyInCreationException,創建單例 bean 之前是有加鎖的,按理不會出現這種情況;
  3. 創建單例 bean;
  4. 如果創建成功,將 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. 執行我們註冊的InstantiationAwareBeanPostProcessorpostProcessBeforeInstantiation方法,如果返回了非空對象,則將其返回。也就是說我們可以在該方法中自定義完成 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. 執行我們註冊的MergedBeanDefinitionPostProcessorpostProcessMergedBeanDefinition方法;
  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. 執行我們註冊的SmartInstantiationAwareBeanPostProcessordetermineCandidateConstructors獲取構造對象數組;
  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

在繼續分析之前,有必要了解下ConstructorArgumentValuesArgumentsHolder這兩個類。

首先,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;

}

ArgumentsHolderConstructorResolver的內部類,和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. 執行我們註冊的InstantiationAwareBeanPostProcessorpostProcessAfterInstantiation方法,如果返回了 false,則不進行屬性裝配,直接返回;
  2. 獲取 beanDefinition 中的PropertyValues對象,根據 beanDefinition 設置的注入類型,填充PropertyValues對象;
  3. 執行我們註冊的InstantiationAwareBeanPostProcessorpostProcessProperties方法,可以對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);
		}
	}

這個方法中主要涉及autowireByNameautowireByTypeapplyPropertyValues三個方法,前兩個暫時不展開,只講最後一個方法。

幾個重要的知識點

在分析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

PropertyTokenHolderAbstractNestablePropertyAccessor的內部類,它更多的是針對“索引形式”的 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. 遍歷屬性對象列表,分別進行兩次轉換,如果列表中沒有類似BeanDefinitionBeanDefinitionHolder等的對象,則設置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

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

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※台北網頁設計公司全省服務真心推薦

※想知道最厲害的網頁設計公司"嚨底家"!

新北清潔公司,居家、辦公、裝潢細清專業服務

※推薦評價好的iphone維修中心

您可能也會喜歡…