自定义标签🏷解析

整体流程

如果不是默认的命名空间，比如是：http://www.springframework.org/schema/aop 那么就会进入自定义解析方法。
在阅读代码前，首先了解下自定义标签如何使用？ 附录2 - 自定义标签🏷
然后再继续看解析源码：

@Nullable
public BeanDefinition parseCustomElement(Element ele) {
    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. 然后获取自定义标签的处理器，通过 DefaultNamespaceHandlerResolver 来解析命令空间获取对应的解析器。

3. 标签解析；

   获取命名空间

   这一步不用我们过多的处理，调用的是 jdk Node 的方法。org.w3c.dom.Node 提供了对应的方法；

   String namespaceUri = getNamespaceURI(ele);

   public String getNamespaceURI(Node node) {
    return node.getNamespaceURI();
   }

   获取自定义标签处理器

   NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);

   3. 解析 XML 文档 - registerBeanDefinitions 可以得知 XmlReaderContext 的由来。
   所以 this.readerContext.getNamespaceHandlerResolver() 这块其实就是获取到了 DefaultNamespaceHandlerResolver
   然后通过 resolve 方法得到对应命名空间的处理器。源码如下：
   org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver#resolve

   @Override
   @Nullable
   public NamespaceHandler resolve(String namespaceUri) {
    // 获取所有的handlers
    Map<String, Object> handlerMappings = getHandlerMappings();
    // 根据命名空间获取处理器
    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对象
            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);
            // 处理器初始化各种标签的解析器到父类的缓存中,
            // private final Map<String, BeanDefinitionParser> parsers = new HashMap<>()
            namespaceHandler.init();
            // 添加到映射中
            handlerMappings.put(namespaceUri, namespaceHandler);
            return namespaceHandler;
        }
        catch (ClassNotFoundException ex) {
            throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
                    "] for namespace [" + namespaceUri + "]", ex);
        }
        catch (LinkageError err) {
            throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
                    className + "] for namespace [" + namespaceUri + "]", err);
        }
    }
   }

4. 首先获取所有的自定义标签处理器；

org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver#resolve

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

用于获取 jar 中这个位置 META-INF/spring.handlers 配置的处理器，比如 aop 包下的这个文件 spring.handlers 如下：

spring.handlers 文件定义的就是命名空间-对应的处理器。

http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler

1. 得到处理器后，会立刻执行 init 方法初始化对应的 BeanDefinitionParser；

2. 将得到的处理器添加到缓存中。

   自定义标签解析

   return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));

   得到命名空间对应的处理器后，开始执行解析。

   找到自定义解析器

   这个时候我们的自定义标签解析器已经初始化完毕，该方法调用的父类的方法如下，需要先找到自定义解析器。
   org.springframework.beans.factory.xml.NamespaceHandlerSupport#parse

   @Override
   @Nullable
   public BeanDefinition parse(Element element, ParserContext parserContext) {
    BeanDefinitionParser parser = findParserForElement(element, parserContext);
    return (parser != null ? parser.parse(element, parserContext) : null);
   }

   进入方法 findParserForElement
   org.springframework.beans.factory.xml.NamespaceHandlerSupport#findParserForElement

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

3. 首先找到 localName ，这个其实就是 中的 keyboard；

4. 然后根据这个 localName 从注册的解析器中找到对应的解析器返回；

   标签解析

   @Override
   @Nullable
   public BeanDefinition parse(Element element, ParserContext parserContext) {
    // 得到自定义解析器
    BeanDefinitionParser parser = findParserForElement(element, parserContext);
    // 执行解析
    return (parser != null ? parser.parse(element, parserContext) : null);
   }

   得到解析器后，开始执行解析操作。
   来到了父类的方法
   org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#parse

   @Override
   @Nullable
   public final BeanDefinition parse(Element element, ParserContext parserContext) {
    // 得到 AbstractBeanDefinition
    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;
   }

这段代码分成了两部分：

• 第一部分通过 parseInternal 解析得到 AbstractBeanDefinition；
• 第二部分将 AbstractBeanDefinition 转换成 BeanDefinitionHolder，并注册 bean；

第一部分间接的使用了我们自定义解析器的自定义解析方法，但在使用之前还做了一些准备工作。
org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser#parseInternal

@Override
protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    // bean定义构建器，创建一个空的 AbstractBeanDefinition
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
    String parentName = getParentName(element);
    if (parentName != null) {
        builder.getRawBeanDefinition().setParentName(parentName);
    }
    // 获取标签对应的 bean Class
    // org.springframework.transaction.interceptor.TransactionInterceptor
    Class<?> beanClass = getBeanClass(element);
    if (beanClass != null) {
        builder.getRawBeanDefinition().setBeanClass(beanClass);
    } else {
        String beanClassName = getBeanClassName(element);
        if (beanClassName != null) {
            builder.getRawBeanDefinition().setBeanClassName(beanClassName);
        }
    }
    builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
    BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
    if (containingBd != null) {
        // Inner bean definition must receive same scope as containing bean.
        builder.setScope(containingBd.getScope());
    }
    // 是否懒加载，默认false
    if (parserContext.isDefaultLazyInit()) {
        // Default-lazy-init applies to custom bean definitions as well.
        builder.setLazyInit(true);
    }
    doParse(element, parserContext, builder);
    return builder.getBeanDefinition();
}

这些准备工作包括：创建默认的 GenericBeanDefinition、得到Class、是否使用父类的scope、配置懒加载。按照加载默认标签的方式准备工作都完事了后，调用 doParse 应用用户自定义的解析方法。
（所以 doParse 中只关心自己的逻辑，其他的工作 spring 帮你做好了，熟悉吗？模板方式模式。）