上一节 我们分析了Spring对默认标签的解析，我们回顾一下，当完成从配置文件到Document的转换并提取到ROOT后，并开始了文件的解析:代码如下
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)) {
this.parseDefaultElement(ele, delegate);//解析默认标签
} else {
delegate.parseCustomElement(ele);//解析自定义标签
}
}
}
} else {
delegate.parseCustomElement(root);//解析自定义标签
}
}
上一节 都是围绕 this.parseDefaultElement(ele, delegate);//解析默认标签这句话展开的 那么 本次就分析下 delegate.parseCustomElement(root);解析自定义标签，分析之前我们就回顾下自定义标签是如何使用的
使用自定义标签
1.创建一个需要扩展的组件
public class User {
private String userName;
private int age;
}
2.定义一个XSD文件描述文件的信息
<?xml version="1.0" encoding="utf-8" ?>
<schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.zhh.com/schema/user"
xml:tns="http://www.zhh.com/schema/user" elementFormDefault="qualified">
<element name="user">
<complexType>
<attribute name="id" type="string"/>
<attribute name="userName" type="string"/>
<attribute name="email" type="string"/>
</complexType>
</element>
</schema>
3.创建一个类实现BeanDefinitionParse接口，用来解析XSD中自定义标签的定义
public class MyElementParse extends AbstractSingleBeanDefinitionParser {
protected Class getBeanClass(){
return User.class;
}
protected void doParse(Element element, BeanDefinitionBuilder beanDefinitionBuilder){
String userName = element.getAttribute("userName");//获取userName
String email = element.getAttribute("email");//获取email
if(StringUtils.hasText(userName)){
beanDefinitionBuilder.addPropertyValue("userName",userName);
}
if(StringUtils.hasText(email)){
beanDefinitionBuilder.addPropertyValue("email",email);
}
}
}
4.创建一个Handle文件扩展来自NamespaceHandlerSupport,目的是将组件注册到Spring中
public class MyNameHandle extends NamespaceHandlerSupport{
@Override
public void init() {
registerBeanDefinitionParser("user",new MyElementParse());
}
}
5.编写Spring.handlers和Spring.schemas文件
Spring.schemas文件
http://www.zhh.com/shema/user.xsd=META-INF/user.xsd
Spring.handlers文件
http://www.zhh.com/shema/user=com.zhh.myHandle.MyNameHandle
6.在xml文件中引用
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:myname="http://www.zhh.com/shcma/user"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.zhh.com/shcma/user http://www.zhh.com/shcma/user.xsd">
<myname:user id="testUser" userName="aaa" email="xxx"/>
</beans>
以上就是自定义标签的使用 首先我们分析一下 delegate.parseCustomElement(root);//解析自定义标签
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
String namespaceUri = this.getNamespaceURI(ele); //获取对应的命名空间
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);//根据对应的命名空间找到NameSpaceHandle
if (handler == null) {
this.error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
return null;
} else {
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));//获取到handle之后 进行解析
}
}
一丶获取对应的命名空间
String nameSpace = this.getNamespaceURI(ele);
org.w3c.dom.Node中已经提供了方法，我们直接调用即可
二丶提取自定义标签处理器
public NamespaceHandler resolve(String namespaceUri) {
//获取所有已经配置的handle
Map<String, Object> handlerMappings = this.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");
} else {
NamespaceHandler namespaceHandler = (NamespaceHandler)BeanUtils.instantiateClass(handlerClass);
namespaceHandler.init();//调用NameSpace子类型的初始化方法
handlerMappings.put(namespaceUri, namespaceHandler);//添加到缓存中
return namespaceHandler;
}
} catch (ClassNotFoundException var7) {
throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "] not found", var7);
} catch (LinkageError var8) {
throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "]: problem with handler class file or dependent class", var8);
}
}
}
上述描述了根据命名空间获取解析器解析的过程，其中Spring.handlers中描述了命名空间 与解析器之间的关系，
根据Spring.handlers 获取命名空间与解析器之键的关系 this.getHandlerMappings();方法
private Map<String, Object> getHandlerMappings() {
if (this.handlerMappings == null) { //如果没有缓存，则开始进行获取
synchronized(this) {
if (this.handlerMappings == null) {
try {
Properties mappings = PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);//将Spring.handlers转换成properties文件 用到了PropertiesLoaderUtils.loadAllProperties 方法
if (this.logger.isDebugEnabled()) {
this.logger.debug("Loaded NamespaceHandler mappings: " + mappings);
}
Map<String, Object> handlerMappings = new ConcurrentHashMap();
CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);//将解析出来的值以Key和value的形式保存在map中并且返回
this.handlerMappings = handlerMappings;
} catch (IOException var4) {
throw new IllegalStateException("Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", var4);
}
}
}
}
return this.handlerMappings;
}
得到了解析器解析器后，Spring 将文件的解析委托给了自定义的解析器去解析
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
此时，MynameSpaceHandle以及完成了初始化的工作，此时并没有真正开始解析 ，解析工作有自定义类 MyElementParse实现
public class MyElementParse extends AbstractSingleBeanDefinitionParser {
protected Class getBeanClass(){
return User.class;
}
protected void doParse(Element element, BeanDefinitionBuilder beanDefinitionBuilder){
String userName = element.getAttribute("userName");
String email = element.getAttribute("email");
if(StringUtils.hasText(userName)){
beanDefinitionBuilder.addPropertyValue("userName",userName);
}
if(StringUtils.hasText(email)){
beanDefinitionBuilder.addPropertyValue("email",email);
}
}
}
我们分析 handler.parse()这个方法
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
String localName = parserContext.getDelegate().getLocalName(element);
//获取元素名称 也就是<myname:user 中的user 也就是在 registerBeanDefinitionParser("user",new MyElementParse()); 注册的解析器
BeanDefinitionParser parser = (BeanDefinitionParser)this.parsers.get(localName);//得到解析器
if (parser == null) {
parserContext.getReaderContext().fatal("Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
}
return parser；//返回
}
而对于
return this.findParserForElement(element, parserContext).parse(element, parserContext);
//中的parse方法的处理
public final BeanDefinition parse(Element element, ParserContext parserContext) {
//将真正的解析 委托给parseInternal 这个方法
AbstractBeanDefinition definition = this.parseInternal(element, parserContext);
if (definition != null && !parserContext.isNested()) {
try {
String id = this.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 = new String[0];
String name = element.getAttribute("name");
if (StringUtils.hasLength(name)) {
aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
}
//将AbstractBeanDefinition 转换成BeanDefinitionHolder并注册功能
BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);//注册bean
this.registerBeanDefinition(holder, parserContext.getRegistry());
if (this.shouldFireEvents()) {
BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
this.postProcessComponentDefinition(componentDefinition);
parserContext.registerComponent(componentDefinition);
}
} catch (BeanDefinitionStoreException var9) {
parserContext.getReaderContext().error(var9.getMessage(), element);
return null;
}
}
return definition;
}
分析parseInternal
protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
String parentName = this.getParentName(element);
if (parentName != null) {
builder.getRawBeanDefinition().setParentName(parentName);
}
Class<?> beanClass = this.getBeanClass(element);//获取BeanClass
if (beanClass != null) {
builder.getRawBeanDefinition().setBeanClass(beanClass);
} else {
String beanClassName = this.getBeanClassName(element);
if (beanClassName != null) {
builder.getRawBeanDefinition().setBeanClassName(beanClassName);
}
}
builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
if (parserContext.isNested()) {//默认对Scope属性的处理
builder.setScope(parserContext.getContainingBeanDefinition().getScope());
}
if (parserContext.isDefaultLazyInit()) {//默认lazyInit属性
builder.setLazyInit(true);
}
this.doParse(element, parserContext, builder);//最终调用自定义解析器的doParse 方法
return builder.getBeanDefinition();
}
有上述可以看出我们自定义了MyElementParse，但是在其中我们只是处理了与业务逻辑有关的部分，但是同时Spring 帮我们做了 按照解析默认标签的处理方式进行处理。
