[置顶] Spring 源码解析 ---- 自定义标签

零. 阅读准备

读这篇文章前先看下预备知识：Spring 自定义标签




一. 代码阅读
自定义标签解析核心代码：

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
String namespaceUri = getNamespaceURI(ele);
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));
}

可以看出 Spring 代码逻辑很清晰：
getNamespaceURI() 获取自定义标签的 namespace
而后使用 namespace 获取相应处理的 handler
最后由 handler 指定的 parser 来解析自定义的标签

（1） getNamespaceURI() 获取自定义标签的 namespace

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

就是常规的 XML 内容提取

（2）而后使用 namespace 获取相应处理的 handler

debug 到这一步发现是使用了 NamespaceHandlerResolver 的实现类 DefaultNamespaceHandlerResolver 来获取对应的 handler

@Override
public NamespaceHandler resolve(String namespaceUri) {
// 获取所有配置在 spring.handlers 中的映射
Map<String, Object> handlerMappings = getHandlerMappings();
// 从映射关系中取出相应的value
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 方法
namespaceHandler.init();
// 放入缓存
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);
}
}
}

放入缓存后，我们可以看到缓存中已经有了我们为自定义标签新增的 handler：








（3）最后由 handler 指定的 parser 来解析自定义的标签

@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
return findParserForElement(element, parserContext).parse(element, parserContext);
}

private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
// 获取 wenniuwuren:user 中的 user
String localName = parserContext.getDelegate().getLocalName(element);
// 根据 user 找到对应的 parser
BeanDefinitionParser parser = this.parsers.get(localName);
if (parser == null) {
parserContext.getReaderContext().fatal(
"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
}
return parser;
}

@Override
public final BeanDefinition parse(Element element, ParserContext parserContext) {
// 使用自定义的 Parser 将 element 中的东西读取到 BeanDefinition 中
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));
}
}
// 将 AbstractBeanDefinition 转换为 BeanDefinitionHolder
BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
// 注册 holder
registerBeanDefinition(holder, parserContext.getRegistry());
if (shouldFireEvents()) {
BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
postProcessComponentDefinition(componentDefinition);
parserContext.registerComponent(componentDefinition);
}
}
catch (BeanDefinitionStoreException ex) {
parserContext.getReaderContext().error(ex.getMessage(), element);
return null;
}
}
return definition;
}

到此，自定义标签的数据就从配置文件加载到了内存，自定义标签的解析其实就是 Spring 提供给开发者的扩展使用，整体解析过程和 Spring 默认的标签类似。