目录标题
前言
在之前的章节中，我们提到了在 Spring 中存在默认标签与自定义标签两种，而在上一章节中我们分析了 Spring 中对默认标签的解析过程，相信大家一定已经有所感悟。那么，现在将开始新的里程，分析 Spring 中自定义标签的加载过程。
一、自定义标签使用
在分析Spring的自定义标签源码之前，我们可以自己手写一个自定义标签：
【Spring学习】Spring自定义标签详细步骤
二、自定义标签解析
1、代码入口
DefaultBeanDefinitionDocumentReader的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);
}
}
2、parseCustomElement【BeanDefinitionParserDelegate】
@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
// 获取自定义标签的命名空间
String namespaceUri = getNamespaceURI(ele);
if (namespaceUri == null) {
return null;
}
// 根据命名空间，获取对应的'自定义标签处理器'（spring.handlers）
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler == null) {
error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
return null;
}
// 进行解析（NamespaceHandlerSupport的parse方法）
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}
2.1 resolve【DefaultNamespaceHandlerResolver】
此处会调用子类的init方法，用于【注册解析器】。
public NamespaceHandler resolve(String namespaceUri) {
// 格式：Map<NameSpace,HandlerClassPathName>
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<?> 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);
// 调用MyNamespaceHandler的init方法。注册解析器：registerBeanDefinitionParser("user", new UserBeanDefinitionParser());
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);
}
}
}
3、parse【NamespaceHandlerSupport】
@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
// 该自定义标签的解析器
BeanDefinitionParser parser = findParserForElement(element, parserContext);
// 调用AbstractBeanDefinitionParser中的parse方法
return (parser != null ? parser.parse(element, parserContext) : null);
}
4、parse【AbstractBeanDefinitionParser】
public final BeanDefinition parse(Element element, ParserContext parserContext) {
// (重点)parseInternal是真正做解析的方法。 AbstractSingleBeanDefinitionParser
//在 parseInternal 中并不是直接调用自定义的 doParse 函数，而是进行了一系列的数据准备，包括对 beanClass、 scope、lazyInit 等属性的准备。
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);
// 注册definition 和 alias
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;
}
4.1 parseInternal【AbstractSingleBeanDefinitionParser】
此处会调用doParse方法，用于【解析自定义标签】。
protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
String parentName = getParentName(element);
if (parentName != null) {
builder.getRawBeanDefinition().setParentName(parentName);
}
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());
}
if (parserContext.isDefaultLazyInit()) {
// Default-lazy-init applies to custom bean definitions as well.
builder.setLazyInit(true);
}
// （关键）调用子类的doParse方法。 自定义解析器的doParse方法
doParse(element, parserContext, builder);
return builder.getBeanDefinition();
}
总结
回顾一下全部的自定义标签处理过程，虽然在实例中我们定义 UserBeanDefinitionParser，但是在其中我们只是做了与自己业务逻辑相关的部分。不过我们没做但是并不代表没有，在这个处理过程中同样也是按照 Spring 中默认标签的处理方式进行，包括创建 BeanDefinition 以及进行相应默认属性的设置，对于这些工作 Spring 都默默地帮我们实现了，只是**暴露出一些接口来供用户实现个性化的业务**。
通过对本章的了解，相信读者对 Spring 中自定义标签的使用以及在解析自定义标签过程中 Spring 为我们做了哪些工作会有一个全面的了解。到此为止我们已经完成了 Spring 中全部的解析工作，也就是说到现在为止我们已经理解了 Spring 将 bean 从配置文件到加载到内存中的全过程，而接下来的任务便是如何使用这些 bean，下一章将介绍 bean的加载。