spring源碼：bean加載之創建bean-屬性填充

一、介紹

在spring可以通過配置的方式指定bean的屬性值，這些屬性值可以是容器中的其他bean，也可以是配置的一個常量。如下

    <bean id="person" class="com.kaka.spring.pojo.Person" autowire="byName">
        <!-- 普通常量屬性 -->
        <property name="age" value="22"/>
        <!-- 屬性值爲容器中的另一個bean -->
		<property name="department" ref="department"/>
    </bean>

在加載這個Person的時候，spring第一步會先創建一個Person對象；第二步把Person對象依賴的所有屬性值都解析到一個PropertyValues對象中，這個階段專注於屬性值的解析。最後，再把PropertyValues中的屬性值設置到Person中。

二、bean加載流程

獲取用戶傳入name對應的beanName
嘗試從緩存中獲取bean實例
緩存中不存在，加載bean實例
3.1. 檢查循環依賴
3.2 處理parentBeanFactory
3.3 處理依賴的bean（dependsOn）
3.4 三種bean實例的創建
3.4.1 單例bean的創建
3.4.1.1 獲取單例bean，getSingleton()方法
3.4.1.2 準備創建bean，createBean()方法
3.4.1.3 創建bean，doCreateBean()方法
3.4.1.3.1 創建BeanWrapper
3.4.1.3.2 記錄bean的Object-Factory
3.4.1.3.3 屬性填充（本章解析）
3.4.2 原型bean的創建
3.4.3 根據scope策略創建bean
從bean實例中獲取真正的對象
轉換對象類型
返回對象實例

三、相關類及方法

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean：填充bean的整體流程
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#autowireByName：根據名稱自動裝配
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#autowireByType：根據類型自動裝配
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#checkDependencies：檢查依賴
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyPropertyValues：把已上解析的屬性填充到bean中

四、源碼分析

1. 填充bean屬性的主流程

	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		// 1. beanWrapper爲null的情況
		if (bw == null) {
			// 這個時候有屬性需要填充，則拋異常
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}
		
		// 2. 給InstantiationAwareBeanPostProcessors最後一次機會在屬性設置前來改變bean
		boolean continueWithPropertyPopulation = true;
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					// postProcessAfterInstantiation的返回值來控制是否繼續填充bean
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

		if (!continueWithPropertyPopulation) {
			return;
		}

		// 3. 自動注入類型(不推薦設置，默認爲no)
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

			// 3.1 根據名稱自動注入(重點方法)
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}

			// 3.2 根據類型自動注入(重點方法)
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}

			pvs = newPvs;
		}

		// 4. 屬性後處理和依賴檢查
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
		if (hasInstAwareBpps || needsDepCheck) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						// 後處理屬性值
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				// 依賴檢查，對應bean標籤中的dependency-check屬性(這個是spring2.5中的屬性；3.0已廢棄)
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}

		// 5. 把屬性應用到bean中(重點方法)
		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

以上代碼在AbstractAutowireCapableBeanFactory類的populateBean方法，主要有以下五個步驟：

BeanWrapper判斷是否爲空
調用InstantiationAwareBeanPostProcessors的postProcessAfterInstantiation方法，來改變bean內容，並根據返回值控制是否繼續填充屬性。
根據自動注入類型，提取依賴的bean，存入到newPvs

自動注入類型，表示該bean中的所有的屬性全部以某種注入方式自動填充，不推薦設置！
我們需要注入bean中哪個屬性，直接在對應的屬性上加@Autowire或者@Resource就行了。

自動注入類型，支持以下四種：
no：不自動裝配(默認值)
byName：根據屬性名來自動裝配。查找與屬性名一致的bean，並將它與屬性自動裝配
byType：根據指定屬性的類型查找相同類型的bean裝配。注：如果有多個bean匹配會拋異常
constructor：與byType類似，只是用於構造器參數。如果沒有在構造器參數中找到類型一致的bean就會拋異常。

    <bean id="department" class="com.kaka.spring.pojo.Department">
        <property name="id" value="1"/>
        <property name="name" value="技術部"/>
    </bean>
	<!-- 使用byName就不用設置department屬性指向的bean了 -->
    <bean id="person" class="com.kaka.spring.pojo.Person" autowire="byName">
        <property name="age" value="22"/>
<!--        <property name="department" ref="department"/>-->
    </bean>

屬性後處理和依賴檢查
調用InstantiationAwareBeanPostProcessors的postProcessPropertyValues方法，來處理bean的屬性。
依賴檢查用於，檢查bean中的所有屬性是否已被賦值。
把屬性應用到bean中

2. 按名稱提取依賴的bean

	protected void autowireByName(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
		// 1. 尋找bw中需要依賴注入的屬性
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			if (containsBean(propertyName)) {
				// 2. 遞歸初始化相關的bean
				Object bean = getBean(propertyName);
				pvs.add(propertyName, bean);
				// 3. 註冊依賴
				registerDependentBean(propertyName, beanName);
				if (logger.isDebugEnabled()) {
					logger.debug("Added autowiring by name from bean name '" + beanName +
							"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
							"' by name: no matching bean found");
				}
			}
		}
	}

先在BeanWrapper中解析出依賴的屬性名稱，然後根據這些名稱去容器中尋找對應依賴的bean，並放入到MutablePropertyValues屬性表中。

3. 按類型提取依賴的bean

	protected void autowireByType(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}

		Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
		// 尋找bw中需要依賴注入的屬性名稱
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			try {
				PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
				// Don't try autowiring by type for type Object: never makes sense,
				// even if it technically is a unsatisfied, non-simple property.
				if (Object.class != pd.getPropertyType()) {
					// 探測指定屬性的set方法
					MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
					boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
					DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
					// 解析指定beanName的屬性所匹配的值，並把解析到的屬性名存儲在autowiredBeanNames中
					// 核心方法！
					Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
					if (autowiredArgument != null) {
						pvs.add(propertyName, autowiredArgument);
					}
					for (String autowiredBeanName : autowiredBeanNames) {
						// 註冊依賴
						registerDependentBean(autowiredBeanName, beanName);
						if (logger.isDebugEnabled()) {
							logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
									propertyName + "' to bean named '" + autowiredBeanName + "'");
						}
					}
					autowiredBeanNames.clear();
				}
			}
			catch (BeansException ex) {
				throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
			}
		}
	}

根據類型提取依賴的bean比較複雜，但大致流程是一樣的。核心方法在AutowireCapableBeanFactory類的resolveDependency方法中，有興趣的可以繼續深挖~

4. 把屬性應用到bean中
在這之前的工作，都是爲了解析bean中各屬性的注入值，並把解析後的結果保存到了PropertyValues中。這一步就是把這些屬性值，設置到bean中。

	protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
		if (pvs.isEmpty()) {
			return;
		}

		if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
			((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
		}

		MutablePropertyValues mpvs = null;
		List<PropertyValue> original;

		if (pvs instanceof MutablePropertyValues) {
			mpvs = (MutablePropertyValues) pvs;
			// 如果mpvs中的值已經被轉換爲對應的類型那麼可以直接設置到beanwrapper
			
			if (mpvs.isConverted()) {
				// Shortcut: use the pre-converted values as-is.
				try {
					bw.setPropertyValues(mpvs);
					return;
				}
				catch (BeansException ex) {
					throw new BeanCreationException(
							mbd.getResourceDescription(), beanName, "Error setting property values", ex);
				}
			}
			original = mpvs.getPropertyValueList();
		}
		else {
			// 如果pvs並不是使用MutablePropertyValues封裝的類型，那麼直接使用原始的屬性獲取方法
			original = Arrays.asList(pvs.getPropertyValues());
		}

		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}
		// 獲取對應的解析器
		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

		// Create a deep copy, resolving any references for values.
		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;
				boolean convertible = bw.isWritableProperty(propertyName) &&
						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
				if (convertible) {
					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
				}
				// Possibly store converted value in merged bean definition,
				// in order to avoid re-conversion for every created bean instance.
				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));
				}
			}
		}
		if (mpvs != null && !resolveNecessary) {
			mpvs.setConverted();
		}

		// Set our (possibly massaged) deep copy.
		try {
			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
		}
		catch (BeansException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
		}
	}

至此創建好的bean已經注入完成依賴的屬性了，再後面就是調用這個bean的初始化方法了。

spring源碼：bean加載之創建bean-屬性填充

一、介紹

二、bean加載流程

三、相關類及方法

四、源碼分析

maven無法下載間接依賴包

CGLIB動態代理使用介紹

JDK動態代理介紹與使用

spring源碼：bean加載之從緩存中獲取bean

spring源碼：bean加載之創建bean-提前曝光bean的Object-Factory

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結