Spring的XML解析原理，这一次全搞懂再走，阿里面试题Java

接着看看DefaultBeanDefinitionDocumentReader中是如何解析的：

protected void doRegisterBeanDefinitions(Element root) { // 创建了BeanDefinitionParserDelegate对象 BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(getReaderContext(), root, parent); // 如果是Spring原生命名空间，首先解析 profile标签，这里不重要 if (this.delegate.isDefaultNamespace(root)) {
            String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
            if (StringUtils.hasText(profileSpec)) {
                String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                        profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS); // We cannot use Profiles.of(...) since profile expressions are not supported  // in XML config. See SPR-12458 for details. if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                                "] not matching: " + getReaderContext().getResource());
                    }
                    return;
                }
            }
        }

        preProcessXml(root); //主要看这个方法，标签具体解析过程 parseBeanDefinitions(root, this.delegate);
        postProcessXml(root);

        this.delegate = parent;
    }

在这个方法中重点关注preProcessXml、parseBeanDefinitions、postProcessXml三个方法，其中preProcessXml和postProcessXml都是空方法，意思是在解析标签前后我们自己可以扩展需要执行的操作，也是一个模板方法模式，体现了Spring的高扩展性。然后进入parseBeanDefinitions方法看具体是怎么解析标签的：

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);
        }
    }

这里有两种标签的解析：Spring原生标签和自定义标签。怎么区分这两种标签呢？

// 自定义标签 <context:component-scan/> // 默认标签 <bean:/>

如上，带前缀的就是自定义标签，否则就是Spring默认标签，无论哪种标签在使用前都需要在Spring的xml配置文件里声明Namespace URI，这样在解析标签时才能通过Namespace URI找到对应的NamespaceHandler。

xmlns:context="http://www.springframework.org/schema/context"

http://www.springframework.org/schema/beans

isDefaultNamespace判断是不是默认标签，点进去看看是不是跟我上面说的一致：

public boolean isDefaultNamespace(Node node) {
        return isDefaultNamespace(getNamespaceURI(node));
    }

    public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";
    public boolean isDefaultNamespace(@Nullable String namespaceUri) {
        return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));
    }

可以看到http://www.springframework.org/schema/beans所对应的就是默认标签。接着，我们进入parseDefaultElement方法：

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);
        }
        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // recurse doRegisterBeanDefinitions(ele);
        }
    }

这里面主要是对import、alias、bean标签的解析以及beans的字标签的递归解析，主要看看bean标签的解析：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { // 解析elment封装为BeanDefinitionHolder对象 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) { // 该方法功能不重要，主要理解设计思想：装饰者设计模式以及SPI设计思想 bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try { // 完成document到BeanDefinition对象转换后，对BeanDefinition对象进行缓存注册 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
            } // Send registration event. getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) { // 获取id和name属性 String id = ele.getAttribute(ID_ATTRIBUTE);
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); // 获取别名属性，多个别名可用,;隔开 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");
            }
        } //检查beanName是否重复 if (containingBean == null) {
            checkNameUniqueness(beanName, aliases, ele);
        } // 具体的解析封装过程还在这个方法里 AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) {
            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.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;
    } // bean的解析 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();
        }
        String parent = null;
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }

        try { // 创建GenericBeanDefinition对象 AbstractBeanDefinition bd = createBeanDefinition(className, parent); // 解析bean标签的属性，并把解析出来的属性设置到BeanDefinition对象中 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT)); //解析bean中的meta标签 parseMetaElements(ele, bd); //解析bean中的lookup-method标签 parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); //解析bean中的replaced-method标签 parseReplacedMethodSubElements(ele, bd.getMethodOverrides()); //解析bean中的constructor-arg标签 parseConstructorArgElements(ele, bd); //解析bean中的property标签  parsePropertyElements(ele, bd);

            parseQualifierElements(ele, bd);

            bd.setResource(this.readerContext.getResource());
            bd.setSource(extractSource(ele));

            return bd;
        }

        return null;
    }

bean标签的解析步骤仔细理解并不复杂，就是将一个个标签属性的值装入到了BeanDefinition对象中，这里需要注意parseConstructorArgElements和parsePropertyElements方法，分别是对constructor-arg和property标签的解析，解析完成后分别装入了BeanDefinition对象的constructorArgumentValues和propertyValues中，而这两个属性在接下来c和p标签的解析中还会用到，而且还涉及一个很重要的设计思想——装饰器模式。 Bean标签解析完成后将生成的BeanDefinition对象、bean的名称以及别名一起封装到了BeanDefinitionHolder对象并返回，然后调用了decorateBeanDefinitionIfRequired进行装饰：

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
            Element ele, BeanDefinitionHolder definitionHolder, @Nullable BeanDefinition containingBd) {

        BeanDefinitionHolder finalDefinition = definitionHolder; //根据bean标签属性装饰BeanDefinitionHolder，比如<bean class="xx" p:username="dark"/> NamedNodeMap attributes = ele.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
            Node node = attributes.item(i);
            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
        } //根据bean标签子元素装饰BeanDefinitionHolder/ NodeList children = ele.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            Node node = children.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
            }
        }
        return finalDefinition;
    }

在这个方法中分别对Bean标签的属性和子标签迭代，获取其中的自定义标签进行解析，并装饰之前创建的BeanDefinition对象，如同下面的c和p：

// c:和p:表示通过构造器和属性的setter方法给属性赋值，是constructor-arg和property的简化写法
<bean class="com.dark.bean.Student" id="student" p:username="Dark" p:password="111" c:age="12" c:sex="1"/>

两个步骤是一样的，我们点进decorateIfRequired方法中：

public BeanDefinitionHolder decorateIfRequired(
            Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) { //根据node获取到node的命名空间，形如：http://www.springframework.org/schema/p String namespaceUri = getNamespaceURI(node);
        if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) { // 根据配置文件获取namespaceUri对应的处理类，SPI思想 NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
            if (handler != null) { //调用NamespaceHandler处理类的decorate方法，开始具体装饰过程，并返回装饰完的对象 BeanDefinitionHolder decorated =
                        handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
                if (decorated != null) {
                    return decorated;
                }
            }
            else if (namespaceUri.startsWith("http://www.springframework.org/")) {
                error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
            }
            else { // A custom namespace, not to be handled by Spring - maybe "xml:...". if (logger.isDebugEnabled()) {
                    logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
                }
            }
        }
        return originalDef;
    }

这里也和我们之前说的一样，首先获取到标签对应的namespaceUri，然后通过这个Uri去获取到对应的NamespceHandler，最后再调用NamespceHandler的decorate方法进行装饰。我们先来看看获取NamespceHandler的过程，这涉及到一个非常重要的高扩展性的思想——SPI（有关SPI，在我之前的文章[Dubbo——SPI及自适应扩展原理]( )中已经详细讲解过，这里不再赘述）：

public NamespaceHandler resolve(String namespaceUri) { // 获取spring中所有jar包里面的 "META-INF/spring.handlers"文件，并且建立映射关系 Map<String, Object> handlerMappings = getHandlerMappings(); //根据namespaceUri：http://www.springframework.org/schema/p，获取到这个命名空间的处理类 Object handlerOrClassName = handlerMappings.get(namespaceUri);
        if (handlerOrClassName == null) {
            return null;
        }
        else if (handlerOrClassName instanceof NamespaceHandler) {
            return (NamespaceHandler) handlerOrClassName;
        }
        else {
            String className = (String) handlerOrClassName;
            try {
                Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
                if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
                    throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
                            "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
                }
                NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass); //调用处理类的init方法，在init方法中完成标签元素解析类的注册 namespaceHandler.init();
                handlerMappings.put(namespaceUri, namespaceHandler);
                return namespaceHandler;
            }
        }
    } // AOP标签对应的NamespaceHandler，可以发现NamespaceHandler的作用就是管理和注册与自己相关的标签解析器 public void init() { // In 2.0 XSD as well as in 2.1 XSD. registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator()); // Only in 2.0 XSD: moved to context namespace as of 2.1 registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

看到这里我们应该就清楚了Spring是如何解析xml里的标签了以及我们如果要扩展自己的标签该怎么做。只需要创建一个我们的自定义标签和解析类，并指定它的命名空间以及NamespaceHandler，最后在META-INF/spring.handlers文件中指定命名空间和NamespaceHandler的映射关系即可，就像Spring的c和p标签一样：

http/://www.springframework.org/schema/c=org.springframework.beans.factory.xml.SimpleConstructorNamespaceHandler
http/://www.springframework.org/schema/p=org.springframework.beans.factory.xml.SimplePropertyNamespaceHandler

像这样使用SPI的思想设计我们的项目的话，当需要扩展时，不需要改动任何的代码，非常的方便优雅。 接着，我们回到handler的decorate方法，这里有三个默认的实现类：NamespaceHandlerSupport、SimpleConstructorNamespaceHandler、SimplePropertyNamespaceHandler。第一个是一个抽象类，与我们这里的流程无关，感兴趣的可自行了解，第二个和第三个则分别是c和p标签对应的NamespaceHandler，两个装饰的处理逻辑基本上是一样的，我这里进入的是SimpleConstructorNamespaceHandler类：

public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) {
        if (node instanceof Attr) {
            Attr attr = (Attr) node;
            String argName = StringUtils.trimWhitespace(parserContext.getDelegate().getLocalName(attr));
            String argValue = StringUtils.trimWhitespace(attr.getValue());

            ConstructorArgumentValues cvs = definition.getBeanDefinition().getConstructorArgumentValues();
            boolean ref = false; // handle -ref arguments if (argName.endsWith(REF_SUFFIX)) {
                ref = true;
                argName = argName.substring(0, argName.length() - REF_SUFFIX.length());
            }

            ValueHolder valueHolder = new ValueHolder(ref ? new RuntimeBeanReference(argValue) : argValue);
            valueHolder.setSource(parserContext.getReaderContext().extractSource(attr)); // handle "escaped"/"_" arguments if (argName.startsWith(DELIMITER_PREFIX)) {
                String arg = argName.substring(1).trim(); // fast default check if (!StringUtils.hasText(arg)) {
                    cvs.addGenericArgumentValue(valueHolder);
                } // assume an index otherwise else {
                    int index = -1;
                    try {
                        index = Integer.parseInt(arg);
                    }
                    catch (NumberFormatException ex) {
                        parserContext.getReaderContext().error(
                                "Constructor argument '" + argName + "' specifies an invalid integer", attr);
                    }
                    if (index < 0) {
                        parserContext.getReaderContext().error(
                                "Constructor argument '" + argName + "' specifies a negative index", attr);
                    }

                    if (cvs.hasIndexedArgumentValue(index)) {
                        parserContext.getReaderContext().error(
                                "Constructor argument '" + argName + "' with index "+ index+" already defined using <constructor-arg>." +
                                " Only one approach may be used per argument.", attr);
                    }

                    cvs.addIndexedArgumentValue(index, valueHolder);
                }
            } // no escaping -> ctr name else {
                String name = Conventions.attributeNameToPropertyName(argName);
                if (containsArgWithName(name, cvs)) {
                    parserContext.getReaderContext().error(
                            "Constructor argument '" + argName + "' already defined using <constructor-arg>." +
                            " Only one approach may be used per argument.", attr);
                }
                valueHolder.setName(Conventions.attributeNameToPropertyName(argName));
                cvs.addGenericArgumentValue(valueHolder);
            }
        }
        return definition;
    }

很简单，拿到c标签对应的值，封装成ValueHolder，再添加到BeanDefinition的ConstructorArgumentValues属性中去，这样就装饰完成了。 讲到这里你可能会觉得，这和平时看到装饰器模式不太一样。其实，设计模式真正想要表达的是各种模式所代表的思想，而不是死搬硬套的实现，只有灵活的运用其思想才算是真正的掌握了设计模式，而装饰器模式的精髓就是动态的将属性、功能、责任附加到对象上，这样你再看这里是否是运用了装饰器的思想呢？ 装饰完成后返回BeanDefinitionHolder对象并调用BeanDefinitionReaderUtils.registerBeanDefinition方法将该对象缓存起来，等待容器去实例化。这里就是将其缓存到DefaultListableBeanFactory的beanDefinitionMap属性中，自己看看代码也就明白了，我就不贴代码了。至此，Spring的XML解析原理分析完毕，下面是我画的时序图，可以对照看看：