BeanDefinition注册-上篇

处理import 、alias、bean、beans 这四种标签
其中最复杂的就是 beans 标签，他会导致程序递归到DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions方法，然后重复上面的所有步骤，有兴趣的同学可以在< beans> 标签中嵌入一个< beans>，来研究下Spring是如何处理递归的。我这里就不再深入讨论了。

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    //处理 import 标签
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    // //处理 alias 标签
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
     //处理 bean 标签
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        processBeanDefinition(ele, delegate);
    }
     //处理 beans 标签
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // recurse
        doRegisterBeanDefinitions(ele);
    }
}

处理bean标签，先解析默认命名空间中的属性、和子标签
然后处理非默认命名空间的标签
接着注册BeanDefinition
最后发送一个BeanDefinition注册事件

/**
     * 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解析成功了就进行
    if (bdHolder != null) {
        //解析非默认命名空间的属性
        //比如 http://www.springframework.org/schema/c 之类的标签
        //对应的解析器也是就在springs.handlers文件中配置的，比如*/c的是org.springframework.beans.factory.xml.SimpleConstructorNamespaceHandler
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            //向IOC中注册该BeanDefiniton！！！
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name "" +
                                     bdHolder.getBeanName() + """, ele, ex);
        }
        //最后发送一个BeanDefinition注册事件
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

Element解析成BeanDefinition并放入到BeanDefinitionHolder中

//调用parseBeanDefinitionElement
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
    return parseBeanDefinitionElement(ele, null);
}
//实际将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属性值不为空，按照 ,; 符号切分name，切分成一个name属性，并放入到aliases中
    //这里看出bean的定义，可以定义多个name值，只要通过逗号或者分号分隔即可。
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }
    
    //把beanName设置成id，
    String beanName = id;
    //如果没有配置id，就把name中配置的第一个值作为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，就检验beanName和aliases是不是已经被占用了，
    //占用了就抛出一个异常BeanDefinitionParsingException，
    //这里传入的containingBean就是null，所以一定要经过里面检查
    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }
    //把ele解析 beanDefinition，
    //其中此处的 beanDefinition的类型是GenericBeanDefinition
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    
    if (beanDefinition != null) {
        //如果beanName没有的话，就使用BeanDefinitionReaderUtils.generateBeanName生成一个名字
          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);
        // 用一个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);
    }
    //如果没有发现占用，就把beanName和aliaes全部放入到usedNames中
    this.usedNames.add(beanName);
    this.usedNames.addAll(aliases);
}

Element解析成BeanDefinition

解析Bean中几乎所有的属性和一些配置的子标签，一个示例Bean标签的配置如图

//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属性，设置到parent中
        String parent = null;
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }
        //创建一个AbstractBeanDefinition，类型是GenericBeanDefinition
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);
        
        //解析ele的属性，并设置到BeanDefinition中
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        
        //如果此bean标签有子标签description的话，就把description中的值设置到bd中
        //        message
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
        
        //解析子标签
        //        
        parseMetaElements(ele, bd);
        
        //解析 子标签，把配置的lookup-method放入到bd的methodOverrides中
        // 
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        
        //解析 replaced-method 标签
        //        
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
        
        //解析 构造函数标签 
        //        
        parseConstructorArgElements(ele, bd);
        
        //解析 属性标签 
        parsePropertyElements(ele, bd);
        
        //解析  标签
        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;
}

创建一个AbstractBeanDefinition

//利用className和parentName创建一个BeanDefinition
protected AbstractBeanDefinition createBeanDefinition(String className, String parentName)
    throws ClassNotFoundException {
    
    return BeanDefinitionReaderUtils.createBeanDefinition(
        parentName, className, this.readerContext.getBeanClassLoader());
}
//BeanDefinitionReaderUtils.createBeanDefinition方法创建的BeanDefinition的类型是GenericBeanDefinition
public static AbstractBeanDefinition createBeanDefinition(
    String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {
    //创建一个GenericBeanDefinition，设置ParentName，
    GenericBeanDefinition bd = new GenericBeanDefinition();
    bd.setParentName(parentName);
    //如果可以className和classLoader都有值的话，就把类Class加载出来，并设置到bd中
    //如果classLoder为空的话，就只设置一个className
    if (className != null) {
        if (classLoader != null) {
            //
            bd.setBeanClass(ClassUtils.forName(className, classLoader));
        }
        else {
            bd.setBeanClassName(className);
        }
    }
    return bd;
}

设置BeanDefinition的属性

几乎设置了一个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());
    }

    //设置bd的 abstract 属性
    if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
        bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
    }
    
    //设置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));
    
    //设置bd的 autowire 属性
    String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
    bd.setAutowireMode(getAutowireMode(autowire));
    
    //设置bd的 dependency-check 属性
    String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
    bd.setDependencyCheck(getDependencyCheck(dependencyCheck));
    
    //设置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));
    }
    
    //设置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));
    }
    
    //设置bd的 primary 属性
    if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
        bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
    }
    
   //设置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);
        }
    }
    
     //设置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);
        }
    }
    //设置bd的 factory-method 属性
    if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
        bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
    }
    //设置bd的 factory-bean 属性
    if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
        bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
    }

    return bd;
}

BeanDefinition的继承关系图，可以看出GenericBeanDefinition的位置

写的有点太多了，还有import标签和 alias标签的解析内容，我放置《BeanDefinition注册-下篇》中一起讲解。
下篇中也会补充一些此文中关于注册BeanDefintion的细节内容。