【死磕 Spring】—– IOC 之 屬性填充

精品專欄

 

• 死磕 Java 併發

• 死磕 Sharding-jdbc

原文出自：http://cmsblogs.com

doCreateBean() 主要用於完成 bean 的建立和初始化工作，我們可以將其分為四個過程：

• createBeanInstance() 實體化 bean
• populateBean() 屬性填充
• 迴圈依賴的處理
• initializeBean() 初始化 bean

第一個過程實體化 bean 已經在前面兩篇部落格分析完畢了，這篇部落格開始分析 屬性填充，也就是 populateBean()，該函式的作用是將 BeanDefinition 中的屬性值賦值給 BeanWrapper 實體物件(對於 BeanWrapper 我們後續專門寫文分析)。

1.    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
2.        // 沒有實體化物件
3.        if (bw == null) {
4.            // 有屬性丟擲異常
5.            if (mbd.hasPropertyValues()) {
6.                throw new BeanCreationException(
7.                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
8.            }
9.            else {
10.                // 沒有屬性直接傳回
11.                return;
12.            }
13.        }
15.        // 在設定屬性之前給 InstantiationAwareBeanPostProcessors 最後一次改變 bean 的機會
16.        boolean continueWithPropertyPopulation = true;
18.        // bena 不是"合成"的，即未由應用程式本身定義
19.        // 是否持有 InstantiationAwareBeanPostProcessor
20.        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
21.            // 迭代所有的 BeanPostProcessors
22.            for (BeanPostProcessor bp : getBeanPostProcessors()) {
23.                // 如果為 InstantiationAwareBeanPostProcessor
24.                if (bp instanceof InstantiationAwareBeanPostProcessor) {
25.                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
26.                    // 傳回值為是否繼續填充 bean
27.                    // postProcessAfterInstantiation：如果應該在 bean上面設定屬性則傳回true，否則傳回false
28.                    // 一般情況下，應該是傳回true，傳回 false 的話，
29.                    // 將會阻止在此 Bean 實體上呼叫任何後續的 InstantiationAwareBeanPostProcessor 實體。
30.                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
31.                        continueWithPropertyPopulation = false;
32.                        break;
33.                    }
34.                }
35.            }
36.        }
38.        // 如果後續處理器發出停止填充命令，則終止後續操作
39.        if (!continueWithPropertyPopulation) {
40.            return;
41.        }
43.        // bean 的屬性值
44.        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
46.        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
47.                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
49.            // 將 PropertyValues 封裝成 MutablePropertyValues 物件
50.            // MutablePropertyValues 允許對屬性進行簡單的操作，
51.            // 並提供建構式以支援Map的深度複製和構造。
52.            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
54.            // 根據名稱自動註入
55.            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
56.                autowireByName(beanName, mbd, bw, newPvs);
57.            }
59.            // 根據型別自動註入
60.            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
61.                autowireByType(beanName, mbd, bw, newPvs);
62.            }
64.            pvs = newPvs;
65.        }
67.        // 是否已經註冊了 InstantiationAwareBeanPostProcessors
68.        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
69.        // 是否需要進行依賴檢查
70.        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
72.        if (hasInstAwareBpps || needsDepCheck) {
73.            if (pvs == null) {
74.                pvs = mbd.getPropertyValues();
75.            }
77.            // 從 bw 物件中提取 PropertyDescriptor 結果集
78.            // PropertyDescriptor：可以透過一對存取方法提取一個屬性
79.            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
80.            if (hasInstAwareBpps) {
81.                for (BeanPostProcessor bp : getBeanPostProcessors()) {
82.                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
83.                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
84.                        // 對所有需要依賴檢查的屬性進行後處理
85.                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
86.                        if (pvs == null) {
87.                            return;
88.                        }
89.                    }
90.                }
91.            }
92.            if (needsDepCheck) {
93.                // 依賴檢查，對應 depends-on 屬性
94.                checkDependencies(beanName, mbd, filteredPds, pvs);
95.            }
96.        }
98.        if (pvs != null) {
99.            // 將屬性應用到 bean 中
100.            applyPropertyValues(beanName, mbd, bw, pvs);
101.        }
102.    }

處理流程如下：

1. 根據 hasInstantiationAwareBeanPostProcessors 屬性來判斷是否需要在註入屬性之前給 InstantiationAwareBeanPostProcessors 最後一次改變 bean 的機會，此過程可以控制 Spring 是否繼續進行屬性填充。
2. 根據註入型別的不同來判斷是根據名稱來自動註入（ autowireByName()）還是根據型別來自動註入（ autowireByType()），統一存入到 PropertyValues 中，PropertyValues 用於描述 bean 的屬性。
3. 判斷是否需要進行 BeanPostProcessor 和 依賴檢測。
4. 將所有 PropertyValues 中的屬性填充到 BeanWrapper 中。

自動註入

Spring 會根據註入型別（ byName / byType ）的不同，呼叫不同的方法（ autowireByName() / autowireByType()）來註入屬性值。

autowireByName()

方法 autowireByName() 是根據屬性名稱完成自動依賴註入的，程式碼如下：

1.    protected void autowireByName(
2.            String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
4.        // 對 Bean 物件中非簡單屬性
5.        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
6.        for (String propertyName : propertyNames) {
7.            // 如果容器中包含指定名稱的 bean，則將該 bean 註入到 bean中
8.            if (containsBean(propertyName)) {
9.                // 遞迴初始化相關 bean
10.                Object bean = getBean(propertyName);
11.                // 為指定名稱的屬性賦予屬性值  
12.                pvs.add(propertyName, bean);
13.                // 屬性依賴註入
14.                registerDependentBean(propertyName, beanName);
15.                if (logger.isDebugEnabled()) {
16.                    logger.debug("Added autowiring by name from bean name '" + beanName +
17.                            "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
18.                }
19.            }
20.            else {
21.                if (logger.isTraceEnabled()) {
22.                    logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
23.                            "' by name: no matching bean found");
24.                }
25.            }
26.        }
27.    }

該方法邏輯很簡單，獲取該 bean 的非簡單屬性，什麼叫做非簡單屬性呢？就是型別為物件型別的屬性，但是這裡並不是將所有的物件型別都都會找到，比如 8 個原始型別，String 型別 ，Number型別、Date型別、URL型別、URI型別等都會被忽略，如下：

1.    protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
2.        Set<String> result = new TreeSet<>();
3.        PropertyValues pvs = mbd.getPropertyValues();
4.        PropertyDescriptor[] pds = bw.getPropertyDescriptors();
5.        for (PropertyDescriptor pd : pds) {
6.            if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
7.                    !BeanUtils.isSimpleProperty(pd.getPropertyType())) {
8.                result.add(pd.getName());
9.            }
10.        }
11.        return StringUtils.toStringArray(result);
12.    }

過濾條件為：有可寫方法、依賴檢測中沒有被忽略、不是簡單屬性型別。其實這裡獲取的就是需要依賴註入的屬性。

獲取需要依賴註入的屬性後，透過迭代、遞迴的方式初始化相關的 bean，然後呼叫 registerDependentBean()完成註冊依賴，如下：

1.    public void registerDependentBean(String beanName, String dependentBeanName) {
2.        String canonicalName = canonicalName(beanName);
4.        synchronized (this.dependentBeanMap) {
5.            Set<String> dependentBeans =
6.                    this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
7.            if (!dependentBeans.add(dependentBeanName)) {
8.                return;
9.            }
10.        }
12.        synchronized (this.dependenciesForBeanMap) {
13.            Set<String> dependenciesForBean =
14.                    this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
15.            dependenciesForBean.add(canonicalName);
16.        }
17.    }

autowireByType()

1. protected void autowireByType(
2.            String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
4.        // 獲取 TypeConverter 實體
5.        // 使用自定義的 TypeConverter，用於取代預設的 PropertyEditor 機制
6.        TypeConverter converter = getCustomTypeConverter();
7.        if (converter == null) {
8.            converter = bw;
9.        }
11.        Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
12.        // 獲取非簡單屬性
13.        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
15.        for (String propertyName : propertyNames) {
16.            try {
17.                // 獲取 PropertyDescriptor 實體
18.                PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
20.                // 不要嘗試按型別
21.                if (Object.class != pd.getPropertyType()) {
22.                    // 探測指定屬性的 set 方法
23.                    MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
25.                    boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
26.                    DependencyDescriptor desc = new AbstractAutowireCapableBeanFactory.AutowireByTypeDependencyDescriptor(methodParam, eager);
28.                    // 解析指定 beanName 的屬性所匹配的值，並把解析到的屬性名稱儲存在 autowiredBeanNames 中
29.                    // 當屬性存在過個封裝 bean 時將會找到所有匹配的 bean 並將其註入
30.                    Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
32.                    if (autowiredArgument != null) {
33.                        pvs.add(propertyName, autowiredArgument);
34.                    }
36.                    // 迭代方式註入 bean
37.                    for (String autowiredBeanName : autowibeanredBeanNames) {
38.                        registerDependentBean(autowiredBeanName, beanName);
39.                        if (logger.isDebugEnabled()) {
40.                            logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
41.                                    propertyName + "' to bean named '" + autowiredBeanName + "'");
42.                        }
43.                    }
44.                    autowiredBeanNames.clear();
45.                }
46.            }
47.            catch (BeansException ex) {
48.                throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
49.            }
50.        }
51.    }

其實主要過程和根據名稱自動註入差不多都是找到需要依賴註入的屬性，然後透過迭代的方式尋找所匹配的 bean，最後呼叫 registerDependentBean() 註冊依賴。不過相對於 autowireByName() 而言，根據型別尋找相匹配的 bean 過程比較複雜，下麵我們就分析這個複雜的過程，如下：

1.    public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
2.                                    @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
4.        // 初始化引數名稱發現器，該方法並不會在這個時候嘗試檢索引數名稱
5.        // getParameterNameDiscoverer 傳回 parameterNameDiscoverer 實體，parameterNameDiscoverer 方法引數名稱的解析器
6.        descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
8.        // 依賴型別為 Optional 型別
9.        if (Optional.class == descriptor.getDependencyType()) {
10.            // 建立 Optional 實體依賴型別
11.            return createOptionalDependency(descriptor, requestingBeanName);
12.        }
14.        // 依賴型別為ObjectFactory、ObjectProvider
15.        else if (ObjectFactory.class == descriptor.getDependencyType() ||
16.                ObjectProvider.class == descriptor.getDependencyType()) {
17.            // ObjectFactory / ObjectProvider 用於 用於延遲解析依賴項
18.            return new DefaultListableBeanFactory.DependencyObjectProvider(descriptor, requestingBeanName);
19.        }
21.        else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
22.            // javaxInjectProviderClass 類註入的特殊處理
23.            return new DefaultListableBeanFactory.Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
24.        }
25.        else {
26.            // 為實際依賴關係標的的延遲解析構建代理
27.            // 預設實現傳回 null
28.            Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
29.                    descriptor, requestingBeanName);
30.            if (result == null) {
31.                // 通用處理邏輯
32.                result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
33.            }
34.            return result;
35.        }
36.    }

這裡我們關註通用處理邏輯： doResolveDependency()，如下：

1.    public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
2.                                      @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
4.        // 註入點
5.        InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
6.        try {
7.            // 針對給定的工廠給定一個快捷實現的方式，例如考慮一些預先解析的資訊
8.            // 在進入所有bean的常規型別匹配演演算法之前，解析演演算法將首先嘗試透過此方法解析快捷方式。
9.            // 子類可以改寫此方法
10.            Object shortcut = descriptor.resolveShortcut(this);
11.            if (shortcut != null) {
12.                // 傳回快捷的解析資訊
13.                return shortcut;
14.            }
16.            // 依賴的型別
17.            Class> type = descriptor.getDependencyType();
18.            // 支援 Spring 的註解 @value
19.            Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
20.            if (value != null) {
21.                if (value instanceof String) {
22.                    String strVal = resolveEmbeddedValue((String) value);
23.                    BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
24.                    value = evaluateBeanDefinitionString(strVal, bd);
25.                }
26.                TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
27.                return (descriptor.getField() != null ?
28.                        converter.convertIfNecessary(value, type, descriptor.getField()) :
29.                        converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
30.            }
32.            // 解析複合 bean，其實就是對 bean 的屬性進行解析
33.            // 包括：陣列、Collection 、Map 型別
34.            Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
35.            if (multipleBeans != null) {
36.                return multipleBeans;
37.            }
39.            // 查詢與型別相匹配的 bean
40.            // 傳回值構成為：key = 匹配的 beanName，value = beanName 對應的實體化 bean
41.            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
42.            // 沒有找到，檢驗 @autowire  的 require 是否為 true
43.            if (matchingBeans.isEmpty()) {
44.                // 如果 @autowire 的 require 屬性為 true ，但是沒有找到相應的匹配項，則丟擲異常
45.                if (isRequired(descriptor)) {
46.                    raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
47.                }
48.                return null;
49.            }
51.            String autowiredBeanName;
52.            Object instanceCandidate;
54.            if (matchingBeans.size() > 1) {
55.                //  確認給定 bean autowire 的候選者
56.                // 按照 @Primary 和 @Priority 的順序
57.                autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
58.                if (autowiredBeanName == null) {
59.                    if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
60.                        // 唯一性處理
61.                        return descriptor.resolveNotUnique(type, matchingBeans);
62.                    } else {
63.                        // 在可選的Collection / Map的情況下，默默地忽略一個非唯一的情況：可能它是一個多個常規bean的空集合
64.                        return null;
65.                    }
66.                }
67.                instanceCandidate = matchingBeans.get(autowiredBeanName);
68.            } else {
69.                // We have exactly one match.
70.                Map.Entry<Staring, Object> entry = matchingBeans.entrySet().iterator().next();
71.                autowiredBeanName = entry.getKey();
72.                instanceCandidate = entry.getValue();
73.            }
75.            if (autowiredBeanNames != null) {
76.                autowiredBeanNames.add(autowiredBeanName);
77.            }
78.            if (instanceCandidate instanceof Class) {
79.                instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
80.            }
81.            Object result = instanceCandidate;
82.            if (result instanceof NullBean) {
83.                if (isRequired(descriptor)) {
84.                    raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
85.                }
86.                result = null;
87.            }
88.            if (!ClassUtils.isAssignableValue(type, result)) {
89.                throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
90.            }
91.            return result;
92.        } finally {
93.            ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
94.        }
95.    }

到這裡就已經完成了所有屬性的註入了。 populateBean() 該方法就已經完成了一大半工作了，下一步則是對依賴 bean 的檢測和 PostProcessor 處理，這個我們後面分析，下麵分析該方法的最後一步： applyPropertyValues()

applyPropertyValues

其實上面只是完成了所有註入屬性的獲取，將獲取的屬性封裝在 PropertyValues 的實體物件 pvs 中，並沒有應用到已經實體化的 bean 中，而 applyPropertyValues() 則是完成這一步驟的。

1.   protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
2.        if (pvs.isEmpty()) {
3.            return;
4.        }
6.        if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
7.            ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
8.        }
10.        // MutablePropertyValues 型別屬性
11.        MutablePropertyValues mpvs = null;
12.        // 原始型別
13.        List<PropertyValue> original;
16.        if (pvs instanceof MutablePropertyValues) {
17.            mpvs = (MutablePropertyValues) pvs;
18.            if (mpvs.isConverted()) {
19.                try {
20.                    // 設定到 BeanWrapper 中去
21.                    bw.setPropertyValues(mpvs);
22.                    return;
23.                }
24.                catch (BeansException ex) {
25.                    throw new BeanCreationException(
26.                            mbd.getResourceDescription(), beanName, "Error setting property values", ex);
27.                }
28.            }
29.            original = mpvs.getPropertyValueList();
30.        }
31.        else {
32.            // 如果 pvs 不是 MutablePropertyValues 型別，則直接使用原始型別
33.            original = Arrays.asList(pvs.getPropertyValues());
34.        }
36.        // 獲取 TypeConverter
37.        TypeConverter converter = getCustomTypeConverter();
38.        if (converter == null) {
39.            converter = bw;
40.        }
42.        // 獲取對應的解析器
43.        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
45.        // Create a deep copy, resolving any references for values.
46.        List<PropertyValue> deepCopy = new ArrayList<>(original.size());
47.        boolean resolveNecessary = false;
48.        // 遍歷屬性，將屬性轉換為對應類的對應屬性的型別
49.        for (PropertyValue pv : original) {
50.            if (pv.isConverted()) {
51.                deepCopy.add(pv);
52.            }
53.            else {
54.                String propertyName = pv.getName();
55.                Object originalValue = pv.getValue();
56.                Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
57.                Object convertedValue = resolvedValue;
58.                boolean convertible = bw.isWritableProperty(propertyName) &&
59.                        !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
60.                if (convertible) {
61.                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
62.                }
63.                // Possibly store converted value in merged bean definition,
64.                // in order to avoid re-conversion for every created bean instance.
65.                if (resolvedValue == originalValue) {
66.                    if (convertible) {
67.                        pv.setConvertedValue(convertedValue);
68.                    }
69.                    deepCopy.add(pv);
70.                }
71.                else if (convertible && originalValue instanceof TypedStringValue &&
72.                        !((TypedStringValue) originalValue).isDynamic() &&
73.                        !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
74.                    pv.setConvertedValue(convertedValue);
75.                    deepCopy.add(pv);
76.                }
77.                else {
78.                    resolveNecessary = true;
79.                    deepCopy.add(new PropertyValue(pv, convertedValue));
80.                }
81.            }
82.        }
83.        if (mpvs != null && !resolveNecessary) {
84.            mpvs.setConverted();
85.        }
87.        // Set our (possibly massaged) deep copy.
88.        try {
89.            bw.setPropertyValues(new MutablePropertyValues(deepCopy));
90.        }
91.        catch (BeansException ex) {
92.            throw new BeanCreationException(
93.                    mbd.getResourceDescription(), beanName, "Error setting property values", ex);
94.        }
95.    }

至此， doCreateBean() 第二個過程：屬性填充 已經分析完成了，下篇分析第三個過程：迴圈依賴的處理，其實迴圈依賴並不僅僅只是在 doCreateBean() 中處理，其實在整個載入 bean 的過程中都有涉及，所以下篇內容並不僅僅只侷限於 doCreateBean()。

往

期

精

彩

【死磕 Spring】—– IOC 之開啟 bean 的實體化行程

【死磕 Spring】—– IOC 之 Factory 實體化 bean

【死磕 Spring】—– IOC 之建構式實體化 bean

【死磕 Spring】—– IOC 之分析各 scope 的 bean 建立

【死磕 Spring】—– IOC 之開啟 bean 的載入

【死磕 Spring】—– IOC 之從單例快取中獲取單例 bean

【死磕 Spring】—– IOC 之parentBeanFactory 與依賴處理

【死磕 Spring】—– IOC 之 IOC 初始化總結

 

END

>>>>>> 加群交流技術 <<<<<<