spring源码之bean加载（bean解析下篇）

FactoryBean
    |-- T getObject(); // 
    |-- Class<?> getObjectType();
    |-- boolean isSingleton();
CarFactoryBean implements FactoryBean<Car> {
    Car getObject() {
        Car car = new Car();
        String[] infos = carInfo.split(",");
        car.setBrand(infos[0]);
        car.setMaxSpeed(Integer.valueOf(infos[1]));
        car.setPrice(Double.valueOf(infos[2]));
        return car;
    }
    
    String carInfo;
    // setter、getter方法
    isSingleton() {
        return false;
    }
}
<!-- srping-bean.xml -->
<bean id="car" class="com.test.CarFactoryBean" carInfo="跑车,400,2000"/>
代码实现：
    getBean("car") -> spring发现CarFactoryBean implements FactoryBean接口，容器调用接口方法CarFactoryBean#getObject()返回
    getBean("&car") -> CarFactoryBean

Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}
Object getSingleton(beanName, allowEarlyReference) {
    // 检查缓存是否存在
    Object singletonObject = this.singletonObjects.get(beanName);
    if (null == getSingleton) {
        synchronized(this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                // 当某些方法需要提前初始化的时候会调用addSingletonFactory方法将对应的ObjectFactory初始化策略存储在singletongFactories
                ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 调用预先设定的getObject方法
                    singletonObject = singletonFactory.getObject();
                    // 记录在缓存中，earlySingletonObjects与singletonFactories互斥
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject != NULL_OBJECT ? singletonObject : null;
}

(1) 对FactoryBean做正确性的验证
(2) 对非FactoryBean不做任务处理
(3) 对bean进行转换
(4) 将从Factory中解析bean的工作委托给getObjectFromFactoryBean

getObjectForBeanInstance(beanInstance, name, beanName, mbd) {
    // &testBeanFactory
    if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
        throw e;
    }
    // &testBeanFactory
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
        return beanInstance;
    }
    // 加载factoryBean
    Object object = null;
    if (mbd == null) {
        // 尝试从缓存中加载bean
        object = getCachedObjectForFactoryBean(beanName);
    }
    if (object == null) {
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        if (mbd == null && containsBeanDefinition(beanName)) {
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        // 是否是用户定义的而不是应用程序本身定义的
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
}
getObjectFromFactoryBean(factory, beanName, shouldPostProcess) {
    // 如果是单例
    if (factory.isSingleton() && containsSingleton(beanName)) {
        synchronized(getSingletonMutex()) {
            Object object = this.factoryBeanObjectCache.get(beanName);
            if (object == null) {
                object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
                this.factoryBeanObjectCache.put(beanName, object);
            }
            return object;
        }
    } else {
        return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
    }
}
doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess) {
    Object object = null;
    try {
        if (System.getSecurityManager() != null) { // 权限验证
            try {
                Object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>(){
                    run() {
                        return factory.getObject();
                    }
                });
            } catch (e) {
                throw e;
            }
        } else {
            object = factory.getObject();
        }
    } catch (e) {
        throw e;
    }
    if (object != null && shouldPostProcess) {
        try {
            object = postProcessObjectFromFactoryBean(object, beanName);
        } catch (e) {
            throw e;
        }
    }
    return object;
}
postProcessObjectFromFactoryBean(object, beanName) {
    return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {
    Object result = existingBean;
    for (BeanPostProcessor beanPostProcessor : getBeanPostProcessors()) {
        result = beanPostProcessor.postProcessorsAfterInitialization(result, beanName);
        return result;
    }
    return result;
}

(1) 检查缓存是否已经加载过
(2) 若没有加载，则记录beanName的正在加载状态
(3) 加载单例前记录加载状态
(4) 通过调用参数传入的ObjectFactory的个体Object实例化bean
(5) 加载单例后的处理方法调用
(6) 将结果记录到缴存并删除加载bean过程中所记录的各种辅助状态
(7) 返回处理结果
getSingleton(beanName, new ObjectFactory) {
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            beforeSingletonCreation(beanName);
            try {
                singletonObject = singletonFactory.getObject();
            } catch (e) {
                throw e;
            } finally {
                afterSingletonCreation(beanName);
            }
            // 加入缓存
            addSingleton(beanName, singletonObject);
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null)
}
beforeSingletonCreation(beanName) {
    if (!this.singletonsCurrentlyCreation.add(beanName)) { // 将当前正要创建的bean记录在缓存中，这样便可以对循环依赖进行检测
        throw e;
    }
}
afterSingletonCreation(beanName) {
    if (!this.singletonsCurrentlyCreation.remove(beanName)) { // 加载结束后，移除缓存中对该bean正在加载状态的记录
        throw e;
    }
}
addSingleton(beanName, singletonObject) {
    synchronized (this.singletonObjects) {
        // 将结果记录到缓存，并删除加载bean过程中所记录的辅助状态
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFatories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}
getSingleton(beanName, new ObjectFactory<Object>(){
    public Object getObject() {
        try {
            return createBean(beanName, mbd, args);
        } catch (e) {
            throw e;
        }
    }
});

(1) 根据设置的class属性，或者根据className来解析class
(2) 对override属性进行标记及验证
(3) 应用初始化前的后处理器，解析指定bean是否存在初始化前的短路操作
(4) 创建bean
createBean(beanName, mbd, args) {
    // 根据设置的class属性，或者根据className来解析class
    resolveBeanClass(mbd, beanName);
    
    // 对override属性进行标记及验证
    try {
        mbd.prepareMethodOverrides();
    } catch (e) {
        throw e;
    }
    // 给BeanPostProcessors一个机会返回代理来替代真正的实例
    Object bean = resolveBeforeInstantiation(beanName, mbd);
    if (bean != null) {
        return bean;
    }
    // 创建bean
    Object beanInstance = doCreateBean(beanName, mbd, args);
    return beanInstance;
}

prepareMethodOverrides() {
    MethodOverrides methodOverrides = getMethodOverrides();
    for (MethodOverride mo : MethodOverrides) {
        prepareMethodOverride(mo);
    }
}
// lookup-method、replace-method属性
prepareMethodOverride(mo) {
    // 获取对应类中对应方法名的个数
    int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
    if (count == 0) {
        throw e;
    } else if (count == 1) {
        // 标记未被覆盖，避免参数类型检查的开销
        mo.setOverloaded(false);
    }
}
|-- 实例化前置处理
resolveBeforeInstantiation(beanName, mbd) {
    Object bean = null;
    try {
        bean = applyBeanPostProcessorsBeforeInitialization(mbd.getBeanClass(), beanName);
        if (bean != null) {
            bean = applyBeanPostProcessorsAfterInitialization(mbd.getBeanClass(), beanName);
        }
        mbd.beforeInstantiationResolved = (bean != null);
    } catch (e) {
        throw e;
    }
    return bean;
}
|-- 实例化前的处理器应用
applyBeanPostProcessorsBeforeInitialization(beanClass, beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
            Object result = ibp.postProcessorsBeforeInitialization(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }
    }
    return null;
}
|-- 实例化后的处理器应用
applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {
    
    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        Object result = beanProcessor.postProcessorsAfterInitialization(result, beanName);
        if (result != null) {
            return result;
        }
    }
    return result;
}

(1) 循环依赖定义：
    循环依赖就是循环引用，就是存在2个或多个bean相互之间的持有对方，如：A->B->C->A，A->B->A
(2) 循环依赖的类型：
    构造器循环依赖、setter循环依赖
5.6.1 构造器循环依赖处理
    TestA、TestB、TestC
    TestA -> 查找“当前创建bean池”，如果没发现则继续准备构造器参数“testB”，并将“testA”标识符放到“当前创建bean池”
    TestB -> 查找“当前创建bean池”，如果没发现则继续准备构造器参数“testC”，并将“testB”标识符放到“当前创建bean池”
    TestC -> 查找“当前创建bean池”，如果没发现则继续准备构造器参数“testA”，并将“testC”标识符放到“当前创建bean池”
    准备构造器参数“testA”时，发现该 bean的标识符在“当前创建bean池”存在，抛出BeanCurrentlyInCreationException。
    
5.6.2 setter循环依赖处理
    TestA、TestB、TestC
    TestA -> 暴露ObjectFactory工厂，并将“testA”标识符放到“当前创建bean池”，然后进行setter注入“testB”
    TestB -> 暴露ObjectFactory工厂，并将“testB”标识符放到“当前创建bean池”，然后进行setter注入“testC”
    TestC -> 暴露ObjectFactory工厂，并将“testC”标识符放到“当前创建bean池”，然后进行setter注入“testA”，进入注入“TestA”时由于提前暴露了“ObjectFactory”工厂，从而使用它返回提前暴露一个创建中的bean。
    最后依赖注入"TestB"、"TestA"，完成setter注入。
    
5.6.3 prototype范围的依赖处理
    scope="prototpye" -> 由于prototpye作用域无法完成依赖注入，spring容器不进行缓存prototype作用域的bean，因此无法提前暴露一个创建中的bean。
    scope="singleton" -> setAllowCircularReferences(false); // 禁用循环引用

(1) 如果是单例则需要首先清除缓存
(2) 实例化bean，将BeanDefinition转换为BeanWrapper
(3) MergedBeanDefinitionPostProccessor的应用
(4) 依赖处理
(5) 属性填充
(6) 循环依赖检查
(7) 注册DisposableBean
(8) 完成创建并返回
protected Object doCreateBean(final String beanName, final RooBeanDefinition mbd, final Object[] args) {
    BeanWrapper instanceWrapper = null;
    // 如果是单例则需要首先清除缓存
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanObjectCache.remove(beanName);
    }
    // 实例化bean，将BeanDefinition转换为BeanWrapper
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    // MergedBeanDefinitionPostProccessor的应用
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            applyMergedBeanDefinitionPostProccessor(mbd, beanType, beanName);
        }
    }
    // 依赖处理
    // 是否需要提前暴露（单例&循环引用&当前bean正在创建中）
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletongCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // 为避免循环依赖，在bean初始化完成前将创建实例的ObjectFactory加入工厂
        addSingletonFactory(beanName, new ObjectFactory(){
            public Object getObject() throw e {
                // 对bean的再一次依赖引用
                return getEarlyBeanReferences(beanName, mbd, bean);
            }
        });
    }
    
    Object exposedObject = bean;
    // 属性填充
    try {
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
            // 调用初始化方法，init-method
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
    } catch (e) {
        throw e;
    }
    
    // 循环依赖检查
    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            // exposedObject没有在初始化方法改变，说明没有被增强
            if (exposedObject == null) {
                exposedObject = earlySingletonReference;
            } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<String>();
                for (String dependentBean : dependentBean) {
                    // 检测依赖
                    if (!removeSingletonIfCreateForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                if (!actualDependentBeans.isEmpty()) {
                    throw e; 
                }
            }
        }
    }
    
    // 注册DisposableBean
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    } catch (e) {
        throw e;
    }
    return exposedObject;
}

(1) InstantiationAwareBeanPostProcessor处理器的postProcessAfterInstantiation函数的应用，此函数可以控制程序是否继续进行属性填充
(2) 根据类型，提取依赖bean，并统一存入PropertyValues中。
(3) 应用InstantiationAwareBeanPostProcessor处理器的postProcessPropertyValues方法，对属性获取完毕填充前对属性的再次处理，RequiredAnnotationBeanPostProcessor对属性的验证
(4) 将所有PropertyValues中的属性填充至BeanWrapper中
populateBean(beanName, mbd, bw) {
    PropertyValues pvs = mbd.getPropertyValues();
    if (bw == null) {
        if (!pvs.isEmpty()) {
            throw e;
        } else {
            // 没有属性填充
            return ;
        }
    }
    
    boolean continueWithPropertyPopulation = true;
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            // 返回值是否继续填充bean
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                continueWithPropertyPopulation = false;
                break;
            }
        }
    }
    // 如果后处理器发出停止填充命令则终止后续的执行
    if (!continueWithPropertyPopulation) {
        return;
    }
    
    if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_NAME || 
            mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
        pvs = newPvs;
    }
    
    // 后处理器已经初始化
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    // 需要检查依赖
    boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
    if (hasInstAwareBpps || needsDepCheck) {
        PropertyDescriptor[] filteredPds = filterPropertyDescriptionsForDependencyCheck(bw);
        if (hasInstAwareBpps) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // 对所有需要依赖检查的属性进行后处理
                pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                if (pvs == null) {
                    return;
                }
            }
        } 
        if (needsDepCheck) {
            checkDependences(beanName, mbd, filteredPds, pvs);
        }
    }
    // 将属性应用到bean中
    applyPropertyValues(beanName, mbd, bw, pvs);
}
// 根据name注入属性
autowireByName(beanName, mbd, bw, newPvs) {
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    for (String propertyName : propertyNames) {
        if (containsBean(propertyName)) {
            // 递归初始化相关的bean
            Object bean = getBean(propertyName);
            pvs.add(propertyName, bean);
            // 注册依赖
            registerDependentBean(propertyName, beanName);
        } else {
            if (logger.isTraceEnabled()) {
                logger.trace(...);
            }
        }
    }
}
// 根据type注入属性
autowireByType(beanName, mbd, BeanWrapper bw, newPvs) {
    try {
        TypeConverter converter = getCustomTypeConverter();
        if (converter == null) {
            converter = bw;
        }
        
        Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
        // 寻找bw中需要依赖注入的属性
        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        for (String propertyName : propertyNames) {
            PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
            if (!Object.calss.equals(pd.getProperType())) {
                // 探测指定的set方法
                MethodParamter methodParam = BeanUtils.getWriteMethodParamter(pd);
                boolean eager = PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());
                PropertyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                
                // 解析指定的属性所匹配的值，并把解析到的属性的名称存储在autowiredBeanNames中，当属性存在多个封装bean时：
                // @Autowired private List<A> aList; 将会找到所有匹配A类型的bean将其注入
                Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                if (autowiredArgument != null) {
                    pvs.add(propertyName, autowiredArgument);
                }
                for (String autowiredBeanName : autowiredBeanNames) {
                    // 注册依赖
                    registerBeanDefinition(autowiredBeanName, beanName);
                }
                autowiredBeanNames.clear();
            }
        }
    } catch (e) {
        throw e;
    }
}
resolveDependency(descriptor, beanName, Set<String> autowiredBeanNames, typeConverter) {
    descriptor.initParamterNameDisconvery(getParamterNameDisconverer());
    // ObjectFactory类注入的特殊处理
    if (descriptor.getDependencyType().equals(ObjectFactory.class)) {
        return new DependencyObjectFactory(descriptor, beanName);
    }
    else if (... eq javaxInjectProviderClass) {
        return new DependencyObjectFactory().createDependencyProvider(descriptor, beanName);
    }
    else {
        // 通用逻辑处理
        return doResolvedDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter);
    }
}
doResolvedDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter) {
    // 用于支持spring中新增的注解@value
    Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
    if (value != null) {
        if (value instanceof String) {
            value = evaluateBeanDefinitionString(strVal, bd);
        }
        TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
        return converter.convertIfNecessary(value, type);
    }
    
    // 属性是数组类型
    if (type.isArray()) { 
        // 数组类型
        Class<?> componentType = type.getComponentType();
        Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);
        if (matchingBeans.isEmpty()) {
            if (descriptor.isRequired()) {
                raiseNoSuchBeanDefinitionException(componentType, componentType.getName(), descriptor);
            }
            return null;
        }
        if (autowiredBeanNames != null) {
            autowiredBeanNames.addAll(matchingBeans.keySet());
        }
        TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
        return converter.convertIfNecessary(matchingBeans.values(), type);
    }
    else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
        // 集合类型
        Class<?> elementType = descriptor.getCollectionType();
        if (elementType == null) {
            if (descriptor.isRequired()) {
                throw e;
            }
            return null;
        }
        Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);
        if (matchingBeans.isEmpty()) {
            throw e;
        }
        if (autowiredBeanNames != null) {
            autowiredBeanNames.addAll(matchingBeans.keySet());
        }
        TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
        return converter.convertIfNecessary(matchingBeans.values(), type);
    } 
    else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
        // Map类型
        Class<?> keyType = descriptor.getMapKeyType();
        if (keyType == null) {
            if (descriptor.isRequired()) {
                throw e;
            }
            return null;
        }
        Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);
        if (matchingBeans.isEmpty()) {
            throw e;
        }
        if (autowiredBeanNames != null) {
            autowiredBeanNames.addAll(matchingBeans.keySet());
        }
        TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
        return converter.convertIfNecessary(matchingBeans.values(), type);
    }
    else {
        Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);
        if (matchingBeans.isEmpty()) {
            throw e;
        }
        if (matchingBeans.size() > 1) {
            String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor);
            if (primaryBeanName == null) {
                throw e;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.add(primaryBeanName);
            }
            return matchingBeans.get(primaryBeanName);
        }
        // 已经可以确定只有一个匹配项
        Map.Entry<String,Object> entry = matchingBeans.entrySet().iterator().next();
        if (autowiredBeanNames != null) {
            autowiredBeanNames.add(entry.getKey());
        }
        return entry.getValue();
    }
}
// 将属性应用到bean中
applyPropertyValues(beanName, mbd, bw, pvs) {
    if (pvs == null || pvs.isEmpty()) {
        return;
    }
    
    MutablePropertyValues mpvs = null;
    List<PropertyValue> original;
    if (bw instancof BeanWrapperImpl) {
        ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
    }
    if (pvs instanceof MutablePropertyValues) {
        mpvs = (MutablePropertyValues) pvs;
        // 如果mpvs中的值已经被转换为对应的类型那么可以直接设置到beanWrapper中
        try {
            if (mpvs.isConverted()) {
                bw.setPropertyValues(mpvs);
                return;
            }
        } catch (e) {
            throw e;
        }
        original = mpvs.getPropertyValueList();
    } else {
        // 非MutablePropertyValues封装的类型，那么直接使用原始的属性获取方法
        original = Arrays.asList(pvs.getPropertyValues());
    }
    
    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }
    // 获取对应的解析器
    BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
    // Create a deep copy, resolving any references for values.
    List<PropertyValue> deepCopy = new ArrayList<String>(original.size());
    boolean resolveNecessary = false;
    for (PropertyValue pv : original) {
        if (pv.isConverted()) {
            deepCopy.add(pv);
        } else {
            String propertyName = pd.getName();
            Object originalValue = pd.getValue();
            Object resolvedValue = valueResolver.resolveValueIfNecessay(pv, originalValue);
            
            Object convertedValue = resolvedValue;
            boolean convertible = (bw.isWritableProperty(propertyName) && !PropertyUtils.isNestedIndexedProperty(propertyName));
            if (convertible) {
                convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
            }
            if (convertedValue == originalValue) {
                if (convertible) {
                    pv.setConvertedValue(convertedValue);
                }
                deepCopy.add(pv);
            }
            else if (convertible && originalValue instanceof TypedStringValue && 
                !((TypedStringValue) originalValue).isDynamic() &&
                !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))){
                pv.setConvertedValue(convertedValue);
                deepCopy.add(pv);
            }
            else {
                resolveNecessary = true;
                deepCopy.add(new PropertyValue(pv, convertedValue));
            }
        }
    }
    if (mpvs != null && !resolveNecessary) {
        mpvs.setConverted();
    }
    try {
        bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    } catch (e) {
        throw e;
    }
}

// spring容器已经执行过bean的实例化，并且进行了属性填充，而就是这时将会调用用户设定的初始化方法
initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    if (System.getSecurityMananger() != null) {
        AccessController.doPrivileged(new PrivilegedAction<Object>(){
            Object run() {
                invokeAwareMethods(beanName, bean);
                return null;
            }
        });
    } else {
        // 对特殊的bean处理：Aware、BeanClassLoaderAware、BeanFactoryAware
        invokeAwareMethods(beanName, bean);
    }
    
    Object wrappedBean = bean;
    if (mbd != null || !mbd.isSynthetic()) {
        // 应用前处理器
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    try {
        // 激活用户自定义的init方法
        invokeInitMethod(beanName, wrappedBean, mbd);
    } catch (e) {
        throw e;
    }
    if (mbd != null || !mbd.isSynthetic()) {
        // 后处理器应用
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}
invokeAwareMethods(final String beanName, final Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}
// 处理器应用
applyBeanPostProcessorsBeforeInitialization(existingBean, beanName) {
    Object result = existingBean;
    for ( BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessBeforeInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}
applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {
    Object result = existingBean;
    for ( BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}
// 激活用户自定义的init方法
invokeInitMethod(beanName, bean, mbd) {
    // 检查是否是InitializingBean，如果是则调用afterPropertiesSet方法
    boolean isInitializingBean = (bean istanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
    
        if (System.getSecurityManager() != null) {
            try {
                AccessController.doPrivileged(new PrivilegedExceptionAction<Object>(){
                    Object run() {
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }
                });
            } catch (e) {
                throw e;
            }
        } else {
            ((InitializingBean) bean).afterPropertiesSet();
        }
    }
    if (mbd != null) {
        String initMethodName = mbd.getInitMethodName();
        if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName))
            && !mbd.isExternallyManagedInitMethod(initMethodName)) {
            // 调用自定义初始化方法
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
    if (!mbd.isPrototype() && requiredDestruction(bean, mbd)) {
        if (mbd.isSingleton()) {
            // 单例模式下需要注册需要销毁的bean，此方法中会处理实现DisposableBean的bean，
            // 并且对所有的bean使用DestrunctionAwareBeanPostProccessors处理
            // DisposableBean DestrunctionAwareBeanPostProccessors
            registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
        } else {
            scope scope = this.scopes.get(mgd.getScope());
            if (scope == null) {
                throw e;
            }
            scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
        }
    }
}