导语
前面已经通过两篇文章说了一下bean标签的解析,感兴趣的同学可以去看一下(Spring源码深度解析系列——bean标签解析《一》和Spring源码深度解析系列——bean标签解析《二》),而这两篇是关于默认标签解析的,既然存在默认的,那么自然就有自定义的了,本篇文章便开始自定义标签的解析。首先来回顾下bean解析初始代码吧!
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
// 对Bean的处理
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)) {
// 对Bean的处理
parseDefaultElement(ele, delegate);
}
else {
// 对Bean的处理
delegate.parseCustomElement(ele);
}
}
}
}
else {
// 自定义标签解析
delegate.parseCustomElement(root);
}
}
既然本篇是说自定义标签,自然是从delegate.parseCustomElement(root)开始了,那我们就开始自定义标签解析之旅吧!
一、自定义标签的使用
既然要说原理,自然要说下使用,毕竟使用是源码入门的源头,那我们就不多说废话了,先来个示例来看看。
1.首先创建一个类
public class Student {
private String id;
private String Name;
private int age;
// 省略set、get方法
}
2.定义一个XSD组件内容
<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.lexueba.com/schema/student"
xmlns:tns="http://www.lexueba.com/schema/student"
elementFormDefault="qualified">
<element name="student">
<complexType>
<attribute name="id" type="string"/>
<attribute name="name" type="string"/>
<attribute name="age" type="int"/>
</complexType>
</element>
</schema>
在上面的代码中,描述了一个新的targetNamespace,并定义了那么为student的element,user有三个属性,这三个类主要用于验证Spring配置文件中自定义格式。XSD文件是XML DTD的替代者,使用XML Schema语言进行编写。
3.创建一个类,实现BeanDefinitionParserDelegate接口,用来解析XSD文件中的定义和组件定义
package com.zfy.spring.test.parser;
import com.zfy.spring.test.bean.Student;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;
/**
* @Description TODO
* @Author zfy
* @Date 2019/7/16 13:45
*/
public class StudentBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
// Element对应的类
protected Class getBeanClass(Element element) {
return Student.class;
}
// 从element中解析并提取对应的元素
protected void doParse(Element element, BeanDefinitionBuilder beanDefinitionBuilder) {
String name = element.getAttribute("name");
String age = element.getAttribute("age");
// 将提取的数据放到BeanDefinitionBuilder中,待完成所有bean的解析后统一注册到BeanFactory中
if (StringUtils.hasText(name)) {
beanDefinitionBuilder.addPropertyValue("name",name);
}
if (StringUtils.hasText(age)) {
beanDefinitionBuilder.addPropertyValue("age",age);
}
}
}
4.创建一个Handler文件,扩展子NamespaceHandlerSupport,目的是将组件注册到Spring容器中
package com.zfy.spring.test.handler;
import com.zfy.spring.test.parser.StudentBeanDefinitionParser;
import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
/**
* @Description TODO
* @Author zfy
* @Date 2019/7/16 13:55
*/
public class MyNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init() {
registerBeanDefinitionParser("student", new StudentBeanDefinitionParser());
}
}
上面代码的作用就是当遇到自定义标签<student:name这样类似于student开头的元素,就会把这个元素扔给对应的StudentBeanDefinitionParserDelegate去解析。
5.编写Spring.handlers和Spring.schemas文件,默认位置是在工程的/META-INF/文件夹下,当然也可以通过Spring的扩展或者修改源码的方式去改变路径。
Spring.handlers:
http\://www.lexueba.com/schema/student=test.customtag.MyNamespaceHandler
Spring.schemas:
http\://www.lexueba.com/schema/student=student.xsd=META-INF/Spring-test.xsd
6.创建配置文件
<?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.lexueba.com/schema/student"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.lexueba.com/schema/student http://www.lexueba.com/schema/student.xsd">
<myname:student id="testbean" name="aaa" age="11" />
</beans>
7.测试类
@Test
public void stringTest() {
BeanFactory bf = new XmlBeanFactory(new ClassPathResource("springTest.xml"));
Student st = (Student) bf.getBean("student");
System.out.println(st.getName() + "," + st.getAge());
}
二、自定义标签解析
上面是自定义标签的基本使用,那么现在就开始真正的解析过程吧。
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));
}
1.获取标签命名空间
标签解析是从命名空间开始的,无论是默认标签和自定义标签,还是区分自定义标签中不同标签的处理器,都是以标签锁提供的命名标签为基础,但对于提取元素的命名空间其实并不需要我们自己去实现的,在这里已经提供了方法:
public String getNamespaceURI(Node node) {
return node.getNamespaceURI();
}
2.提取自定义标签处理器
有了命名空间后,便可以进行NamespaceHandler的提取了,这里可以继续之前的parseCustomerElement函数的跟踪了,分析 NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri) ,在readerContext初始化的时候其属性namespaceHandlerResolver已经被初始化为DefaultNamespaceHandlerResolver的实例了,因此这里调用的resolve方法其实调用的是DefaultNamespaceHandlerResolver类中的方法,那我们来看下resolve的方法:
public NamespaceHandler resolve(String namespaceUri) {
// 获取所有已经配置的handler映射
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);
// 调用自定义的NamespaceHandler的init方法
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);
}
}
}
上面的代码中清楚的体现了关于解析自定义NamespaceHandler的过程,通过之前的示例可以了解如果使用自定义标签,那么其中不可少的一项就是Spring.handlers文件中配置命名空间与命名空间处理器之间的映射关系。也只有这样,Spring才能根据映射关系找到匹配的处理器,而寻找匹配处理器便是在上面代码中实现的,在获取到自定义的NamespaceHandler后,就可以进行处理器的初始化解析了。
在得到自定义的命名空间处理器后,会立马执行namespaceHandler.init()。在注册后,命名空间处理器就可以根据标签来调用不同的解析器进行解析。根据上面的代码和前面的实例,这里其实可以推测 getHandlerMappings 这个方法的主要功能就是读取Spring.handlers中的配置,并缓存到map中。
private Map<String, Object> getHandlerMappings() {
Map<String, Object> handlerMappings = this.handlerMappings;
// 如果没有被缓存,则开始进行缓存
if (handlerMappings == null) {
synchronized (this) {
handlerMappings = this.handlerMappings;
if (handlerMappings == null) {
if (logger.isDebugEnabled()) {
logger.debug("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");
}
try {
// this.handlerMappingsLocation在构造函数中已经被初始化为:META-INF/Spring,handlers
Properties mappings =
PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
if (logger.isDebugEnabled()) {
logger.debug("Loaded NamespaceHandler mappings: " + mappings);
}
handlerMappings = new ConcurrentHashMap<>(mappings.size());
// 将Properties格式文件合并到Map格式的handlerMapping中
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;
}
3.标签解析
在得到解析器以及要解析的元素后,Spring就可以将解析的工作委托给自定义解析器去解析了。
handler.parse(ele, new ParserContext(this.readerContext, this, containingBd))
此时handler其实已经被实例化倒了我们自定义的MyNamespaceHandler中了,而MyNamespaceHandler也已经完成了初始化的工作,但是我们自定义的这个类中并没有parse方法,因此可以确定这个方法是在父类中实现的。
public BeanDefinition parse(Element element, ParserContext parserContext) {
// 寻找解析器,并进行操作
BeanDefinitionParser parser = findParserForElement(element, parserContext);
return (parser != null ? parser.parse(element, parserContext) : null);
}
findParserForElement(element, parserContext):
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
// 获取元素名称,也就是<myname:user 中的user,如果再示例中,此时的localName就是user
String localName = parserContext.getDelegate().getLocalName(element);
// 根据user找到对应的解析器,也就是在registerBeanDefinitionParser("user",new UserBeanDefinitionParser());注册的解析器。
BeanDefinitionParser parser = this.parsers.get(localName);
if (parser == null) {
parserContext.getReaderContext().fatal(
"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
}
return parser;
}
parse(element, parserContext):
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));
}
}
// 将AbstractBeanDefinition转换为BeanDefinitionHolder,并注册
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,但是在parseInternal中有不是直接调用自定义的函数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,此时会调用自定义解析器,如: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);
}
// 调用子类重写的doParser方法进行解析
doParse(element, parserContext, builder);
return builder.getBeanDefinition();
}
最后来看下其实在自定义标签解析的过程中,虽然我们自己定义了StudentBeanDefinitionParser,但仅仅是做了与自己业务相关的操作,这其中过程也是按照默认标签解析的处理方式去实现的。
参考:Spring源码深度解析(第二版)(郝佳)