處理import 、alias、bean、beans 這四種標(biāo)簽
其中最復(fù)雜的就是 beans 標(biāo)簽，他會(huì)導(dǎo)致程序遞歸到DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions方法，然后重復(fù)上面的所有步驟，有興趣的同學(xué)可以在< beans> 標(biāo)簽中嵌入一個(gè)< beans>，來研究下Spring是如何處理遞歸的。我這里就不再深入討論了。

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    //處理 import 標(biāo)簽
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    // //處理 alias 標(biāo)簽
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
     //處理 bean 標(biāo)簽
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        processBeanDefinition(ele, delegate);
    }
     //處理 beans 標(biāo)簽
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // recurse
        doRegisterBeanDefinitions(ele);
    }
}

處理bean標(biāo)簽，先解析默認(rèn)命名空間中的屬性、和子標(biāo)簽
然后處理非默認(rèn)命名空間的標(biāo)簽
接著注冊(cè)BeanDefinition
最后發(fā)送一個(gè)BeanDefinition注冊(cè)事件

/**
     * Process the given bean element, parsing the bean definition
     * and registering it with the registry.
     */
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    //解析ele成BeanDefinition，并放入到BeanDefinitionHolder中
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    //如果bdHolder解析成功了就進(jìn)行
    if (bdHolder != null) {
        //解析非默認(rèn)命名空間的屬性
        //比如 http://www.springframework.org/schema/c 之類的標(biāo)簽
        //對(duì)應(yīng)的解析器也是就在springs.handlers文件中配置的，比如*/c的是org.springframework.beans.factory.xml.SimpleConstructorNamespaceHandler
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            //向IOC中注冊(cè)該BeanDefiniton！！！
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name "" +
                                     bdHolder.getBeanName() + """, ele, ex);
        }
        //最后發(fā)送一個(gè)BeanDefinition注冊(cè)事件
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

Element解析成BeanDefinition并放入到BeanDefinitionHolder中

//調(diào)用parseBeanDefinitionElement
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
    return parseBeanDefinitionElement(ele, null);
}
//實(shí)際將Element解析成Beanfinition的方法
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    //獲取id屬性
    String id = ele.getAttribute(ID_ATTRIBUTE);
    //獲取name屬性
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    //別名list
    List aliases = new ArrayList();
    
    //如果name屬性值不為空，按照 ,; 符號(hào)切分name，切分成一個(gè)name屬性，并放入到aliases中
    //這里看出bean的定義，可以定義多個(gè)name值，只要通過逗號(hào)或者分號(hào)分隔即可。
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }
    
    //把beanName設(shè)置成id，
    String beanName = id;
    //如果沒有配置id，就把name中配置的第一個(gè)值作為beanName
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        beanName = aliases.remove(0);
        if (logger.isDebugEnabled()) {
            logger.debug("No XML "id" specified - using "" + beanName +
                         "" as bean name and " + aliases + " as aliases");
        }
    }
    //如果傳入的containingBean為null，就檢驗(yàn)beanName和aliases是不是已經(jīng)被占用了，
    //占用了就拋出一個(gè)異常BeanDefinitionParsingException，
    //這里傳入的containingBean就是null，所以一定要經(jīng)過里面檢查
    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }
    //把ele解析 beanDefinition，
    //其中此處的 beanDefinition的類型是GenericBeanDefinition
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    
    if (beanDefinition != null) {
        //如果beanName沒有的話，就使用BeanDefinitionReaderUtils.generateBeanName生成一個(gè)名字
          if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) {
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                        beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    beanName = this.readerContext.generateBeanName(beanDefinition);
                    // Register an alias for the plain bean class name, if still possible,
                    // if the generator returned the class name plus a suffix.
                    // This is expected for Spring 1.2/2.0 backwards compatibility.
                    String beanClassName = beanDefinition.getBeanClassName();
                    if (beanClassName != null &&
                        beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                        !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                        aliases.add(beanClassName);
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Neither XML "id" nor "name" specified - " +
                                 "using generated bean name [" + beanName + "]");
                }
            }
            catch (Exception ex) {
                error(ex.getMessage(), ele);
                return null;
            }
        }
        String[] aliasesArray = StringUtils.toStringArray(aliases);
        // 用一個(gè)BeanDefinitionHolder ，把beanDefinition, beanName, aliasesArray封裝在一起然后返回
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
}

檢查name有沒有被使用

//檢查benaName、aliases是否被之前的bean占用
protected void checkNameUniqueness(String beanName, List aliases, Element beanElement) {
    String foundName = null;
    //判斷beanName是否被使用
    if (StringUtils.hasText(beanName) && this.usedNames.contains(beanName)) {
        foundName = beanName;
    }
    //判斷是否aliases中有被占用的
    if (foundName == null) {
        foundName = (String) CollectionUtils.findFirstMatch(this.usedNames, aliases);
    }
    //如果找到了占用，就拋出異常
    if (foundName != null) {
        error("Bean name "" + foundName + "" is already used in this  element", beanElement);
    }
    //如果沒有發(fā)現(xiàn)占用，就把beanName和aliaes全部放入到usedNames中
    this.usedNames.add(beanName);
    this.usedNames.addAll(aliases);
}

Element解析成BeanDefinition

解析Bean中幾乎所有的屬性和一些配置的子標(biāo)簽，一個(gè)示例Bean標(biāo)簽的配置如圖

//Element解析成AbstractBeanDefinition
public AbstractBeanDefinition parseBeanDefinitionElement(
    Element ele, String beanName, BeanDefinition containingBean) {
    //把beanName壓入到棧parseState中
    this.parseState.push(new BeanEntry(beanName));

    String className = null;
    //獲取class屬性值，放入到className中
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }

    try {
        //如果有parent屬性，設(shè)置到parent中
        String parent = null;
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }
        //創(chuàng)建一個(gè)AbstractBeanDefinition，類型是GenericBeanDefinition
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);
        
        //解析ele的屬性，并設(shè)置到BeanDefinition中
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        
        //如果此bean標(biāo)簽有子標(biāo)簽description的話，就把description中的值設(shè)置到bd中
        //        message
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
        
        //解析子標(biāo)簽
        //        
        parseMetaElements(ele, bd);
        
        //解析 子標(biāo)簽，把配置的lookup-method放入到bd的methodOverrides中
        // 
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        
        //解析 replaced-method 標(biāo)簽
        //        
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
        
        //解析 構(gòu)造函數(shù)標(biāo)簽 
        //        
        parseConstructorArgElements(ele, bd);
        
        //解析 屬性標(biāo)簽 
        parsePropertyElements(ele, bd);
        
        //解析  標(biāo)簽
        parseQualifierElements(ele, bd);
        
        bd.setResource(this.readerContext.getResource());
        bd.setSource(extractSource(ele));

        return bd;
    }
    catch (ClassNotFoundException ex) {
        error("Bean class [" + className + "] not found", ele, ex);
    }
    catch (NoClassDefFoundError err) {
        error("Class that bean class [" + className + "] depends on not found", ele, err);
    }
    catch (Throwable ex) {
        error("Unexpected failure during bean definition parsing", ele, ex);
    }
    finally {
        this.parseState.pop();
    }

    return null;
}

創(chuàng)建一個(gè)AbstractBeanDefinition

//利用className和parentName創(chuàng)建一個(gè)BeanDefinition
protected AbstractBeanDefinition createBeanDefinition(String className, String parentName)
    throws ClassNotFoundException {
    
    return BeanDefinitionReaderUtils.createBeanDefinition(
        parentName, className, this.readerContext.getBeanClassLoader());
}
//BeanDefinitionReaderUtils.createBeanDefinition方法創(chuàng)建的BeanDefinition的類型是GenericBeanDefinition
public static AbstractBeanDefinition createBeanDefinition(
    String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {
    //創(chuàng)建一個(gè)GenericBeanDefinition，設(shè)置ParentName，
    GenericBeanDefinition bd = new GenericBeanDefinition();
    bd.setParentName(parentName);
    //如果可以className和classLoader都有值的話，就把類Class加載出來，并設(shè)置到bd中
    //如果classLoder為空的話，就只設(shè)置一個(gè)className
    if (className != null) {
        if (classLoader != null) {
            //
            bd.setBeanClass(ClassUtils.forName(className, classLoader));
        }
        else {
            bd.setBeanClassName(className);
        }
    }
    return bd;
}

設(shè)置BeanDefinition的屬性

幾乎設(shè)置了一個(gè)BeanDefinition需要的全部屬性

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,                                                            BeanDefinition containingBean, AbstractBeanDefinition bd) {
    //解析spring2.x中的scope屬性
    //解析Spring1.x中的singleton屬性
    if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
        // Spring 2.x "scope" attribute
        bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
        if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
            error("Specify either "scope" or "singleton", not both", ele);
        }
    }
    else if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
        // Spring 1.x "singleton" attribute
        bd.setScope(TRUE_VALUE.equals(ele.getAttribute(SINGLETON_ATTRIBUTE)) ?
                    BeanDefinition.SCOPE_SINGLETON : BeanDefinition.SCOPE_PROTOTYPE);
    }
    else if (containingBean != null) {
        // Take default from containing bean in case of an inner bean definition.
        bd.setScope(containingBean.getScope());
    }

    //設(shè)置bd的 abstract 屬性
    if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
        bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
    }
    
    //設(shè)置bd的 lazy-init 屬性
    String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
    if (DEFAULT_VALUE.equals(lazyInit)) {
        lazyInit = this.defaults.getLazyInit();
    }
    bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
    
    //設(shè)置bd的 autowire 屬性
    String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
    bd.setAutowireMode(getAutowireMode(autowire));
    
    //設(shè)置bd的 dependency-check 屬性
    String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
    bd.setDependencyCheck(getDependencyCheck(dependencyCheck));
    
    //設(shè)置bd的 depends-on 屬性
    if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
        String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
        bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
    }
    
    //設(shè)置bd的 autowire-candidate 屬性
    String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
    if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
        String candidatePattern = this.defaults.getAutowireCandidates();
        if (candidatePattern != null) {
            String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
            bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
        }
    }
    else {
        bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
    }
    
    //設(shè)置bd的 primary 屬性
    if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
        bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
    }
    
   //設(shè)置bd的 init-method  屬性
    if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
        String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
        if (!"".equals(initMethodName)) {
            bd.setInitMethodName(initMethodName);
        }
    }
    else {
        if (this.defaults.getInitMethod() != null) {
            bd.setInitMethodName(this.defaults.getInitMethod());
            bd.setEnforceInitMethod(false);
        }
    }
    
     //設(shè)置bd的 destroy-method 屬性
    if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
        String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
        if (!"".equals(destroyMethodName)) {
            bd.setDestroyMethodName(destroyMethodName);
        }
    }
    else {
        if (this.defaults.getDestroyMethod() != null) {
            bd.setDestroyMethodName(this.defaults.getDestroyMethod());
            bd.setEnforceDestroyMethod(false);
        }
    }
    //設(shè)置bd的 factory-method 屬性
    if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
        bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
    }
    //設(shè)置bd的 factory-bean 屬性
    if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
        bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
    }

    return bd;
}

BeanDefinition的繼承關(guān)系圖，可以看出GenericBeanDefinition的位置

寫的有點(diǎn)太多了，還有import標(biāo)簽和 alias標(biāo)簽的解析內(nèi)容，我放置《BeanDefinition注冊(cè)-下篇》中一起講解。
下篇中也會(huì)補(bǔ)充一些此文中關(guān)于注冊(cè)BeanDefintion的細(xì)節(jié)內(nèi)容。