0003 - 基于xml的Spring Bean 的创建过程

一、目录

1. 前言
2. 创建 Bean 容器
3. 加载 Bean 定义
4. 创建 Bean
5. Spring Bean 创建过程中的设计模式
6. 总结

二、前言

2.1 Spring 使用配置

    ApplicationContext context = new ClassPathXmlApplicationContext("spring-config-ioc.xml");
    UserService userService = context.getBean("userService",UserService.class);
    userService.sayHello("zhangsan"); 

而在 spring-config-ioc.xml 中只是简单的定义了 userService Bean：

    <bean id="userService" class="com.jd.spring.service.ioc.impl.UserServiceImpl">
    </bean> 

Spring 使用的版本为 3.2.6.RELEASE，下面我们通过源码一步步来了解下 Bean 的创建过程。

三、创建 Bean 容器

Spring 容器包括两类：BeanFactroy 和 ApplicationContext，ApplicationContext 扩展自 BeanFactory，在之上又增加了一些扩展功能，下面我们以 ClassPathXmlApplicationContext 为例来看下容器的创建过程。

    public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)throws BeansException { super(parent); setConfigLocations(configLocations); if (refresh) { //在此进行容器的创建，Bean的加载，创建 refresh(); } } 

refresh 实现步骤如下：

1.prepareRefresh

主要用来验证一些需要的系统变量。

2.obtainFreshBeanFactory

创建 BeanFactory，然后加载 Bean 定义

    protected final void refreshBeanFactory() throws BeansException { //判断beanFactory是否为null if (hasBeanFactory()) { //如果之前已经创建了BeanFactory，调用Bean的destroySingletons方法 destroyBeans(); //将beanFactory设置为null closeBeanFactory(); } try { //创建的容器类为DefaultListableBeanFactory DefaultListableBeanFactory beanFactory = createBeanFactory(); beanFactory.setSerializationId(getId()); //设置是否允许override,循环引用，QualifierAnnotationAutowireCandidateResolver customizeBeanFactory(beanFactory); //加载Bean定义 loadBeanDefinitions(beanFactory); synchronized (this.beanFactoryMonitor) { this.beanFactory = beanFactory; } } } 

此时可以看到创建的 BeanFactory 为 DefaultListableBeanFactory，通过源码我们可以看到 BeanFactory 和 ApplicationContext 类关系图如下：

3.prepareBeanFactory

添加对 spel 的支持，默认的属性编辑器，同时设置忽略依赖的接口

    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); beanFactory.ignoreDependencyInterface(EnvironmentAware.class); 

4.postProcessBeanFactory

5.invokeBeanFactoryPostProcessors

Bean 容器创建后执行，执行 BeanFactoryPostProcessor 接口的 postProcessBeanFactory 方法。

6.registerBeanPostProcessors

注册 BeanPostProcessor，Bean 创建后执行。BeanPostProcessor提供 postProcessBeforeInitialization、postProcessAfterInitialization 初始化前、初始化后执行方法。

7.initMessageSource

初始化消息资源（国际化）。

8.initApplicationEventMulticaster

注册了 SimpleApplicationEventMulticaster 广播器。

9.onRefresh

初始化一些特殊的 Bean，留给子类来实现。

10.registerListeners

注册事件监听。

11.finishBeanFactoryInitialization

实例化所有单例非延迟加载 Bean，beanFactory.preInstantiateSingletons();

12.finishRefresh

    // Initialize lifecycle processor for this context.
    initLifecycleProcessor();

    // Propagate refresh to lifecycle processor first.
    getLifecycleProcessor().onRefresh();

    // Publish the final event.
    publishEvent(new ContextRefreshedEvent(this)); // Participate in LiveBeansView MBean, if active. LiveBeansView.registerApplicationContext(this); 

四、加载 Bean 定义

入口为 AbstractXmlApplicationContext.loadBeanDefinitions 方法，通过 XmlBeanDefinitionReader 来加载 BeanDefinitions。

4.1 获取资源文件

    Resource[] resources = ((ResourcePatternResolver)
    resourceLoader).getResources(location);

获取资源文件分为如下几种情况：

• 如果 locationPattern 是 classpath*:spring-config-ioc.xml 这种格式的话，那么最终通过 getClassLoader().getResources(path) 来获取资源文件；
• 如果 locationPattern 是 classpath:spring-config-ioc.xml 这种格式的话，new ClassPathResource(location.substring(CLASSPATHURLPREFIX.length()), getClassLoader())；
• 如果 locationPattern 是 spring-config-ioc.xml 这种格式的话

        try {
            // Try to parse the location as a URL...
            URL url = new URL(location);
            return new UrlResource(url); } catch (MalformedURLException ex) { // No URL -> resolve as resource path. return getResourceByPath(location); } 

最终返回 new ClassPathContextResource(path, getClassLoader())。

4.2 加载 Bean 定义

加载 Bean 定义的入口为 XmlBeanDefinitionReader.loadBeanDefinitions，核心方法如下：

    Document doc = this.documentLoader.loadDocument(
                    inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());
            return registerBeanDefinitions(doc, resource);

首先通过 documentLoader 获取到 xml 文件对应的 Document 对象，然后再解析 Document 对象，最终注册 registerBeanDefinitions。这里面的方法调用层级比较多，但是都相对比较简单，我就不一一列出了，我只列出一些核心，关键的代码，其它代码大家可以自己跟下。

在解析的时候 Spring 会留有解析前处理，解析后处理方法，供子类实现。

    //创建Bean解析的代理类，同时解析出在beans中定义的default属性，如default-lazy-init="default"
    //default-autowire="default" this.delegate = createDelegate(this.readerContext, root, parent); preProcessXml(root); parseBeanDefinitions(root, this.delegate); postProcessXml(root); 

解析 BeanDefinitions：

    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { if (delegate.isDefaultNamespace(root)) { NodeList nl = root.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element) { Element ele = (Element) node; if (delegate.isDefaultNamespace(ele)) { //解析默认标签元素 parseDefaultElement(ele, delegate); } else { delegate.parseCustomElement(ele); } } } } else { //解析自定义标签 delegate.parseCustomElement(root); } } 

如果节点元素的 namespaceURI 为http://www.springframework.org/schema/beans，那么认为是默认元素，否则认为是自定义元素。自定义元素通过 NameSpaceHandler 类类处理，不同的标签有不同的处理类。

默认元素主要包括如下 4 种：

• import：解析 import 元素，然后加载 resource 指定的配置文件，过程同上
• alias：解析别名
• Bean：解析Bean，下面重点讲解
• Beans：解析Beans，循环解析Beans下的元素，过程同上

解析 Bean 定义过程如下：

    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try { //将BeanDefinition注册到BeanFactory BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); } catch (BeanDefinitionStoreException ex) { getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex); } //注册完成后发送事件通知 getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); } 

解析过程主要包括 3 部分：解析 Bean 定义，然后注册到 BeanFactory，最后发送注册完成通知。

4.2 解析 Bean 定义

    String id = ele.getAttribute(ID_ATTRIBUTE);
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    String[] aliasesArray = StringUtils.toStringArray(aliases);
    return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray); 

parseBeanDefinitionElement 过程如下：

    className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    AbstractBeanDefinition bd = createBeanDefinition(className, parent);
    parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

    parseMetaElements(ele, bd);
    parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
    parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

    parseConstructorArgElements(ele, bd);
    parsePropertyElements(ele, bd);
    parseQualifierElements(ele, bd);

1.创建 BeanDefinition 对象

创建 GenericBeanDefinition 对象。

2.解析 BeanDefinition 属性

解析 scope、singleton、abstract、lazy-init、autowire、dependency-check、depends-on、autowire-candidate、primary、init-method、destroy-method、factory-method、factory-bean 属性。scope、singleton 不能同时存在。

3.解析 Meta 元素

解析 bean 下的 meta 元素，如

    <meta key="name" value="zhangsan"/>

通过 BeanDefinition.getAttribute 获取属性值。

4.解析 LookupOverride 子元素

解析 lookup 子元素并注册到 BeanDefinitions，BeanDefinition 持有 MethodOverrides 引用：

    private MethodOverrides methodOverrides = new MethodOverrides();

    MethodOverrides:
    private final Set<MethodOverride> overrides = new HashSet<MethodOverride>(0); 

5.解析 ReplacedMethod 子元素

解析 replace 子元素并注册到 BeanDefinitions。

6.解析构造器元素

解析构造器元素 constructor-arg。

7.解析属性元素

解析 property 属性，属性值：

    Object val = parsePropertyValue(ele, bd, propertyName);
    PropertyValue pv = new PropertyValue(propertyName, val);
    parseMetaElements(ele, pv);
    pv.setSource(extractSource(ele));
    bd.getPropertyValues().addPropertyValue(pv);

属性 name 的解析相对简单，属性 value 的解析比较复杂，涉及到 ref、value，还有可能是子元素 array、list、set、map、props，这里就不展开说明了，感兴趣的可以自己看下。

8.解析 Qualifier 元素

解析 Qualifier 元素。

4.3 注册 Bean 定义

通过 BeanDefinitionRegistry 来注册 BeanDefinition，最终是将 BeanDefinition 保存在 BeanFactory 中，

    this.beanDefinitionMap.put(beanName, beanDefinition);

BeanFactory持有beanDefinitionMap引用：

    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64); 

4.4 发送通知

bean 注册完成后，发送通知，Listener 需要实现 ReaderEventListener 接口，

    public void fireComponentRegistered(ComponentDefinition componentDefinition) { this.eventListener.componentRegistered(componentDefinition); } 

五、创建 Bean

在创建 ApplicationContext 时会默认初始化所有非懒加载的单例 bean（BeanFactory 容器的话是在 getBean 时创建 bean 对象）。创建 bean 的入口为 AbstractBeanFactory.getBean 方法，核心代码如下：

        // Eagerly check singleton cache for manually registered singletons.
        Object sharedInstance = getSingleton(beanName);

首先从"缓存"中查找 bean 是否已经创建，如果创建的话直接返回创建的 bean，否则执行创建 bean 的逻辑。如果 scope 配置为 prototype，那么每次 getBean 时都会创建 bean。

1.getSingleton

从缓存中获取 bean，此处很关键，用来解决 Spring 循环依赖问题。

    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { synchronized (this.singletonObjects) { singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null && allowEarlyReference) { ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { singletonObject = singletonFactory.getObject(); this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } return (singletonObject != NULL_OBJECT ? singletonObject : null); } 

首先从 singletonObjects 中获取对象，如果 singletonObjects 不存在的话那么从 earlySingletonObjects 中获取对象，earlySingletonObjects 存放的是创建中的对象（bean 已创建，但是还未初始化完成），singletonFactories 存放的是 bean 和 ObjectFactory 的关系，在 bean 创建完成后会保存 bean 和 ObjectFactory 的关系。singletonFactories 和 earlySingletonObjects 互斥。

2.合并 BeanDefinition

3.创建 bean dependsOn 依赖的 beans

如果我们配置了 bean 标签的 depends-on 属性，那么在创建 bean 前会首先创建依赖的 beans。

4.创建单例对象

    resolveBeanClass(mbd, beanName);

    mbd.prepareMethodOverrides();

    // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    Object bean = resolveBeforeInstantiation(beanName, mbd);
    if (bean != null) {
        return bean; } Object beanInstance = doCreateBean(beanName, mbd, args); 

• resolveBeforeInstantiation

在 bean 实例化前、后执行，可以更改 bean 的实例化对象，如配置：

    <bean class="com.jd.spring.processor.MyInstantiationAwareBeanPostProcessor"/>

MyInstantiationAwareBeanPostProcessor类实现InstantiationAwareBeanPostProcessor，然后重写postProcessBeforeInstantiation方法：


    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException { if (beanName != null && beanName.equals("helloWorldService")) { return new HelloWorldServiceProxy(); } return null; } 

这样的话 helloWorldService 对应的 bean 为 HelloWorldServiceProxy。

• doCreateBean

创建 bean 的实现方法，下面我们通过单独的章节来重点说明。

5.创建原型对象

    try {
            beforePrototypeCreation(beanName);
            prototypeInstance = createBean(beanName, mbd, args);
        }
    finally {
            afterPrototypeCreation(beanName);
    }
    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);


getObjectForBeanInstance，如果创建的bean为FactoryBean，调用FactoryBean.getObject方法生成最终的bean。

5.1 doCreateBean

方法入口为 AbstractAutowireCapableBeanFactory.doCreateBean，doCreateBean 核心方法如下：

    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null); Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null); // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); mbd.postProcessed = true; } } addSingletonFactory(beanName, new ObjectFactory<Object>() { public Object getObject() throws BeansException { return getEarlyBeanReference(beanName, mbd, bean); } }); populateBean(beanName, mbd, instanceWrapper); if (exposedObject != null) { exposedObject = initializeBean(beanName, exposedObject, mbd); } 

5.1.1 createBeanInstance

创建 bean 实例，其本质是通过反射调用默认或有参的构造方法来创建 bean 实例，下面我们来看下具体的实现细节。

    //获取beanClass，通过Class.forName来获取
    Class<?> beanClass = resolveBeanClass(mbd, beanName);

    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName()); } //如果配置了factory-method，那么通过工厂方法来创建bean，这个稍后分析下 if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); } // 获取构造器，可能通过默认构造器来创建bean，也可能通过有参构造器来创建bean Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { return autowireConstructor(beanName, mbd, ctors, args); } // No special handling: simply use no-arg constructor. return instantiateBean(beanName, mbd); 

instantiateUsingFactoryMethod

通过工厂方法来创建，如果我们在定义 bean 时配置了 factory-method 属性，如

   <bean id="userServiceFactory" class="com.jd.spring.service.ioc.impl.UserServiceFactory" ></bean> <bean id="userService" class="com.jd.spring.service.ioc.impl.UserServiceImpl" factory-bean="userServiceFactory" factory-method="getUserService" > <property name="userServiceB" ref="userServiceB"> </property> </bean> 

那么将会通过 userServiceFactory的getUserService 方法来创建 bean，instantiateUsingFactoryMethod 方法实现如下：

    protected BeanWrapper instantiateUsingFactoryMethod(
            String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {

        return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs); } 

核心步骤如下：

1.获取工厂 bean

    String factoryBeanName = mbd.getFactoryBeanName();
    if (factoryBeanName != null) {
        if (factoryBeanName.equals(beanName)) {
            throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName, "factory-bean reference points back to the same bean definition"); } factoryBean = this.beanFactory.getBean(factoryBeanName); if (factoryBean == null) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "factory-bean '" + factoryBeanName + "' returned null"); } factoryClass = factoryBean.getClass(); isStatic = false; } else { // It's a static factory method on the bean class. if (!mbd.hasBeanClass()) { throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName, "bean definition declares neither a bean class nor a factory-bean reference"); } factoryBean = null; factoryClass = mbd.getBeanClass(); isStatic = true; } 

也就是说如果配置了 factory-bean 属性，那么工厂类为配置的 factory-bean，否则工厂类为当前 bean，但是要求工厂方法为静态方法。

2.获取工厂方法

    rawCandidates = (mbd.isNonPublicAccessAllowed() ?
        ReflectionUtils.getAllDeclaredMethods(factoryClazz) : factoryClazz.getMethods());
    List<Method> candidateSet = new ArrayList<Method>();
    for (Method candidate : rawCandidates) {
        if (Modifier.isStatic(candidate.getModifiers()) == isStatic &&
                candidate.getName().equals(mbd.getFactoryMethodName()) &&
                mbd.isFactoryMethod(candidate)) {
            candidateSet.add(candidate); } } Method[] candidates = candidateSet.toArray(new Method[candidateSet.size()]); AutowireUtils.sortFactoryMethods(candidates); 

获取工厂类中的工厂方法，并进行方法排序，因为会存在方法重载的情况，排序规则如下：

    public static void sortFactoryMethods(Method[] factoryMethods) { Arrays.sort(factoryMethods, new Comparator<Method>() { public int compare(Method fm1, Method fm2) { boolean p1 = Modifier.isPublic(fm1.getModifiers()); boolean p2 = Modifier.isPublic(fm2.getModifiers()); if (p1 != p2) { return (p1 ? -1 : 1); } int c1pl = fm1.getParameterTypes().length; int c2pl = fm2.getParameterTypes().length; return (new Integer(c1pl)).compareTo(c2pl) * -1; } }); } 

先按方法修饰符进行排序，public 方法在前，non-public 方法在后；再按照方法参数个数进行排序，方法参数多的在前，少的在后。

然后按照配置的 ConstructorArguments 来匹配工厂方法。

3.反射执行方法创建 bean

beanInstance = beanFactory.getInstantiationStrategy().instantiate(
    mbd, beanName, beanFactory, factoryBean, factoryMethodToUse, argsToUse);

最终通过反射创建 bean，factoryMethod.invoke(factoryBean, args);

autowireConstructor

使用有参的构造方法来创建 bean：

    Class<?> beanClass = mbd.getBeanClass();
    try {
        candidates = (mbd.isNonPublicAccessAllowed() ?
                beanClass.getDeclaredConstructors() : beanClass.getConstructors());
    }
    AutowireUtils.sortConstructors(candidates);

取得 beanClass 下的构造方法，同样进行排序，排序规则也是先按方法修饰符进行排序，public 方法在前，non-public 方法在后；再按照方法参数个数进行排序，方法参数多的在前，少的在后。

然后按照配置的 ConstructorArguments 来匹配构造方法，匹配规则是按照构造方法参数个数和参数类型进行匹配。

    if (explicitArgs == null) {
        argsHolderToUse.storeCache(mbd, constructorToUse);
    }

将匹配到的构造方法进行缓存，防止后续重复计算。找到匹配的构造方法后，然后通过反射创建 bean。

beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
                mbd, beanName, this.beanFactory, constructorToUse, argsToUse);

instantiateBean

使用默认的构造方法来创建 bean，同样也是通过反射创建 bean，代码如下：

beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);

5.1.2 applyMergedBeanDefinitionPostProcessors

5.1.3 addSingletonFactory

如果对象为单例，并且允许提前曝光，并且 bean 正在创建中，那么将 bean 和 ObjectFactory 放入到 singletonFactory 中，此处的作用是用来解决循环依赖的问题。

5.1.4 填充属性

populateBean 核心代码如下：

//获取bean配置下的子元素property
PropertyValues pvs = mbd.getPropertyValues();

//如果指定了自动注入的模式，获取自动注入的属性
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
        mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
    MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

    // Add property values based on autowire by name if applicable. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); } // Add property values based on autowire by type if applicable. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } //设置属性值 applyPropertyValues(beanName, mbd, bw, pvs); 

autowireByName

autowire="byName" 根据名称自动注入，使用自动注入的好处是可以解决<bean> 标签下 <property> 标签过多的问题。

    //查找所有未配置的属性，在bean class中存在，但是未在xml配置文件中配置的属性
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    for (String propertyName : propertyNames) {
        if (containsBean(propertyName)) { Object bean = getBean(propertyName); //获取bean pvs.add(propertyName, bean); registerDependentBean(propertyName, beanName); } } 

autowireByType

autowire="byType" 根据类型自动注入。通过 DefaultListableBeanFactory.doResolveDependency 来获取属性的值，然后同样添加到 pvs，pvs.add(propertyName, bean);

在获取值的时候会根据 type 类型来做相应处理，如Array、Collection、Map，我们以常见的注入 bean 属性为例来看下实现代码：

//根据类型查找候选的bean
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) { if (descriptor.isRequired()) { raiseNoSuchBeanDefinitionException(type, "", descriptor); } return null; } if (matchingBeans.size() > 1) { String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor); //如果根据类型匹配到多个bean，并且没有指定primaryBeanName属性的话那么会抛出类似expected single matching bean but found 2 这样的异常 if (primaryBeanName == null) { throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet()); } if (autowiredBeanNames != null) { autowiredBeanNames.add(primaryBeanName); } return matchingBeans.get(primaryBeanName); } // We have exactly one match. Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next(); if (autowiredBeanNames != null) { autowiredBeanNames.add(entry.getKey()); } return entry.getValue(); 

applyPropertyValues

TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
    converter = bw;
}
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

遍历配置的 property 子元素，然后获取 value/ref 对应的值

String propertyName = pv.getName(); 
Object originalValue = pv.getValue();
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); //获取属性值，可能为字符串，也可能是bean，list，map
Object convertedValue = resolvedValue; boolean convertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName); if (convertible) { convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter); } // Set our (possibly massaged) deep copy. try { //deepCopy为PropertyValue集合，记录了属性名和属性值 bw.setPropertyValues(new MutablePropertyValues(deepCopy)); } 

上面最重要的两步为转换属性的值和设置属性的值，下面我们分别来看下。

• convertForProperty

转换属性的值：

private Object convertForProperty(Object value, String propertyName, BeanWrapper bw, TypeConverter converter) { if (converter instanceof BeanWrapperImpl) { return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName); } else { PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName); MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd); return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam); } } public Object convertForProperty(Object value, String propertyName) throws TypeMismatchException { //获取属性描述符，记录了属性的数据类型，如String,List,Map PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(propertyName); if (pd == null) { throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName, "No property '" + propertyName + "' found"); } return convertForProperty(propertyName, null, value, pd); } 

最终通过 typeConverterDelegate 代理类来执行：

this.typeConverterDelegate.convertIfNecessary(propertyName, oldValue, newValue, requiredType, td); 

转换过程如下：

1.查找是否定义了数据类型对应的自定义属性编辑器PropertyEditor，如果定义了自定义的PropertyEditor，则通过getValue获取值 2.判断是否定义了ConversionService，通过conversionService.convert来转换属性值3.convertToTypedArray

int arrayLength = Array.getLength(input);
Object result = Array.newInstance(componentType, arrayLength);
for (int i = 0; i < arrayLength; i++) {
    Object value = convertIfNecessary( buildIndexedPropertyName(propertyName, i), null, Array.get(input, i), componentType); Array.set(result, i, value); } 

4.convertToTypedCollection

convertedCopy = CollectionFactory.createApproximateCollection(original, original.size());
Object element = it.next();
String indexedPropertyName = buildIndexedPropertyName(propertyName, i);
Object convertedElement = convertIfNecessary(indexedPropertyName, null, element,
        (elementType != null ? elementType.getType() : null) , elementType); try { convertedCopy.add(convertedElement); } 

遍历集合中的元素，然后生成转换后的集合。如果是 List 的话生成 ArrayList，Set 的话如果是排序 Set 的话生成 TreeSet，否则生成 LinkedHashSet

5.convertToTypedMap

//如果map类型为SortedMap，那么创建TreeMap；否则创建LinkedHashMap
convertedCopy = CollectionFactory.createApproximateMap(original, original.size());

while (it.hasNext()) {
    Map.Entry entry = (Map.Entry) it.next();
    Object key = entry.getKey(); Object value = entry.getValue(); String keyedPropertyName = buildKeyedPropertyName(propertyName, key); Object convertedKey = convertIfNecessary(keyedPropertyName, null, key, (keyType != null ? keyType.getType() : null), keyType); Object convertedValue = convertIfNecessary(keyedPropertyName, null, value, (valueType!= null ? valueType.getType() : null), valueType); try { convertedCopy.put(convertedKey, convertedValue); } } 

• setPropertyValues

 //deepCopy为PropertyValue集合，记录了属性名和属性值
 bw.setPropertyValues(new MutablePropertyValues(deepCopy));

final Method writeMethod = (pd instanceof GenericTypeAwarePropertyDescriptor ?
        ((GenericTypeAwarePropertyDescriptor) pd).getWriteMethodForActualAccess() :
        pd.getWriteMethod());
writeMethod.invoke(this.object, value);  

其实现本质就是获取属性对应的 set 方法，然后调用反射进行设置。需要注意情况如下：

1.如果定义了属性，但是未存在相应set方法，则抛出异常

Bean property 'name' is not writable or has an invalid setter method

2.如果属性为List，Map等集合属性，首先通过相应的read方法来获取已有值，然后再合并新的值。

5.1.5 bean 初始化

    invokeAwareMethods(beanName, bean);
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    invokeInitMethods(beanName, wrappedBean, mbd);
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

1.执行 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); } 

2.执行 BeanPostProcessor.postProcessBeforeInitialization

执行 BeanPostProcessor 的初始化前方法，BeanPostProcessor 需要在 xml 中配置，如

    <bean class="com.jd.spring.processor.MyBeanPostPrcessor"/>

3.执行 bean 初始化方法

    ((InitializingBean) bean).afterPropertiesSet();
    invokeCustomInitMethod(beanName, bean, mbd); 

首先执行 afterPropertiesSet 方法（如果实现 InitializingBean 接口的话），然后再执行自定义的初始化方法 init-method。

4.执行 BeanPostProcessor.postProcessAfterInitialization

执行 BeanPostProcessor 的初始化后方法，BeanPostProcessor 需要在 xml中 配置，如

    <bean class="com.jd.spring.processor.MyBeanPostPrcessor"/>

bean 初始化过程结果如下：