03-Spring默认标签解析

默认标签的解析

上一篇分析了整体的 xml 文件解析，形成 BeanDefinition 并注册到 IOC 容器中，但并没有详细的说明具体的解析，这一篇主要说一下默认标签的解析，下一篇主要说自定义标签的解析。

parseDefaultElement

解析默认的元素标签

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {

    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {

        importBeanDefinitionResource(ele);

    }

    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {

        // 处理别名，会将 beanName 和别名一块注册到 SimpleAliasRegistry 中的 aliasMap 中去。

        processAliasRegistration(ele);

    }

    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {

        // 解析 bean 标签

        processBeanDefinition(ele, delegate);

    }

    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {

        // recurse，会产生递归解析

        doRegisterBeanDefinitions(ele);

    }

}

importBeanDefinitionResource

主要解析标签中 resource 标签，此处会产生递归调用，importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);

获取 resource 属性所表示的路径
解析系统属性
针对绝对路径和相对路径进行不同的解析
相对路径的情况下，需要计算出绝对路径的地址
调用 loadBeanDefinitions 进行递归解析
通知监听器，完成解析

protected void importBeanDefinitionResource(Element ele) {

    // 获取resource属性

    String location = ele.getAttribute(RESOURCE_ATTRIBUTE);

    if (!StringUtils.hasText(location)) {

        // 如果不存在resource属性则不作任何处理

        getReaderContext().error("Resource location must not be empty", ele);

        return;

    }

    // Resolve system properties: e.g. "${user.dir}"

    // 解析系统属性

    location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

    Set<Resource> actualResources = new LinkedHashSet<>(4);

    // Discover whether the location is an absolute or relative URI

    // 判断location是绝对URI还是相对URI

    boolean absoluteLocation = false;

    try {

        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*:"

    }

    // Absolute or relative?

    // 如果是绝对URI则直接根据地质加载对应的配置文件

    if (absoluteLocation) {

        try {

            int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);

            if (logger.isTraceEnabled()) {

                logger.trace("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存在多个子类实现类，如VfsResource、FileSystemResource等，而每个resource的createRekative方式实现都不一样，

            // 所以这里先使用子类的方法尝试解析

            Resource relativeResource = getReaderContext().getResource().createRelative(location);

            if (relativeResource.exists()) {

                importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);

                actualResources.add(relativeResource);

            }

            else {

                // 如果解析不成功，则使用默认的解析器ResourcePatternResolver进行解析

                String baseLocation = getReaderContext().getResource().getURL().toString();

                importCount = getReaderContext().getReader().loadBeanDefinitions(

                    StringUtils.applyRelativePath(baseLocation, location), actualResources);

            }

            if (logger.isTraceEnabled()) {

                logger.trace("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[0]);

    getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));

}

processAliasRegistration

主要是将 beanName 和别名一块注册到 SimpleAliasRegistry 中的 aliasMap 中去

processBeanDefinition

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

    // beanDefinitionHolder是beanDefinition对象的封装类，封装了BeanDefinition，bean的名字和别名，用它来完成向IOC容器的注册

    // 得到这个beanDefinitionHolder就意味着beandefinition是通过BeanDefinitionParserDelegate对xml元素的信息按照spring的bean规则进行解析得到的

    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

    if (bdHolder != null) {

        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

        try {

            // Register the final decorated instance.

            // 向ioc容器注册解析得到的beandefinition的地方

            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

        }

        catch (BeanDefinitionStoreException ex) {

            getReaderContext().error("Failed to register bean definition with name '" +

                                     bdHolder.getBeanName() + "'", ele, ex);

        }

        // Send registration event.

        // 在beandefinition向ioc容器注册完成之后，发送消息

        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

    }

}

delegate.parseBeanDefinitionElement(ele)

主要完成的有以下工作：

解析bean标签中的id和name属性
解析其他属性，封装到 GenericBeanDefinition 中
如果没有指定 beanName，将会按照默认的规则生成对应的 beanName
将解析到的 GenericBeanDefinition 中去。

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {

    // 解析id属性

    String id = ele.getAttribute(ID_ATTRIBUTE);

    // 解析name属性

    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    // 如果bean有别名的话，那么将别名分割解析

    List<String> aliases = new ArrayList<>();

    if (StringUtils.hasLength(nameAttr)) {

        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);

        aliases.addAll(Arrays.asList(nameArr));

    }

    String beanName = id;

    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {

        beanName = aliases.remove(0);

        if (logger.isTraceEnabled()) {

            logger.trace("No XML 'id' specified - using '" + beanName +

                         "' as bean name and " + aliases + " as aliases");

        }

    }

    if (containingBean == null) {

        checkNameUniqueness(beanName, aliases, ele);

    }

    // 对bean元素的详细解析

    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

    if (beanDefinition != null) {

        if (!StringUtils.hasText(beanName)) {

            try {

                // 如果不存在beanname，那么根据spring中提供的命名规则为当前bean生成对应的beanName

                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.isTraceEnabled()) {

                    logger.trace("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);

        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);

    }

    return null;

}

parseBeanDefinitionElement

public AbstractBeanDefinition parseBeanDefinitionElement(

    Element ele, String beanName, @Nullable BeanDefinition containingBean) {

    this.parseState.push(new BeanEntry(beanName));

    // 解析class属性

    String className = null;

    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {

        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();

    }

    // 解析parent属性

    String parent = null;

    if (ele.hasAttribute(PARENT_ATTRIBUTE)) {

        parent = ele.getAttribute(PARENT_ATTRIBUTE);

    }

    try {

        // 创建装在bean信息的AbstractBeanDefinition对象，实际的实现是GenericBeanDefinition

        AbstractBeanDefinition bd = createBeanDefinition(className, parent);

        // 解析bean标签的各种其他属性

        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

        // 设置description信息

        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

        // 解析元数据

        parseMetaElements(ele, bd);

        // 解析lookup-method属性

        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

        // 解析replaced-method属性

        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        // 解析构造函数参数

        parseConstructorArgElements(ele, bd);

        // 解析property子元素

        parsePropertyElements(ele, bd);

        // 解析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;

}

createBeanDefinition()

通过 Utils 创建了 GenericBeanDefinition

BeanDefinitionReaderUtils.createBeanDefinition(

    parentName, className, this.readerContext.getBeanClassLoader());

public static AbstractBeanDefinition createBeanDefinition(

    @Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {

    GenericBeanDefinition bd = new GenericBeanDefinition();

    bd.setParentName(parentName);

    if (className != null) {

        if (classLoader != null) {

            bd.setBeanClass(ClassUtils.forName(className, classLoader));

        }

        else {

            bd.setBeanClassName(className);

        }

    }

    return bd;

}

parseBeanDefinitionAttributes

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,

                                                            @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {

    // 解析singleton属性

    if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {

        error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);

    }

    else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {

        bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));

    }

    else if (containingBean != null) {

        // Take default from containing bean in case of an inner bean definition.

        // 在嵌入beanDefinitiono情况下且没有单独指定scope属性则使用父类默认的属性

        bd.setScope(containingBean.getScope());

    }

    // 解析abstract属性

    if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {

        bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));

    }

    // 解析lazy-init属性

    String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);

    if (isDefaultValue(lazyInit)) {

        lazyInit = this.defaults.getLazyInit();

    }

    // 如果没有设置或者设置成其他字符都会被设置为false

    bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

    // 解析autowire属性

    String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);

    bd.setAutowireMode(getAutowireMode(autowire));

    // 解析depends-on属性

    if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {

        String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);

        bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));

    }

    // 解析autowire-candidate属性

    String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);

    if (isDefaultValue(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));

    }

    // 解析primary属性

    if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {

        bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));

    }

    // 解析init-method属性

    if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {

        String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);

        bd.setInitMethodName(initMethodName);

    }

    else if (this.defaults.getInitMethod() != null) {

        bd.setInitMethodName(this.defaults.getInitMethod());

        bd.setEnforceInitMethod(false);

    }

    // 解析destory-method属性

    if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {

        String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);

        bd.setDestroyMethodName(destroyMethodName);

    }

    else if (this.defaults.getDestroyMethod() != null) {

        bd.setDestroyMethodName(this.defaults.getDestroyMethod());

        bd.setEnforceDestroyMethod(false);

    }

    // 解析factory-method属性

    if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {

        bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));

    }

    // 解析factory-bean属性

    if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {

        bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));

    }

    return bd;

}

parseMetaElements

public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {

    // 获取当前节点的所有子元素

    NodeList nl = ele.getChildNodes();

    for (int i = 0; i < nl.getLength(); i++) {

        Node node = nl.item(i);

        // 提取meta

        if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {

            Element metaElement = (Element) node;

            String key = metaElement.getAttribute(KEY_ATTRIBUTE);

            String value = metaElement.getAttribute(VALUE_ATTRIBUTE);

            // 使用key、value构造beanMetadataAttribute

            BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);

            attribute.setSource(extractSource(metaElement));

            // 记录信息

            attributeAccessor.addMetadataAttribute(attribute);

        }

    }

}

parseLookupOverrideSubElements

lookup-method：动态地将一个原型 bean 作为 bean 对象注入到单例 bean 中。

public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {

    NodeList nl = beanEle.getChildNodes();

    for (int i = 0; i < nl.getLength(); i++) {

        Node node = nl.item(i);

        // 仅当在spring默认bean的子元素下且为<lookup-method>时有效

        if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {

            Element ele = (Element) node;

            // 获取要修饰的方法

            String methodName = ele.getAttribute(NAME_ATTRIBUTE);

            // 获取配置返回的bean

            String beanRef = ele.getAttribute(BEAN_ELEMENT);

            LookupOverride override = new LookupOverride(methodName, beanRef);

            override.setSource(extractSource(ele));

            overrides.addOverride(override);

        }

    }

}

parseReplacedMethodSubElements

replaced-method：用于方法的动态替换

public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {

    NodeList nl = beanEle.getChildNodes();

    for (int i = 0; i < nl.getLength(); i++) {

        Node node = nl.item(i);

        // 仅当在spring默认的bean的子元素下且为<replaced-method>时有效

        if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {

            Element replacedMethodEle = (Element) node;

            // 提取要替换的旧方法

            String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);

            // 提取对应的新的替换方法

            String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);

            ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);

            // Look for arg-type match elements.

            List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);

            for (Element argTypeEle : argTypeEles) {

                // 记录参数

                String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);

                match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle));

                if (StringUtils.hasText(match)) {

                    replaceOverride.addTypeIdentifier(match);

                }

            }

            replaceOverride.setSource(extractSource(replacedMethodEle));

            overrides.addOverride(replaceOverride);

        }

    }

}

parseConstructorArgElements

public void parseConstructorArgElement(Element ele, BeanDefinition bd) {

    // 获取index属性

    String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);

    // 获取type属性

    String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);

    // 提取name属性

    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    if (StringUtils.hasLength(indexAttr)) {

        try {

            int index = Integer.parseInt(indexAttr);

            if (index < 0) {

                error("'index' cannot be lower than 0", ele);

            }

            else {

                try {

                    this.parseState.push(new ConstructorArgumentEntry(index));

                    // 解析ele对应的属性元素

                    Object value = parsePropertyValue(ele, bd, null);

                    ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);

                    if (StringUtils.hasLength(typeAttr)) {

                        valueHolder.setType(typeAttr);

                    }

                    if (StringUtils.hasLength(nameAttr)) {

                        valueHolder.setName(nameAttr);

                    }

                    valueHolder.setSource(extractSource(ele));

                    // 不允许重复指定相同参数

                    if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {

                        error("Ambiguous constructor-arg entries for index " + index, ele);

                    }

                    else {

                        bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);

                    }

                }

                finally {

                    this.parseState.pop();

                }

            }

        }

        catch (NumberFormatException ex) {

            error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);

        }

    }

    else {

        // 没有index属性则忽略属性，自动寻找

        try {

            this.parseState.push(new ConstructorArgumentEntry());

            Object value = parsePropertyValue(ele, bd, null);

            ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);

            if (StringUtils.hasLength(typeAttr)) {

                valueHolder.setType(typeAttr);

            }

            if (StringUtils.hasLength(nameAttr)) {

                valueHolder.setName(nameAttr);

            }

            valueHolder.setSource(extractSource(ele));

            bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);

        }

        finally {

            this.parseState.pop();

        }

    }

}

parsePropertyElements

public void parsePropertyElement(Element ele, BeanDefinition bd) {

    // 获取配置元素中name的值

    String propertyName = ele.getAttribute(NAME_ATTRIBUTE);

    if (!StringUtils.hasLength(propertyName)) {

        error("Tag 'property' must have a 'name' attribute", ele);

        return;

    }

    this.parseState.push(new PropertyEntry(propertyName));

    try {

        // 不允许多次对同一属性配置，如果已经存在同名的property属性，那么就不进行解析

        if (bd.getPropertyValues().contains(propertyName)) {

            error("Multiple 'property' definitions for property '" + propertyName + "'", ele);

            return;

        }

        // 此处用来解析property值，返回的对象对应对bean定义的property属性设置的解析结果，这个解析结果会封装到PropertyValue对象中，然后

        // 设置到BeanDefinitionHolder中去

        Object val = parsePropertyValue(ele, bd, propertyName);

        PropertyValue pv = new PropertyValue(propertyName, val);

        parseMetaElements(ele, pv);

        pv.setSource(extractSource(ele));

        bd.getPropertyValues().addPropertyValue(pv);

    }

    finally {

        this.parseState.pop();

    }

}

parseQualifierElements

public void parseQualifierElement(Element ele, AbstractBeanDefinition bd) {

    String typeName = ele.getAttribute(TYPE_ATTRIBUTE);

    if (!StringUtils.hasLength(typeName)) {

        error("Tag 'qualifier' must have a 'type' attribute", ele);

        return;

    }

    this.parseState.push(new QualifierEntry(typeName));

    try {

        AutowireCandidateQualifier qualifier = new AutowireCandidateQualifier(typeName);

        qualifier.setSource(extractSource(ele));

        String value = ele.getAttribute(VALUE_ATTRIBUTE);

        if (StringUtils.hasLength(value)) {

            qualifier.setAttribute(AutowireCandidateQualifier.VALUE_KEY, value);

        }

        NodeList nl = ele.getChildNodes();

        for (int i = 0; i < nl.getLength(); i++) {

            Node node = nl.item(i);

            if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ATTRIBUTE_ELEMENT)) {

                Element attributeEle = (Element) node;

                String attributeName = attributeEle.getAttribute(KEY_ATTRIBUTE);

                String attributeValue = attributeEle.getAttribute(VALUE_ATTRIBUTE);

                if (StringUtils.hasLength(attributeName) && StringUtils.hasLength(attributeValue)) {

                    BeanMetadataAttribute attribute = new BeanMetadataAttribute(attributeName, attributeValue);

                    attribute.setSource(extractSource(attributeEle));

                    qualifier.addMetadataAttribute(attribute);

                }

                else {

                    error("Qualifier 'attribute' tag must have a 'name' and 'value'", attributeEle);

                    return;

                }

            }

        }

        bd.addQualifier(qualifier);

    }

    finally {

        this.parseState.pop();

    }

}

巴特西