Spring4.3.x 容器中bean的創建過程（3）—— 初始化bean的屬性值

版權聲明：本文爲博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/chyohn/article/details/54967798

概述

在Spring4.3.x 容器中bean的創建過程（1）——走進初始化bean的主要戰場一篇中我們找到了初始化bean的主要場所在AbstractAutowireCapableBeanFactory類中的doCreateBean方法中，在這個方法中首先調用createBeanInstance方法創建bean的實例；然後調用populateBean方法設置bean的屬性；接着調用initializeBean方法執行Bean後處理器和InitializingBean對象的afterPropertiesSet方法以及init-method方法；最後調用registerDisposableBeanIfNecessary方法註冊bean的銷燬方法。它的每一步都比較繁瑣，所以我把他們分開來探討。在 Spring4.3.x 容器中bean的創建過程（2）——實例化Bean一篇中，我已經探討了第一步實例化bean，這一篇探討的內容就是第二步通過BeanWrapper對象設置bean的屬性。

設置bean的屬性值

AbstractAutowireCapableBeanFactory類中的doCreateBean方法調用它的populateBean方法設置bean的屬性值，populateBean方法的源碼如下。

    protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
        // 獲取bean需要被初始化的屬性
        PropertyValues pvs = mbd.getPropertyValues();

        if (bw == null) {
            if (!pvs.isEmpty()) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            } else {
                // 對於bean爲null的情況，沒有屬性可以設置，直接返回
                return;
            }
        }

        // 執行InstantiationAwareBeanPostProcessor的post方法
        // 如果bean是不是synthetic的，即不是容器基本或者工具型的bean，不需要執行InstantiationAwareBeanPostProcessor的post方法
        boolean continueWithPropertyPopulation = true;
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        // 可能在post方法中已經設置bean的屬性，因此後面不需要再設置了
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }

        if (!continueWithPropertyPopulation) {
            return;
        }

        // 檢查是否需要自動裝配bean的屬性值
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                // 根據名稱自動裝配來添加bean屬性值
                autowireByName(beanName, mbd, bw, newPvs);
            }

            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                // 根據類型自動裝配來添加bean的屬性值
                autowireByType(beanName, mbd, bw, newPvs);
            }

            pvs = newPvs;
        }

        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

        if (hasInstAwareBpps || needsDepCheck) {
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            if (hasInstAwareBpps) {
                // 執行InstantiationAwareBeanPostProcessor的post方法
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        // 通過postProcessPropertyValues返回一個新的PropertyValues
                        // 也可以在這裏設置bean的屬性，比如被@Autowired、@Value和@Inject註解的屬性或者方法
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }
            if (needsDepCheck) {
                // 執行依賴檢測
                checkDependencies(beanName, mbd, filteredPds, pvs);
            }
        }

        // 設置bean的屬性
        applyPropertyValues(beanName, mbd, bw, pvs);
    }

populateBean方法可能會調用實例化後處理器InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法和postProcessPropertyValues方法設置bean的屬性，除此之外調用AbstractAutowireCapableBeanFactory類的applyPropertyValues方法設置bean的屬性。但是在執行applyPropertyValues方法之前，還可能根據名稱或者類型自動裝配bean的屬性。下面我們先看看自動裝配bean屬性後，在看applyPropertyValues方法如何設置bean的屬性。

（1） 根據名稱自動裝配來添加bean屬性值

如果bean允許的自動裝配模式爲by name，那麼AbstractAutowireCapableBeanFactory類的populateBean方法調用autowireByName方法來添加需要初始化設置的屬性及其值，源碼如下。

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

        // 獲取可能需要自動裝配的屬性的名稱
        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        for (String propertyName : propertyNames) {
            if (containsBean(propertyName)) {
                // 容器中含有與屬性名稱相同的bean名稱
                // 從容器中獲取屬性值
                Object bean = getBean(propertyName);
                // 添加屬性及其值
                pvs.add(propertyName, bean);
                // 註冊bean的依賴
                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");
                }
            }
        }
    }

autowireByName方法首先調用unsatisfiedNonSimpleProperties方法獲取需要自動裝配的屬性的名稱，然後從bean工廠中通過屬性名稱獲取對應的屬性值。下面是unsatisfiedNonSimpleProperties方法的源碼。

    protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
        Set<String> result = new TreeSet<String>();
        PropertyValues pvs = mbd.getPropertyValues();
        // 獲取bean的屬性描述器
        PropertyDescriptor[] pds = bw.getPropertyDescriptors();
        for (PropertyDescriptor pd : pds) {
            if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
                    !BeanUtils.isSimpleProperty(pd.getPropertyType())) {
                // 屬性具有setter方法，不在依賴排除列表中，不在已有的PropertyValues中
                // 並且不是基本類型及其數組時，添加到result中
                result.add(pd.getName());
            }
        }
        return StringUtils.toStringArray(result);
    }

unsatisfiedNonSimpleProperties方法返回那些擁有setter方法、不在依賴排除列表中、不在已有的PropertyValues中和不是基本類型及其數組的屬性的名稱。

（2） 根據類型自動裝配來添加bean的屬性值

如果bean允許的自動裝配模式爲by type那麼AbstractAutowireCapableBeanFactory類的populateBean方法調用autowireByType方法來添加需要初始化設置的屬性及其值，源碼如下。

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

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

        Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
        // 獲取可能需要自動裝配的屬性的名稱
        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        for (String propertyName : propertyNames) {
            try {
                // 獲取屬性描述器對象
                PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);

                if (Object.class != pd.getPropertyType()) {
                    MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                    // 對於PriorityOrdered的後處理器，不採用立即執行初始化
                    boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());
                    DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                    // 獲取屬性的值
                    Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                    if (autowiredArgument != null) {
                        // 屬性值存在，則添加到pvs中
                        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);
            }
        }
    }

當有滿足條件的屬性時,autowireByType方法會調用的AbstractAutowireCapableBeanFactory類resolveDependency方法來獲取屬性值，這個方法的實現在DefaultListableBeanFactory類中，源碼如下。

    @Override
    public Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

        descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());

        if (javaUtilOptionalClass == descriptor.getDependencyType()) {
            // 類型爲java8的java.util.Optional
            return new OptionalDependencyFactory().createOptionalDependency(descriptor, requestingBeanName);
        } else if (ObjectFactory.class == descriptor.getDependencyType() ||
                ObjectProvider.class == descriptor.getDependencyType()) {
            return new DependencyObjectProvider(descriptor, requestingBeanName);
        } else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
            // 類型爲javax.inject.Provider
            return new Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
        } else {
            Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
                    descriptor, requestingBeanName);
            if (result == null) {
                result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
            }
            return result;
        }
    }

resolveDependency方法會根據依賴的類型來做不同的處理，但不管是哪種情況，最終都會執行DefaultListableBeanFactory對象的doResolveDependency方法，這個方法的源碼如下。

    public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

        InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
        try {
            // 從DependencyDescriptor對象中快速獲取所需對象
            // Spring4.3.1 後新增的
            Object shortcut = descriptor.resolveShortcut(this);
            if (shortcut != null) {
                return shortcut;
            }

            Class<?> type = descriptor.getDependencyType();
            Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
            if (value != null) {
                // 處理@Value註解提供的value值
                if (value instanceof String) {
                    String strVal = resolveEmbeddedValue((String) value);
                    BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
                    value = evaluateBeanDefinitionString(strVal, bd);
                }
                TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
                return (descriptor.getField() != null ?
                        converter.convertIfNecessary(value, type, descriptor.getField()) :
                        converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
            }

            // resolveMultipleBeans方法處理數組、集合、Map屬性
            Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
            if (multipleBeans != null) {
                return multipleBeans;
            }

            // 獲取可用的實例
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
            if (matchingBeans.isEmpty()) {
                // 無可用實例
                if (descriptor.isRequired()) {
                    raiseNoMatchingBeanFound(type, descriptor.getResolvableType().toString(), descriptor);
                }
                return null;
            }

            String autowiredBeanName;
            Object instanceCandidate;

            if (matchingBeans.size() > 1) {
                // 可用實例不止一個
                // 獲取最優實例
                autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
                if (autowiredBeanName == null) {
                    if (descriptor.isRequired() || !indicatesMultipleBeans(type)) {
                        // 屬性的值必須有，或者屬性不是數組、Collection、Map對象
                        return descriptor.resolveNotUnique(type, matchingBeans);
                    } else {
                        // 在這裏屬性可能是Collection或者Map對象，直接返回null
                        return null;
                    }
                }
                instanceCandidate = matchingBeans.get(autowiredBeanName);
            } else {
                // 只有一個可用實例
                Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
                autowiredBeanName = entry.getKey();
                instanceCandidate = entry.getValue();
            }

            if (autowiredBeanNames != null) {
                autowiredBeanNames.add(autowiredBeanName);
            }
            return (instanceCandidate instanceof Class ?
                    descriptor.resolveCandidate(autowiredBeanName, type, this) : instanceCandidate);
        } finally {
            ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
        }
    }

doResolveDependency方法裏分成四種情況獲取bean依賴的對象，第一種是通過DependencyDescriptor對象的resolveShortcut方法獲得依賴對象，這種情況根據具體的DependencyDescriptor對象確定，有些返回null，而有些則會返回一個對象；第二種是通過AutowireCandidateResolver策略類獲得依賴對象，這種情況需要根據工廠對象採用的是什麼策略而定；第三種情況是屬性是數組、集合、Map對象時，從容器中獲取所有匹配的對象放進數組、集合或者Map對象中；第四種是一般情況直接從容器中獲取匹配的對象，對於這種情況容器中可能存在多個匹配的bean，doResolveDependency方法通過調用determineAutowireCandidate方法確定最優的bean。下面我們看看屬性是數組、集合或者Map對象時的處理。

當屬性爲數組、集合或者Map對象時，doResolveDependency方法調用DefaultListableBeanFactory類的resolveMultipleBeans方法處理，下面是這個方法的源碼。

    private Object resolveMultipleBeans(DependencyDescriptor descriptor, String beanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) {

        Class<?> type = descriptor.getDependencyType();
        if (type.isArray()) {
            // 處理數組對象
            Class<?> componentType = type.getComponentType();
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
                    new MultiElementDependencyDescriptor(descriptor));
            if (matchingBeans.isEmpty()) {
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            Object result = converter.convertIfNecessary(matchingBeans.values(), type);
            if (getDependencyComparator() != null && result instanceof Object[]) {
                Arrays.sort((Object[]) result, adaptDependencyComparator(matchingBeans));
            }
            return result;
        } else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
            // 處理集合對象
            Class<?> elementType = descriptor.getCollectionType();
            if (elementType == null) {
                return null;
            }
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType,
                    new MultiElementDependencyDescriptor(descriptor));
            if (matchingBeans.isEmpty()) {
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            Object result = converter.convertIfNecessary(matchingBeans.values(), type);
            if (getDependencyComparator() != null && result instanceof List) {
                Collections.sort((List<?>) result, adaptDependencyComparator(matchingBeans));
            }
            return result;
        } else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
            // 處理Map對象
            Class<?> keyType = descriptor.getMapKeyType();
            if (String.class != keyType) {
                return null;
            }
            Class<?> valueType = descriptor.getMapValueType();
            if (valueType == null) {
                return null;
            }
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType,
                    new MultiElementDependencyDescriptor(descriptor));
            if (matchingBeans.isEmpty()) {
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            return matchingBeans;
        } else {
            return null;
        }
    }

（3）applyPropertyValues方法設置bean的屬性值

在獲取到哪些屬性需要設置值的後，AbstractAutowireCapableBeanFactory類的populateBean方法調用applyPropertyValues方法來設置屬性值，源碼如下。

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

        MutablePropertyValues mpvs = null;
        List<PropertyValue> original;

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

        if (pvs instanceof MutablePropertyValues) {
            mpvs = (MutablePropertyValues) pvs;
            if (mpvs.isConverted()) {
                // 爲了避免每一次創建實例的時候再一次轉換屬性的真實值
                // 則使用上一次轉換後的pvs
                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<PropertyValue>(original.size());
        boolean resolveNecessary = false;
        for (PropertyValue pv : original) {
            if (pv.isConverted()) {

                deepCopy.add(pv);
            } else {
                // 獲取真實的屬性值
                String propertyName = pv.getName();
                Object originalValue = pv.getValue();
                // 獲得屬性值，這兒會處理SpEL表達式
                Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
                Object convertedValue = resolvedValue;
                boolean convertible = bw.isWritableProperty(propertyName) &&
                        !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
                if (convertible) {
                    // 類型轉換
                    // 屬性擁有setter方法，且配置的屬性名稱中不包含“.”或者“[”時，進行類型轉換
                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
                }

                // 把轉換後的值存到BeanDefinition對象中，爲了避免每一次創建實例的時候再一次轉換
                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) {
            // 把MutablePropertyValues對象標誌成“已完成轉換”，已避免下次使用時重複操作
            mpvs.setConverted();
        }

        try {
            // 設置bean的屬性
            bw.setPropertyValues(new MutablePropertyValues(deepCopy));
        } catch (BeansException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Error setting property values", ex);
        }
    }

applyPropertyValues方法也是爲設置bean的屬性做準備工作的，它主要做了兩件事情，其一是從配置中解析屬性的真實值，即處理Spring的EL表達式和類型轉換；其二是爲了降低類型轉換的開銷而緩存那些可以被緩存的屬性配置。準備工作完成後，調用BeanWrapper對象的setPropertyValues(PropertyValues pvs)方法繼續設置bean屬性的工作。

下面我們繼續看BeanWrapper對象的setPropertyValues(PropertyValues pvs)方法的源碼。setPropertyValues(PropertyValues pvs)方法的定義在PropertyAccessor接口中，它的實現在AbstractPropertyAccessor抽象類中，源碼如下。

    @Override
    public void setPropertyValues(PropertyValues pvs) throws BeansException {
        setPropertyValues(pvs, false, false);
    }

    @Override
    public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
            throws BeansException {

        List<PropertyAccessException> propertyAccessExceptions = null;
        List<PropertyValue> propertyValues = (pvs instanceof MutablePropertyValues ?
                ((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));
        for (PropertyValue pv : propertyValues) {
            try {
                // 設置屬性
                setPropertyValue(pv);
            } catch (NotWritablePropertyException ex) {
                // 沒有setter方法
                if (!ignoreUnknown) {
                    throw ex;
                }
            } catch (NullValueInNestedPathException ex) {
                // 設置屬性時，遇到空指針異常
                if (!ignoreInvalid) {
                    throw ex;
                }
            } catch (PropertyAccessException ex) {
                if (propertyAccessExceptions == null) {
                    propertyAccessExceptions = new LinkedList<PropertyAccessException>();
                }
                propertyAccessExceptions.add(ex);
            }
        }

        if (propertyAccessExceptions != null) {
            PropertyAccessException[] paeArray =
                    propertyAccessExceptions.toArray(new PropertyAccessException[propertyAccessExceptions.size()]);
            throw new PropertyBatchUpdateException(paeArray);
        }
    }

setPropertyValues(PropertyValues pvs)方法調用重載方法 setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)設置屬性值。而在設置每個屬性時，setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)方法調用另一個重載方法setPropertyValue(PropertyValue pv)方法來爲單個屬性賦值。

setPropertyValue(PropertyValue pv)方法在AbstractPropertyAccessor類中有實現，在再其子類AbstractNestablePropertyAccessor類中也有實現，BeanWrapperImpl繼承了AbstractNestablePropertyAccessor類，因此我們看看AbstractNestablePropertyAccessor中的實現，源碼如下。

    @Override
    public void setPropertyValue(PropertyValue pv) throws BeansException {
        PropertyTokenHolder tokens = (PropertyTokenHolder) pv.resolvedTokens;
        if (tokens == null) {
            String propertyName = pv.getName();
            BeanWrapperImpl nestedBw;
            try {
                nestedBw = getBeanWrapperForPropertyPath(propertyName);
            } catch (NotReadablePropertyException ex) {
                throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
                        "Nested property in path '" + propertyName + "' does not exist", ex);
            }
            tokens = getPropertyNameTokens(getFinalPath(nestedBw, propertyName));
            if (nestedBw == this) {
                // 爲了避免再一次創建bean時重新獲取PropertyTokenHolder對象，因此把它緩存起來
                // 由於，嵌套的bean可能會變，因此對嵌套的bean的屬性配置不做緩存
                pv.getOriginalPropertyValue().resolvedTokens = tokens;
            }
            nestedBw.setPropertyValue(tokens, pv);
        } else {
            setPropertyValue(tokens, pv);
        }
    }

setPropertyValue(PropertyValue pv) 方法主要做兩件事情，其一是獲取屬性所屬bean的AbstractNestablePropertyAccessor對象；其二是緩存非嵌套bean屬性的PropertyTokenHolder對象。當獲得屬性所對應的AbstractNestablePropertyAccessor對象後，調用setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv)方法 完成屬性的設置，源碼如下。

    protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
        String propertyName = tokens.canonicalName;
        String actualName = tokens.actualName;

        if (tokens.keys != null) {
            // 屬性爲數組、List或者Map
            // 屬性必須有getter和setter方法
            // 配置時索引或者Map的key使用[]包圍
            PropertyTokenHolder getterTokens = new PropertyTokenHolder();
            getterTokens.canonicalName = tokens.canonicalName;
            getterTokens.actualName = tokens.actualName;
            getterTokens.keys = new String[tokens.keys.length - 1];
            System.arraycopy(tokens.keys, 0, getterTokens.keys, 0, tokens.keys.length - 1);
            Object propValue;
            try {
                // 根據PropertyTokenHolder對象獲取當前類持有的bean的屬性值
                propValue = getPropertyValue(getterTokens);
            } catch (NotReadablePropertyException ex) {
                // 屬性沒有getter方法，拋出異常
                throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
                        "Cannot access indexed value in property referenced " +
                        "in indexed property path '" + propertyName + "'", ex);
            }
            // 設置元素的值
            String key = tokens.keys[tokens.keys.length - 1];
            if (propValue == null) {
                if (isAutoGrowNestedPaths()) {
                    // 如果autoGrowNestedPaths==true，則創建一個默認值
                    int lastKeyIndex = tokens.canonicalName.lastIndexOf('[');
                    getterTokens.canonicalName = tokens.canonicalName.substring(0, lastKeyIndex);
                    propValue = setDefaultValue(getterTokens);
                } else {
                    throw new NullValueInNestedPathException(getRootClass(), this.nestedPath + propertyName,
                            "Cannot access indexed value in property referenced " +
                            "in indexed property path '" + propertyName + "': returned null");
                }
            }
            if (propValue.getClass().isArray()) {
                // 添加或者修改數組元素
                PropertyHandler ph = getLocalPropertyHandler(actualName);
                // 獲得數組元素的類型
                Class<?> requiredType = propValue.getClass().getComponentType();
                int arrayIndex = Integer.parseInt(key);
                Object oldValue = null;
                try {
                    if (isExtractOldValueForEditor() && arrayIndex < Array.getLength(propValue)) {
                        oldValue = Array.get(propValue, arrayIndex);
                    }
                    // 類型轉換
                    // 獲取真實類型的值
                    Object convertedValue = convertIfNecessary(propertyName, oldValue, pv.getValue(),
                            requiredType, ph.nested(tokens.keys.length));
                    int length = Array.getLength(propValue);
                    if (arrayIndex >= length && arrayIndex < this.autoGrowCollectionLimit) {
                        // 索引大於數組的長度，則從新創建一個數組
                        Class<?> componentType = propValue.getClass().getComponentType();
                        Object newArray = Array.newInstance(componentType, arrayIndex + 1);
                        System.arraycopy(propValue, 0, newArray, 0, length);
                        setPropertyValue(actualName, newArray);
                        propValue = getPropertyValue(actualName);
                    }
                    // 設置數組元素的值
                    Array.set(propValue, arrayIndex, convertedValue);
                } catch (IndexOutOfBoundsException ex) {
                    throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
                            "Invalid array index in property path '" + propertyName + "'", ex);
                }
            } else if (propValue instanceof List) {
                // 添加或者修改List元素
                PropertyHandler ph = getPropertyHandler(actualName);
                // 獲取List元素的泛型類型
                Class<?> requiredType = ph.getCollectionType(tokens.keys.length);
                List<Object> list = (List<Object>) propValue;
                int index = Integer.parseInt(key);
                Object oldValue = null;
                if (isExtractOldValueForEditor() && index < list.size()) {
                    oldValue = list.get(index);
                }
                // 類型轉換，獲取元素的真實類型的值
                Object convertedValue = convertIfNecessary(propertyName, oldValue, pv.getValue(),
                        requiredType, ph.nested(tokens.keys.length));
                int size = list.size();
                if (index >= size && index < this.autoGrowCollectionLimit) {
                    // 所添加的元素的索引超過List現有元素個數
                    // 增加List的個數
                    for (int i = size; i < index; i++) {
                        try {
                            list.add(null);
                        } catch (NullPointerException ex) {
                            throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
                                    "Cannot set element with index " + index + " in List of size " +
                                    size + ", accessed using property path '" + propertyName +
                                    "': List does not support filling up gaps with null elements");
                        }
                    }
                    list.add(convertedValue);
                } else {
                    try {
                        list.set(index, convertedValue);
                    } catch (IndexOutOfBoundsException ex) {
                        throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
                                "Invalid list index in property path '" + propertyName + "'", ex);
                    }
                }
            } else if (propValue instanceof Map) {
                // 添加或修改Map元素
                PropertyHandler ph = getLocalPropertyHandler(actualName);
                // 獲取Map中key的類型
                Class<?> mapKeyType = ph.getMapKeyType(tokens.keys.length);
                // 獲取Map中value的類型
                Class<?> mapValueType = ph.getMapValueType(tokens.keys.length);
                Map<Object, Object> map = (Map<Object, Object>) propValue;

                TypeDescriptor typeDescriptor = TypeDescriptor.valueOf(mapKeyType);
                // 轉換鍵值爲真實類型的值
                Object convertedMapKey = convertIfNecessary(null, null, key, mapKeyType, typeDescriptor);
                Object oldValue = null;
                if (isExtractOldValueForEditor()) {
                    oldValue = map.get(convertedMapKey);
                }
                // 獲取真實類型的值
                Object convertedMapValue = convertIfNecessary(propertyName, oldValue, pv.getValue(),
                        mapValueType, ph.nested(tokens.keys.length));
                map.put(convertedMapKey, convertedMapValue);
            } else {
                throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
                        "Property referenced in indexed property path '" + propertyName +
                        "' is neither an array nor a List nor a Map; returned value was [" + propValue + "]");
            }
        } else {
            // 獲得屬性對應的PropertyHandler對象
            PropertyHandler ph = getLocalPropertyHandler(actualName);
            if (ph == null || !ph.isWritable()) {
                if (pv.isOptional()) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Ignoring optional value for property '" + actualName +
                                "' - property not found on bean class [" + getRootClass().getName() + "]");
                    }
                    return;
                } else {
                    throw createNotWritablePropertyException(propertyName);
                }
            }
            Object oldValue = null;
            try {
                Object originalValue = pv.getValue();
                Object valueToApply = originalValue;
                if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
                    // 獲得類型轉換後的真實值
                    if (pv.isConverted()) {
                        valueToApply = pv.getConvertedValue();
                    } else {
                        if (isExtractOldValueForEditor() && ph.isReadable()) {
                            try {
                                oldValue = ph.getValue();
                            } catch (Exception ex) {
                                if (ex instanceof PrivilegedActionException) {
                                    ex = ((PrivilegedActionException) ex).getException();
                                }
                                if (logger.isDebugEnabled()) {
                                    logger.debug("Could not read previous value of property '" +
                                            this.nestedPath + propertyName + "'", ex);
                                }
                            }
                        }
                        valueToApply = convertForProperty(
                                propertyName, oldValue, originalValue, ph.toTypeDescriptor());
                    }
                    pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
                }
                // 設置屬性值
                ph.setValue(this.wrappedObject, valueToApply);
            } catch (TypeMismatchException ex) {
                throw ex;
            } catch (InvocationTargetException ex) {
                PropertyChangeEvent propertyChangeEvent =
                        new PropertyChangeEvent(this.rootObject, this.nestedPath + propertyName, oldValue, pv.getValue());
                if (ex.getTargetException() instanceof ClassCastException) {
                    throw new TypeMismatchException(propertyChangeEvent, ph.getPropertyType(), ex.getTargetException());
                } else {
                    Throwable cause = ex.getTargetException();
                    if (cause instanceof UndeclaredThrowableException) {
                        cause = cause.getCause();
                    }
                    throw new MethodInvocationException(propertyChangeEvent, cause);
                }
            } catch (Exception ex) {
                PropertyChangeEvent pce =
                        new PropertyChangeEvent(this.rootObject, this.nestedPath + propertyName, oldValue, pv.getValue());
                throw new MethodInvocationException(pce, ex);
            }
        }
    }

從setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv)把屬性的設置分爲兩種情況，一種情況是爲屬性類型爲數組、List或者Map的屬性添加或修改元素，這種情況必須提供屬性的getter和setter方法；另一種情況是爲當前bean設置屬性值，這種情況必須提供屬性的setter方法。在這個方法中，還會對那些沒有進行類型轉換的做類型轉換處理以獲得屬性或者元素的真實值。

總結

（1）被@Autowired、@Value和@Inject註解的屬性或者方法會在AutowiredAnnotationBeanPostProcessor後處理器的postProcessPropertyValues方法中被處理，在這個時候，屬性會被設置，方法會被執行。

（2）自動裝配模式爲by name和by type的，屬性的設置和xml配置的屬性的設置在同一處被處理，也就是從applyPropertyValues方法開始到完成屬性設置。

（3）在設置屬性之前，必須獲得屬性的真實類型值。這時會先處理Spring的EL表達式，然後再做類型轉換。

（4）對於數組、List和Map對象的元素，可以通過“p[key or index]”的格式設置，其中p表示bean的屬性名稱，“[]”中的key表示Map對象的鍵名，index表示數組和List對象的索引，索引的大小不受數組和List的長度限制，如下的配置。但是這種方式的配置要求bean必須提供對應的getter和setter方法。

    <bean id="author" class="com.chyohn.Author">
        <property name="books[0]">
            <bean class="com.chyohn.Book">
                <property name="name" value="Spring4.x 源碼解讀"/>
            </bean>
        </property>
    </bean>

這個配置就是創建一個Author對象，他的第一本書叫《Spring4.x 源碼解讀》。

（5）bean的屬性也支持級聯配置，格式爲“p.sp.ssp…..”。這樣說比較抽象，舉個例子，上面的xml配置改成如下。結果和上面的配置時一樣的。

    <bean id="author" class="com.chyohn.Author">
        <property name="books[0]">
            <bean class="com.chyohn.Book" />
        </property>
        <property name="books[0].name" value="Spring4.x 源碼解讀"/>
    </bean>