(一)Spring IoC源码-1.容器的初始化-06自定义标签的解析

在(一)IoC源码-04注册BeanDefinitions一文中，了解到Spring对于默认标签和自定义标签的处理方式是不同的。

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    //如果元素是默认标签，按照处理默认标签的方式来处理
    if (delegate.isDefaultNamespace(root)) {
        //获取元素的所有子节点
        NodeList nl = root.getChildNodes();
        //遍历所有的子节点，即"import", "alias", "bean".
        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);
    }
}

在上文(一)IoC源码-05默认标签的解析中已经学习了默认标签是如何解析的，本文学习自定义标签是如何解析的。

自定义标签的解析

自定义标签的解析是在BeanDefinitionParserDelegate.parseCustomElement(Element)方法中进行的。

@Nullable
public BeanDefinition parseCustomElement(Element ele) {
    //第二个参数的含义为父类bean，对顶层元素进行解析时应设为null
    return parseCustomElement(ele, null);
}

@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    //获取元素所在命名空间
    String namespaceUri = getNamespaceURI(ele);
    if (namespaceUri == null) {
        return null;
    }
    //根据命名空间获取自定义的处理器
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    if (handler == null) {
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
        return null;
    }
    //根据自定义的处理器解析自定义标签
    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

将步骤总结如下

1. 获取元素所在命名空间
2. 根据命名空间获取自定义的命名空间处理器
3. 根据自定义的命名空间处理器解析自定义标签

获取元素所在命名空间

/**
 * 获取给定节点的命名空间
 */
@Nullable
public String getNamespaceURI(Node node) {
    return node.getNamespaceURI();
}

可见在封装Document实例时就已经将命名空间封装到Node中了。

根据命名空间获取自定义的命名空间处理器
DefaultNamespaceHandlerResolver.resolve(String)

/**
 * 在配置映射中定位指定命名空间的命名空间处理器
 */
@Override
public NamespaceHandler resolve(String namespaceUri) {
    //获取所有的handler映射
    Map<String, Object> handlerMappings = getHandlerMappings();
    //根据命名空间在handler映射中找到对应handler，或者handler的类名
    Object handlerOrClassName = handlerMappings.get(namespaceUri);
    //如果没有获取到handler或其类名，返回null
    if (handlerOrClassName == null) {
        return null;
    }
    else if (handlerOrClassName instanceof NamespaceHandler) {//如果获取到了handler，强转后直接返回
        return (NamespaceHandler) handlerOrClassName;
    }
    else {//如果获取到了handler类名
        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);
            //调用自定义的初始化方法
            namespaceHandler.init();
            //将handler记录在映射表中
            handlerMappings.put(namespaceUri, namespaceHandler);
            return namespaceHandler;
        }
        catch (ClassNotFoundException ex) {
            throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +
                    namespaceUri + "] not found", ex);
        }
        catch (LinkageError err) {
            throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +
                    namespaceUri + "]: problem with handler class file or dependent class", err);
        }
    }
}

将步骤总结为

1. 获取所有的handler映射
2. 根据命名空间在handler映射中找到对应handler，或者handler的类名
3. 如果没有获取到handler或其类名，返回null
4. 如果获取到了handler，强转后直接返回
5. 如果获取到了handler类名，通过反射将类名转化为类，初始化类，将handler记录在映射表中，返回handler。

有必要看下如何“获取所有的handler映射”。

private Map<String, Object> getHandlerMappings() {
    Map<String, Object> handlerMappings = this.handlerMappings;
    if (handlerMappings == null) {
        synchronized (this) {
            handlerMappings = this.handlerMappings;
            if (handlerMappings == null) {
                try {
                    Properties mappings =
                            PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Loaded NamespaceHandler mappings: " + mappings);
                    }
                    Map<String, Object> mappingsToUse = new ConcurrentHashMap<>(mappings.size());
                    CollectionUtils.mergePropertiesIntoMap(mappings, mappingsToUse);
                    handlerMappings = mappingsToUse;
                    this.handlerMappings = handlerMappings;
                }
                catch (IOException ex) {
                    throw new IllegalStateException(
                            "Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
                }
            }
        }
    }
    return handlerMappings;
}

经过跟踪，找到这行代码。

    /**
     * The location to look for the mapping files. Can be present in multiple JAR files.
     */
    public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers";

根据自定义的命名空间处理器解析自定义标签
获取到自定义命名空间解析器后，就可以使用它来解析自定义标签了（handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));）。但如果自定义解析器中并没有实现prase方法，那只能在父类中找了。
NamespaceHandlerSupport.parse(Element, ParserContext)

@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
    //寻找解析器
    BeanDefinitionParser parser = findParserForElement(element, parserContext);
    //解析并返回
    return (parser != null ? parser.parse(element, parserContext) : null);
}

先看下如何寻找解析器

@Nullable
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
    //获取元素名称
    String localName = parserContext.getDelegate().getLocalName(element);
    //根据元素名称找到解析器
    BeanDefinitionParser parser = this.parsers.get(localName);
    //如果找不到解析器，抛出异常
    if (parser == null) {
        parserContext.getReaderContext().fatal(
                "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
    }
    return parser;
}

再看下解析过程
AbstractBeanDefinitionParser.parse(Element, ParserContext)

@Override
public final BeanDefinition parse(Element element, ParserContext parserContext) {
    AbstractBeanDefinition definition = parseInternal(element, parserContext);
    if (definition != null && !parserContext.isNested()) {
        try {
            String id = resolveId(element, definition, parserContext);
            if (!StringUtils.hasText(id)) {
                parserContext.getReaderContext().error(
                        "Id is required for element '" + parserContext.getDelegate().getLocalName(element)
                                + "' when used as a top-level tag", element);
            }
            String[] aliases = null;
            if (shouldParseNameAsAliases()) {
                String name = element.getAttribute(NAME_ATTRIBUTE);
                if (StringUtils.hasLength(name)) {
                    aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
                }
            }
            BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
            registerBeanDefinition(holder, parserContext.getRegistry());
            if (shouldFireEvents()) {
                BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
                postProcessComponentDefinition(componentDefinition);
                parserContext.registerComponent(componentDefinition);
            }
        }
        catch (BeanDefinitionStoreException ex) {
            String msg = ex.getMessage();
            parserContext.getReaderContext().error((msg != null ? msg : ex.toString()), element);
            return null;
        }
    }
    return definition;
}

对自定义标签的解析的学习到这里就结束了。到目前为止，已经学习了Spring中全部的解析工作，也就是如何将Bean从配置文件加载到内存。接下来会学习如何使用这些bean。