文章目录
自定义标签的解析
在上文中完成了Spring中对默认标签的解析过程的分析，现在继续Spring中自定义标签的解析。delegate.parseCustomElement(ele);
在自定义标签的解析之前，先学习一下自定义标签的使用。
1. 自定义标签的使用
- 创建一个POJO的User类：
public class User {
private String id;
private String name;
private Integer age;
// 省略 set/get 方法
}
- 创建一个XSD文件描述组件内容：
user.xsd
<schema xmlns="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.baidu.com/user"
elementFormDefault="qualified">
<element name="user">
<complexType>
<attribute name="id" type="string"/>
<attribute name="name" type="string"/>
<attribute name="age" type="integer"/>
</complexType>
</element>
</schema>
这个XSD文件中指定了一个新的targetNamespace（不存在也没有关系，因为我们会从本地去寻找对应的文件，第一篇文章中讲过的EntityResolver）；并且在这个命名空间中定义了一个name为user的element，user有三个属性：id、name、age；主要用于验证Spring配置文件中自定义标签的格式。
- 创建一个UserBeanDefinitionParser类，实现AbstractSingleBeanDefinitionParser接口，用于解析XSD文件中的定义和自定义组件的定义：
public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
@Override
protected Class<?> getBeanClass(Element element) {
return User.class;
}
@Override
protected void doParse(Element element, BeanDefinitionBuilder builder) {
// 从element中获取对应元素的数据
String id = element.getAttribute("id");
String name = element.getAttribute("name");
String age = element.getAttribute("age");
// 将提取的数据进行处理之后，放到BeanDefinitionBuilder中，等到所有bean解析后统一注册到BeanFactory中；
if (StringUtils.hasText(id)) {
builder.addPropertyValue("id", id + 1);
}
if (StringUtils.hasText(name)) {
builder.addPropertyValue("name", name + 1);
}
if (StringUtils.hasText(age)) {
builder.addPropertyValue("age", age + 1);
}
}
}
- 创建一个MyNamespaceHandler文件，扩展自NamespaceHandlerSupport，用于把自定义的组件的解析器注册到Spring容器：
public class MyNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init() {
registerBeanDefinitionParser("user", new UserBeanDefinitionParser());
}
}
spring.handlers
http\://www.baidu.com/user=org.bgy.spring.study.spring.bean.definition.custom.bean.MyNamespaceHandler
spring.schemas
http\://www.baidu.com/user.xsd=META-INF/user.xsd
- 创建配置文件，在配置文件中引入对应的命名空间以及XSD，并且配置自定义组件：
custom-bean-context.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:myname="http://www.baidu.com/user"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.baidu.com/user http://www.baidu.com/user.xsd">
<myname:user id="user" name="bgy" age="25"/>
</beans>
- 创建测试类：
public class CustomBeanTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:META-INF/custom-bean-context.xml");
User user = (User)applicationContext.getBean("user");
System.out.println(user);
}
}
// output: User{id='user1', name='bgy1', age=251}
可以看到输出了配置文件中的配置值，通过自定义标签实现了通过属性的方式将user类型的Bean注入到Spring容器并赋值。在Spring中自定义标签非常有用，比如：事务标签: <tx:annotation-driven>、切面标签：<aop:config>等。
Spring中加载自定义标签的大致流程：
遇到自定义标签之后就根据配置文件中的命名空间，去spring.handlers和spring.schemas文件中去找对应的handler以及解析元素的parser，从而完成整个自定义元素的解析。
2. 自定义标签的解析
在了解了自定义标签的使用之后，再来看看Spring中是怎么解析的。
BeanDefinitionParserDelegate.java
public BeanDefinition parseCustomElement(Element ele) {
return parseCustomElement(ele, null);
}
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
// 获取对应的命名空间
String namespaceUri = getNamespaceURI(ele);
if (namespaceUri == null) {
return null;
}
// 根据命名空间找到对应的 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));
}
2.1 获取自定义标签的命名空间
public String getNamespaceURI(Node node) {
return node.getNamespaceURI();
}
从custom-bean-context.xml配置文件中的 xmlns:myname="http://www.baidu.com/user"行可以得到，我们这个自定义标签的命名空间为：http://www.baidu.com/user
2.2 获取自定义标签的自定义处理器
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
DefaultNamespaceHandlerResolver.java
public NamespaceHandler resolve(String namespaceUri) {
// 获取所有已经配置的 handler 映射；
// 在 Spring.handlers 中配置了 命名空间与命名空间处理器的映射关系
// getHandlerMappings() 作用：读取 Spring.handlers 配置文件并将配置文件缓存在map中
Map<String, Object> handlerMappings = getHandlerMappings();
// 根据命名空间找到对应的信息（可能是handler 或者是 类路径）
Object handlerOrClassName = handlerMappings.get(namespaceUri);
if (handlerOrClassName == null) {
return null;
} else if (handlerOrClassName instanceof NamespaceHandler) {
// 如果已经做过解析的情况，就是handler，直接返回
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);
// 调用自定义的NamespaceHandler 的初始化方法
namespaceHandler.init();
// 把解析出来的handler，放入map缓存
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);
}
}
}
这个方法主要就是通过自定义标签的命名空间，获取到对应的处理器handler。在这里我们对于自定义的命名空间，配置了对应的自定义处理器。
2.2.1 获取handlerMappings
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 {
// this.handlerMappingsLocation 在构造函数中已经被设置成了 DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers"
// 使用工具类 PropertiesLoaderUtils，读取 spring.handlers 中的配置，并转化成 Properties
Properties mappings = PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
if (logger.isTraceEnabled()) {
logger.trace("Loaded NamespaceHandler mappings: " + mappings);
}
handlerMappings = new ConcurrentHashMap<>(mappings.size());
// 将 Properties 配置文件中的各个 K-V，转换到 handlerMappings(map)中
CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
// 设置map
this.handlerMappings = handlerMappings;
} catch (IOException ex) {
throw new IllegalStateException(
"Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
}
}
}
}
return handlerMappings;
}
上面主要就是通过PropertiesLoaderUtils工具类对属性handlerMappingsLocation进行配置文件的读取，拿到spring.handlers文件中配置的命名空间与处理器的映射关系，并转换到handlerMappings中。
2.2.2 通过namespaceUri获取NamespaceHandler
Object handlerOrClassName = handlerMappings.get(namespaceUri);
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);
// 调用自定义的NamespaceHandler 的初始化方法
namespaceHandler.init();
// 把解析出来的handler，放入map缓存
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);
}
}
首先根据 namespaceUri通过缓存 handlerMappings拿到我们配置的自定义处理器（返回的是类路径）：org.bgy.spring.study.spring.bean.definition.custom.bean.MyNamespaceHandler。
再通过反射将类路径初始化为具体的类，并且调用 namespaceHandler.init() 方法来进行自定义 UserBeanDefinitionParser的注册。
在这里可以注册多个标签解析器，当前示例中只注册了支持 <myname:user>写法的标签，还可以注册如：<myname:A>、<myname:B>等的标签，使得myname的命名空间中可以支持多种标签的接。
2.3 解析自定义标签
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
到了这里，handler已经被实例化成了我们自定义的处理器 MyNamespaceHandler，并且MyNamespaceHandler已经完成了初始化工作；然后将解析的工作委托给自定义解析器去解析。
但是我们自定义的处理器中并没有实现parse()方法，所以这个方法应该是父类中的实现。
2.3.1 获取自定义标签的自定义解析器
NamespaceHandlerSupport.java
public BeanDefinition parse(Element element, ParserContext parserContext) {
// 寻找解析器
BeanDefinitionParser parser = findParserForElement(element, parserContext);
// 进行解析
return (parser != null ? parser.parse(element, parserContext) : null);
}
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
// 获取元素名称，也就是示例中 <myname:user 中的 user，此时 localName为 user
String localName = parserContext.getDelegate().getLocalName(element);
// 根据user找到对应的解析器，也就是在 MyNamespaceHandler 的 init() 方法中注册的 UserBeanDefinitionParser实例
BeanDefinitionParser parser = this.parsers.get(localName);
if (parser == null) {
parserContext.getReaderContext().fatal(
"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
}
return parser;
}
首先是寻找元素对应的解析器，进而调用解析器中的parse()方法。
在这里就是根据<myname:user>标签中的user获取到 MyNamespaceHandler中的init()方法中注册的对应的 UserBeanDefinitionParser的实例，并调用其parse()方法进行解析。
但是我们自定义的解析器UserBeanDefinitionParser中也没有实现parse()方法，所以这个方法也应该是父类的实现：
2.3.2 调用父类解析器进行解析
AbstractBeanDefinitionParser.java
public final BeanDefinition parse(Element element, ParserContext parserContext) {
AbstractBeanDefinition definition = parseInternal(element, parserContext);
// 以下代码都是用来将解析后的 AbstractBeanDefinition 转化成 BeanDefinitionHolder,并注册 BeanDefinition
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;
}
这个方法中大部分的代码都是处理将解析后的 AbstractBeanDefinition转化成 BeanDefinitionHolder并且注册的功能，真正解析的工作是在 parseInternal()方法中完成的：
protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
String parentName = getParentName(element);
if (parentName != null) {
builder.getRawBeanDefinition().setParentName(parentName);
}
// 获取自定义标签中的class，示例中此时会调用 UserBeanDefinitionParser 的getBeanClass()方法
Class<?> beanClass = getBeanClass(element);
if (beanClass != null) {
builder.getRawBeanDefinition().setBeanClass(beanClass);
}
else {
// 如果子类没有重写这个 getBeanClass()方法，则尝试检查子类是否重写 getBeanClassName()方法
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.
// 如果存在父类，则使用父类的 scope 属性
builder.setScope(containingBd.getScope());
}
if (parserContext.isDefaultLazyInit()) {
// 配置延迟加载
// Default-lazy-init applies to custom bean definitions as well.
builder.setLazyInit(true);
}
// 调用 UserBeanDefinitionParser 中重写的 doParse() 方法，进行最后的解析；
doParse(element, parserContext, builder);
return builder.getBeanDefinition();
}
这里先是创建了一个BeanDefinitionBuilder的实例builder，并且获取到 beanClass、scope、lazyInit等属性并设置进builder中，再调用子类（我们的实现类UserBeanDefinitionParser）中重写的doParse()方法进行解析，解析之后返回一个 AbstractBeanDefinition的实例。
在拿到了AbstractBeanDefinition实例后面的解析步骤为：创建一个 BeanDefinitionHolder 的实例，然后调用BeanDefinitionReaderUtils的registerBeanDefinition()方法进行注册。其实就又回到了上一篇文章Spring——2. 默认标签的解析中的 1.3 注册解析到的BeanDefinition。
到此为止，已经完成了Spring将bean从配置文件加载到内存的全部过程的解析，接下来就是对于bean本身的加载了。
3. 整体流程思维导图
最后附上一个整体流程的思维导图：Spring容器初始化体系，本篇文章对应其中的 自定义标签的解析 部分。
111
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
