Spring自定义标签的解析

前面已经讲了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)) {
						// 默认标签的解析
						parseDefaultElement(ele, delegate);
					}
					else {
						// 自定义标签的解析
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			// 自定义标签的解析
			delegate.parseCustomElement(root);
		}
	}

在分析自定义标签的解析之前先了解一下自定义标签的使用,这样我们就能更好的理解自定义标签的解析了.

自定义标签的使用
Spring提供了可扩展Schema的支持,扩展Spring自定义标签大致需要以下几个步骤(前提是要把Spring的core包加入项目中)

• 创建一个需要扩展的组件
• 定一个XSD文件描述组件内容
• 创建一个文件,实现BeanDefinitionParser接口,用来解析XSD文件中定义和组件定义
• 创建一个Handler文件,扩展自NamespaceHandlerSupport,目的是将组建注册到Spring容器
• 编写Spring.handlers和Spring.schemas文件.

1、创建一个POJO,用来接收配置文件.

public class User {
    
    private String userName;
    
    private String email;
    
}

2、定义一个XSD文件描述组件内容

<?xml version="1.0" encoding="UTF-8" ?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://www.aiqiong.com/schema/user"
    xmlns:tns="http://www.aiqiong.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、创建一个文件,实现BeanDefinitionParser接口,用来解析XSD文件中的定义和组件定义.

public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {

    @Override
    protected void doParse(Element element, BeanDefinitionBuilder builder) {
        String userName = element.getAttribute("userName");
        String email = element.getAttribute("email");
        // 将提取到的数据放入到BeanDefinitionBuilder中,
        // 待到完成所有bean的解析后,统一注册到beanFactory中
        if(StringUtils.hasText(userName)){
            builder.addPropertyValue("userName",userName);
        }
        if(StringUtils.hasText(email)){
            builder.addPropertyValue("email",email);
        }
    }
}

4、创建一个Handler文件,扩展自NamespaceHandlerSupport,目的是将组件注册到Spring容器

public class MyNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
    	// 当遇到自定义标签<user:aaa>这样类似于user开头的元素的时候,就会把这个元素扔给对应的UserBeanDefinitionParser去解析
        registerBeanDefinitionParser("user",new UserBeanDefinitionParser());
    }
}

5、编写Spring.handlers和Spring.schemas文件,默认位置是在工程的/META-INF/文件夹下,当然也可以修改Spring的扩展或者修改源码的方式改变路径

• Spring.handlers
  http://www.aiqiong.com/schema/user=com.www.aiqiong.com/schema/user=com.itpluto.MyNameSpaceHandler

• Spring.schemas
  http://www.aiqiong.com/schema/user=com.www.aiqiong.com/schema/user.xsd=META-INF/Spring-test.xsd

到这里,自定义的配置就结束了,而Spring加载自定义的大致流程就是遇到自定义标签后就去Spring.schemas和Spring.handlers中去找对应的XSD和handler,默认位置是/META-IINF/下,进而找到对应的handler以及解析元素的parser,从而完成了整个自定义元素的解析,也就是说,Spring将自定义的解析工作委托给了用户自己实现.
6、创建测试配置文件,在配置文件中引入对应的命名空间及XSD后,便可以直接使用自定义标签了

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:myname="http://www.aiqiong.com/schema/user"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/Spring-beans-2.0.xsd
  http://www.aiqiong.com/schema/user http://www.aiqiong.com/schema/user.xsd"

>
    <myname:user id="testbean" userName="aaa" email="bbb"/>
</beans>

7、测试

public static void main(String[] args) {
        ApplicationContext bf = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User)bf.getBean("testbean");
        String userName = user.getUserName();
        String email = user.getEmail();
        System.out.println("userName="+userName+";emial="+email);
    }

自定义标签的解析

	public BeanDefinition parseCustomElement(Element ele) {
		return parseCustomElement(ele, null);
	}

	public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
		// 1、获取命名空间
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
		// 2、根据命名空间找到对应的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;
		}
		// 3、调用自定义的NamespaceHandler进行解析
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

1、获取标签的命名空间
其实如何提取对应元素的命名空间并不需要我们自己亲自去实现,在org.w3c.dom.Node中已经提供了方法供我们直接调用:

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

2、提取自定义标签处理器

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的初始化方法
				// 注册解析器
				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);
			}
		}
	}

注意第一步获取映射,其实就是读取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.isTraceEnabled()) {
						logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");
					}
					try {
						// this.handlerMappingsLocation在构造函数中已经被初始化为:META-INF/Spring.handlers
						// PropertiesLoaderUtils对配置文件进行读取
						Properties mappings =
								PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
						if (logger.isTraceEnabled()) {
							logger.trace("Loaded NamespaceHandler mappings: " + mappings);
						}
						handlerMappings = new ConcurrentHashMap<>(mappings.size());
						// 将Properties格式文件合并到Map格式的handlerMappings中
						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、标签解析
因为这个时候handler已经被初始化为了我们自定义的MyNamespaceHandler了,但是我们并没有实现parse方法,所以推断应该是父类里边的parse方法

	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方法register的
		// 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;
	}

解析操作

public final BeanDefinition parse(Element element, ParserContext parserContext) {
		// 解析,这里会调用我们解析器里的自定义方法:doParse()
        AbstractBeanDefinition definition = this.parseInternal(element, parserContext);
        // 后面就是对beanDefinition的处理了
        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 = null;
                if (this.shouldParseNameAsAliases()) {
                    String name = element.getAttribute("name");
                    if (StringUtils.hasLength(name)) {
                        aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
                    }
                }

                BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
                this.registerBeanDefinition(holder, parserContext.getRegistry());
                if (this.shouldFireEvents()) {
                    BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
                    this.postProcessComponentDefinition(componentDefinition);
                    parserContext.registerComponent(componentDefinition);
                }
            } catch (BeanDefinitionStoreException var8) {
                String msg = var8.getMessage();
                parserContext.getReaderContext().error(msg != null ? msg : var8.toString(), element);
                return null;
            }
        }

        return definition;
    }

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,此时会调用自定义解析器如UserBeanDefinitionParser中的getBeanClass方法
        Class<?> beanClass = this.getBeanClass(element);
        if (beanClass != null) {
            builder.getRawBeanDefinition().setBeanClass(beanClass);
        } else {
        	// 若子类没有重写getBeanClass方法则尝试检查子类是否重写getBeanClassName方法
            String beanClassName = this.getBeanClassName(element);
            if (beanClassName != null) {
                builder.getRawBeanDefinition().setBeanClassName(beanClassName);
            }
        }

        builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
        BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
        if (containingBd != null) {
        	// 使用父类的scope属性
            builder.setScope(containingBd.getScope());
        }

        if (parserContext.isDefaultLazyInit()) {
        	// 配置延迟加载
            builder.setLazyInit(true);
        }
		// 这里会去调用我们自定义的doParse方法
        this.doParse(element, parserContext, builder);
        return builder.getBeanDefinition();
    }

到这里自定义标签解析就结束了.
总结:
我们在了解了自定义标签的使用时候,跟着源码看了一遍.
其实就是根据元素获取命名空间,再根据命名空间找到对应的处理器,并且执行init方法,把解析器注册进去,然后解析元素的时候,根据标签元素的名称再把注册进去的解析器提取出来,进行解析操作,解析操作核心是调用我们的doParse()方法,但是还有其他的比如scope、class等操作,虽然我们没有做,但是Spring都帮我们做好了.