1. 解析的切入点
Spring配置文件会被转换成Document对象，并且获得对应的根节点root之后，开始了标签的解析工作。
2. 具体的解析过程
2.1 如何判定是自定义标签
核心代码如下:
/**
* Parse the elements at the root level in the document:
* "import", "alias", "bean".
* @param root the DOM root element of the document
*/
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);
}
}
这里判定是否为默认标签的方法为delegate.isDefaultNamespace(root),核心代码如下：
public boolean isDefaultNamespace(Node node) {
return isDefaultNamespace(getNamespaceURI(node));
}
public boolean isDefaultNamespace(String namespaceUri) {
return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));
}
public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";
其实就是根据配置文件的命名空间来判定，如果是beans下的则认为是默认的命名空间，如果不是则认为是自定义的，我们使用的Aop、Tx等都是属于自定义标签的范畴。
2.2 具体解析过程
代码如下：
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
String namespaceUri = getNamespaceURI(ele);
// 根据命名空间找到对应的NamespaceHandler
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler == null) {
error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
return null;
}
// 调用自定义的NamespaceHandler进行解析
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}
这里解析过程又分为三个步骤：
1.获取配置文件的命名空间
2.根据命名空间获取对应的Handler
3.通过Handler调用自定义标签的解析逻辑。
2.2.1 获取命名空间
/**
* Get the namespace URI for the supplied node.
* The default implementation uses {@link Node#getNamespaceURI}.
* Subclasses may override the default implementation to provide a
* different namespace identification mechanism.
* @param node the node
*/
public String getNamespaceURI(Node node) {
return node.getNamespaceURI();
}
这里获取命名空间是通过W3C标准的DOM解析完成的，比较简单没有什么可说的。
2.2.2 获取Handler的过程
/**
* Locate the {@link NamespaceHandler} for the supplied namespace URI
* from the configured mappings.
* @param namespaceUri the relevant namespace URI
* @return the located {@link NamespaceHandler}, or {@code null} if none found
*/
@Override
public NamespaceHandler resolve(String namespaceUri) {
// 默认获取META-INF/spring.handlers下所有handler映射
Map handlerMappings = getHandlerMappings();
// 通过命名空间获取对应的Handler
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");
}
// 初始化handler
NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
// 调用初始化方法，注册自定义标签解析器
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通过spring.handlers文件读取，经过一系列的过程已经被初始化。
2.2.3 Handler调用自定义标签的解析
继续剖析自定义的解析器是如何作用于自定义标签的，这里以类NamespaceHandlerSupport为基础进行剖析。
上面获取到标签对应的Handler之后，紧接着调用如下的方法：
/**
* Parses the supplied {@link Element} by delegating to the {@link BeanDefinitionParser} that is
* registered for that {@link Element}.
*/
@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
// 1.寻找解析器
// 2.调用自定义解析器parse方法
return findParserForElement(element, parserContext).parse(element, parserContext);
}
这里执行的过程分为两步:
1.获取元素对应的自定义解析器
2.执行handler.parse(...)方法;
2.2.3.1 获取元素对应的自定义解析器
/**
* Locates the {@link BeanDefinitionParser} from the register implementations using
* the local name of the supplied {@link Element}.
*/
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
// 获取元素名称
String localName = parserContext.getDelegate().getLocalName(element);
// 通过元素名称在parsers中找到自定义的解析器
BeanDefinitionParser parser = this.parsers.get(localName);
if (parser == null) {
parserContext.getReaderContext().fatal(
"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
}
return parser;
}
这里一个很关键的parsers变量，Map的数据结构维护了元素的名称和它的解析器对象的映射关系，代码如下：
/**
* Stores the {@link BeanDefinitionParser} implementations keyed by the
* local name of the {@link Element Elements} they handle.
*/
private final Map parsers =
new HashMap<>();
这里可能会有疑问：他们的关系是怎么建立起来的呢？
这个要回过头看到获取Handler的过程中有这么一段代码：
// 调用初始化方法，注册自定义标签解析器
namespaceHandler.init();
这个init()就是预留了一个注册自定义注解解析器的接口，下面以Spring Aop模块中的自定义标签为例分析，代码如下：
public class AopNamespaceHandler extends NamespaceHandlerSupport {
/**
* Register the {@link BeanDefinitionParser BeanDefinitionParsers} for the
* '{@code config}', '{@code spring-configured}', '{@code aspectj-autoproxy}'
* and '{@code scoped-proxy}' tags.
*/
@Override
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());
}
}
可以看到这里注册了几个的常见元素的自定义解析器,这里又调用了父类NamespaceHandlerSupport中的registerBeanDefinitionParser方法,注册方法代码如下：
/**
* Subclasses can call this to register the supplied {@link BeanDefinitionParser} to
* handle the specified element. The element name is the local (non-namespace qualified)
* name.
*/
protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
this.parsers.put(elementName, parser);
}
到这里就将元素和自定义解析器的关系通过parsers维护了起来,到这里具体的自定义标签解析器已经找到。下面看下自定义的解析器是如何被调用的。
2.2.3.2 自定义解析器执行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) {
parserContext.getReaderContext().error(ex.getMessage(), element);
return null;
}
}
return definition;
}
注意第一行这里又调用了parseInternal(),代码如下：
@Override
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));
// 如果有父类,则使用父类的scope属性
if (parserContext.isNested()) {
// Inner bean definition must receive same scope as containing bean.
builder.setScope(parserContext.getContainingBeanDefinition().getScope());
}
// 设定延迟加载
if (parserContext.isDefaultLazyInit()) {
// Default-lazy-init applies to custom bean definitions as well.
builder.setLazyInit(true);
}
// 这里又调用了doParse(element, builder),也就是我们自己实现的解析方法。
doParse(element, parserContext, builder);
return builder.getBeanDefinition();
}
在代码最后的位置调用了doParse(element, builder)也就是我们自己定义的解析实现,至此整个自定义的标签已经解析完成。