一、介紹
在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的初始化方法了。