Spring4 默认标签解析源码

介绍

spring中将标签解析委派给DefaultBeanDefinitionDocumentReader类的parseDefaultElement方法来解析Document中的根级别元素Element下的元素，主要包括默认标签元素解析和自定义标签元素解析。本篇主要是默认标签元素；默认标签元素主要包括：import标签，alias标签，bean标签，beans标签。

默认标签解析开始位置

DefaultBeanDefinitionDocumentReader类之parseDefaultElement方法

// 解析Document元素Element节点  
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    // 如果元素节点是<import>节点
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        // 解析Document元素中的<import>节点
        importBeanDefinitionResource(ele);
    }
    // 如果元素节点是<alias>节点
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        // 解析Document元素中的<alias>节点
        processAliasRegistration(ele);
    }
    // 如果元素节点是<bean>节点
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        // 解析Document元素中的<bean>节点
        processBeanDefinition(ele, delegate);
    }
    // 如果元素节点是<beans>节点
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { 
        // 解析Document元素中的<beans>节点
        doRegisterBeanDefinitions(ele);
    }
}

解析Bean标签及注册

processBeanDefinition(ele, delegate);

// 解析Document元素中的<bean>节点 
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // BeanDefinitionHolder类对BeanDefinition的封装
    // 使用BeanDefinitionParserDelegate解析默认的bean标签（包括属性及子元素标签的解析）
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        // 解析自定义标签
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // IOC容器注册BeanDefinition
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                    bdHolder.getBeanName() + "'", ele, ex);
        }
        //在完成向Spring IoC容器注册解析得到的Bean定义之后，发送注册事件  
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

核心步骤说明：
① spring将Element元素委派给BeanDefinitionParserDelegate类解析成BeanDefinitionHolder（bean封装成BeanDefination，BeanDefinationHolder类是对BeanDefinition的封装）；其中解析标签元素分为默认标签元素和自定义标签元素。
② spring将委托BeanDefinitionReaderUtils类的registerBeanDefinition方法注册。
--------------- 解析默认标签元素 parseBeanDefinitionElement ---------------

// 解析提供的Element元素
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
    return parseBeanDefinitionElement(ele, null);
}

// 解析提供的Element元素,重载方法
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    // public static final String ID_ATTRIBUTE = "id";
    // 获取bean元素中的id属性
    String id = ele.getAttribute(ID_ATTRIBUTE);
    // public static final String NAME_ATTRIBUTE = "name";
    // 获取bean元素中的name属性
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    // 将bean元素中name属性值存放到别名中
    List<String> aliases = new ArrayList<String>();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }
    
    // 设置beanName默认值为id属性值
    String beanName = id;
    // 如果别名集合不为空，那么将别名集合中的第一个元素设置为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");
        }
    }
    
    // 检查Bean元素配置的id、name或者别名是否重复
    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }

    // 解析bean定义本身，而不考虑名称或别名。
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        // 如果beanName为空
        if (!StringUtils.hasText(beanName)) {
            try {
                // 如果bean元素没有配置id、别名或者name并且包含子Bean元素
                // 那么就解析Bean使用别名注册
                if (containingBean != null) {
                    // 生成beanName
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                            beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    // 生成beanName
                    beanName = this.readerContext.generateBeanName(beanDefinition);
                    // 将beanName添加到别名集合中
                    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);
        // 将Bean定义封装对象beanDefinition、bean名称、别名数组这些都封装到BeanDefinitionHolder对象中
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
}

说明：
① 获取Element元素中的属性id和name。
② 检查bean元素配置的id、name或者别名是否重复。
③ 解析bean元素本身（刨除name和id解析，通过调用parseBeanDefinitionElement方法）。
④ 设置beanName，默认是id，如果id没有就使用别名。如果别名也没有那么就spring默认生成一个。

// 解析BeanDefination(bean名称和别名除外, 调用此函数前已经处理过了)
public AbstractBeanDefinition parseBeanDefinitionElement(
        Element ele, String beanName, BeanDefinition containingBean) {
    
    this.parseState.push(new BeanEntry(beanName));

    // public static final String CLASS_ATTRIBUTE = "class";
    // 获取bean元素中的class属性
    String className = null;
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }

    try {
        // public static final String PARENT_ATTRIBUTE = "parent";
        // 获取bean元素中的parent属性
        String parent = null;
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }
        
        // 使用给定的class名称和parent名称创建BeanDefination
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);
        // 解析bean中默认的各种属性
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        // 设置bean元素下面的description标签值
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
        // 对Bean元素的meta(元信息)属性解析
        parseMetaElements(ele, bd);
        // 解析lookup-method属性标签
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        // 解析replaced-method属性标签
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
        // 解析Bean元素的构造方法设置标签
        parseConstructorArgElements(ele, bd);
        // 解析Bean元素的property属性标签
        parsePropertyElements(ele, bd);
        // 解析Bean元素的qualifier属性标签
        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;
}

// 使用给定的class名称和parent名称创建BeanDefination
protected AbstractBeanDefinition createBeanDefinition(String className, String parentName)
        throws ClassNotFoundException {

    return BeanDefinitionReaderUtils.createBeanDefinition(
            parentName, className, this.readerContext.getBeanClassLoader());
}

说明：
① 解析Bean中默认的各种属性（parseBeanDefinitionAttributes方法）。
② 解析Bean下面的description元素（DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT)）。
③ 解析Bean下面的meta元素（parseMetaElements方法）。
④ 解析Bean下面的lookup-method元素（parseLookupOverrideSubElements方法）。
⑤ 解析Bean下面的replaced-method元素（parseReplacedMethodSubElements方法）。
⑥ 解析Bean下面的ConstructorArg元素（parseConstructorArgElements方法）。
⑦ 解析Bean下面的property元素（parsePropertyElements方法）。
⑧ 解析Bean下面的qualifier元素（parseQualifierElements方法）。
--------------- 注册Bean registerBeanDefinition---------------

// 将Bean定义注册到Bean工厂
public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {

    // Register bean definition under primary name.
    // 获取Bean定义的名称
    String beanName = definitionHolder.getBeanName();
    // 使用Bean名称和BeanDefinition向IOC容器注册
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.
    // 如果BeanDefinition有别名，那么向ioc容器注册别名
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}

@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {
    // 判断beanName不为空
    Assert.hasText(beanName, "Bean name must not be empty");
    // 判断beanDefinition不为空
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    // 校验AbstractBeanDefinition中的methodOverrides校验
    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }
    
    BeanDefinition oldBeanDefinition;
    // 通过beanName获取BeanDefinition
    oldBeanDefinition = this.beanDefinitionMap.get(beanName);
    if (oldBeanDefinition != null) {
        // 如果beanName对应的beanDefinition已经存在了，并且beanDefinition不允许被覆盖就抛出异常
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                    "': There is already [" + oldBeanDefinition + "] bound.");
        }
        else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                        "' with a framework-generated bean definition: replacing [" +
                        oldBeanDefinition + "] with [" + beanDefinition + "]");
            }
        }
        // 如果新的beanDefinition不是旧的beanDefinition，那么打印日志信息（替换旧的beanDefinition）
        else if (!beanDefinition.equals(oldBeanDefinition)) {
            if (this.logger.isInfoEnabled()) {
                this.logger.info("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + oldBeanDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        // 新的beanDefinition对象就是旧的beanDefinition，那么同样打印日志（替换旧的beanDefinition）
        else {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with an equivalent definition: replacing [" + oldBeanDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        // 新的beanDefinition替换已存在的beanDefinition
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    else {
        if (hasBeanCreationStarted()) {
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            // 上锁共享维护的beanDefinitionMap
            synchronized (this.beanDefinitionMap) {
                // 更新beanName键对应的最新值beanDefinition
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
                // 将之前的beanName添加到updatedDefinitions
                updatedDefinitions.addAll(this.beanDefinitionNames);
                // 将当前最新的beanName添加到updatedDefinitions
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                // 如果beanName单例集合manualSingletonNames中已存在beanName
                if (this.manualSingletonNames.contains(beanName)) {
                    Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
                    // 移除第一个放入的beanName
                    updatedSingletons.remove(beanName);
                    // 更新beanName单例集合manualSingletonNames
                    this.manualSingletonNames = updatedSingletons;
                }
            }
        }
        else {
            // Still in startup registration phase
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    //重置所有已经注册过的BeanDefinition的缓存 
    if (oldBeanDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}

---

解析import标签

importBeanDefinitionResource(ele);

// 解析import元素和加载BeanDefination
protected void importBeanDefinitionResource(Element ele) {
    // public static final String RESOURCE_ATTRIBUTE = "resource";
    // 获取import标签的resource属性值
    String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
    // location定位的资源不存在，提示错误
    if (!StringUtils.hasText(location)) {
        getReaderContext().error("Resource location must not be empty", ele);
        return;
    }

    // Resolve system properties: e.g. "${user.dir}"
    // 解析系统属性，返回定位资源的路径
    location = environment.resolveRequiredPlaceholders(location); 
    Set<Resource> actualResources = new LinkedHashSet<Resource>(4);

    boolean absoluteLocation = false;
    try {
        // 判断location属性值的定位是否为绝对路径
        absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
    }
    catch (URISyntaxException ex) {
        // cannot convert to an URI, considering the location relative
        // unless it is the well-known Spring prefix "classpath*:"
    }

    // 如果资源为绝对路径
    if (absoluteLocation) {
        try {
            // 通过指定路径加载bean定义的资源，返回<import>节点的加载次数
            int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
            if (logger.isDebugEnabled()) {
                logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
            }
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error(
                    "Failed to import bean definitions from URL location [" + location + "]", ele, ex);
        }
    }
    else {// 如果资源为相对路径
        // No URL -> considering resource location as relative to the current file.
        try {
            int importCount;
            // 通过指定路径获取相对路径下的资源Resource
            Resource relativeResource = getReaderContext().getResource().createRelative(location);
            // 判断相对路径对应的资源是否存在
            if (relativeResource.exists()) {
                // 使用XmlBeanDefinitionReader读取相对路径下的资源
                importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
                actualResources.add(relativeResource);
            }
            else {
                String baseLocation = getReaderContext().getResource().getURL().toString();
                importCount = getReaderContext().getReader().loadBeanDefinitions(
                        StringUtils.applyRelativePath(baseLocation, location), actualResources);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
            }
        }
        catch (IOException ex) {
            getReaderContext().error("Failed to resolve current resource location", ele, ex);
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
                    ele, ex);
        }
    }
    Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);
    // 在解析完<import>元素之后，发送容器导入其他资源处理完成事件
    getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

说明：
① 解析resource属性的定位资源路径，解析系统属性。
② 如果是绝对路径，那么调用loadBeanDefinitions方法加载路径资源。
③ 如果是相对路径，那么将相对路径拼接成绝对路径，使用loadBeanDefinitions方法加载路径资源。

---

参考

本文主要是参考了spring源码深度解析和个人读spring源码的总结