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>