spring解析自定义标签

/ Spring / 没有评论 / 32浏览

spring解析自定义标签

1、实践

1.1、如何拓展自定义标签

1.1.1、创建一个需要拓展的组件(POJO)

1539088667367.png

1.1.2、定义一个xsd文件描述组件内容

1539092925444.png

1.1.3、定义一个NamespaceHandler

程序可以通过此类定位到BeanDefinitionParse 1539092964595.png

1.1.4、定义一个BeanDefinitionParse,用来解析组件内容

1539092992933.png

1.1.5、编写spring.handlers和spring.schemas文件

spring.handlers

http\://www.dreamlong.com/schema/user=com.wl.custom.namespaceHandler.UserNamespaceHandler

spring.schemas

http\://www.dreamlong.com/schema/user.xsd=xml/user.xsd

1.1.6、编写xml配置

1539093226527.png

1.1.7、程序架构

程序的架构如图所示: 1539093129734.png

1539093157067.png

1.1.8、运行结果

1539093275863.png

2、源码

2.1、入口

DefaultBeanDefinitionDocumentReader.parseBeanDefinitions

	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);
		}
	}

在实践部分可知,命名空间为自定义空间,http://www.dreamlong.com/schema/user

2.2、解析过程

BeanDefinitionParserDelegate.parseCustomElement

	public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
		//获取当前元素的命名空间
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
		//根据命名空间获取对应Handler
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		//通过返回的处理器解析当前元素
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

2.2.1、获取节点的命名空间

String namespaceUri = getNamespaceURI(ele);

1539099017123.png

2.2.2、根据命名空间获取对应的NamespaceHandler

NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);

this.readerContext.getNamespaceHandlerResolver(); 此方法返回结果是NamespaceHandlerResolver,而NamespaceHandlerResolver的实现类是DefaultNamespaceHandlerResolver,进入到DefaultNamespaceHandlerResolver.resolve:

	public NamespaceHandler resolve(String namespaceUri) {
		//获取handlerMapping,即spring.handlers中存储的信息,以 namespaceUri -> NamespaceHandler名字 的形式存储
		//如果已经实例化,则该namespaceUri对应的value值是NamespaceHandler对象,而不是String类型
		Map<String, Object> handlerMappings = getHandlerMappings();
		//获取到对应的NamespaceHandler名字或者实例
		Object handlerOrClassName = handlerMappings.get(namespaceUri);
		if (handlerOrClassName == null) {
			return null;
		}
		//如果当前类已经实例化,则直接返回
		else if (handlerOrClassName instanceof NamespaceHandler) {
			return (NamespaceHandler) handlerOrClassName;
		}
		//还未实例化,则上面获取的handlerOrClassName只是名字,还需实例化
		else {
			//获取到className
			String className = (String) handlerOrClassName;
			try {
				//通过className以及当前类加载器加载class类
				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();
				//将实例化好的Handler以namespaceUri->Handler的形式存储在handlerMappings中
				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);
			}
		}
	}

以上代码一共做了这么几件事: 1、读取所有META-INF/spring.handlers的文件,并且以namespaceUri -> NamespaceHandler名字 的形式存储 2、根据传入的namespaceUri获取对应的值,如果该值类型是NamespaceHandler,则直接返回;如果是字符串类型,则还未实例化,进行实例化,然后将实例化NamespaceHandler替代原来的NamespaceHandler名字 3、返回对应的NamespaceHandler 1539131755529.png 1539135467615.png

2.2.3、解析

return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));

这句代码的做了这么2件事: 1、查找到对应的BeandefinitionParser 2、解析

2.2.3.1、定位BeanDefinitionParser

首先我们可以得知当前NamespaceHandler为UserNamespaceHandler,那么要如何获取到对应的UserBeanDefinitionParser,首先我们知道UserNamespaceHandler有如下方法:

public class UserNamespaceHandler extends NamespaceHandlerSupport {
    @Override
    public void init() {
        //以节点本地名称->BeanDefinitioinParser的形式存储在Map<String, BeanDefinitionParser>中
        registerBeanDefinitionParser("user",new UserBeanDefinitionParse());
    }
}

由于UserNamespaceHandler继承了NamespaceHandlerSupport,进入到NamespaceHandlerSupport:

public abstract class NamespaceHandlerSupport implements NamespaceHandler {
   /**
	 * Stores the {@link BeanDefinitionParser} implementations keyed by the
	 * local name of the {@link Element Elements} they handle.
	 * 以节点本地名称->BeanDefinitionParser的形式存储于Map
	 */
	private final Map<String, BeanDefinitionParser> parsers =
			new HashMap<String, BeanDefinitionParser>();
		
	/**
	  * 将对应的BeanDefinitionParser存放到map中
	  */
	protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
		this.parsers.put(elementName, parser);
	}
	
	//根据Element的localName定位到对应的BeanDefinitionParser
	private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
		//获取节点的本地名称
		String localName = parserContext.getDelegate().getLocalName(element);
		//根据节点本地名称获取到对应BeanDefinitionParser
		BeanDefinitionParser parser = this.parsers.get(localName);
		if (parser == null) {
			parserContext.getReaderContext().fatal(
					"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
		}
		return parser;
	}
}

因此,我们可以知道: 1、NamespaceHandler在初始化(init)时将对应的BeanDefinitionParser以elementName->BeanDefinitionParser的形式存储在map中 2、NamespaceHandler可以根据Element的localName,从而定位到对应的BeanDefinitionParser

2.2.3.2、解析

由于当前定位到的解析器为UserBeanDefinitionParse,它的继承体系图如图所示: 1539137582091.png

1539137716761.png

2.2.3.2.1、AbstractBeanDefinitionParser.parse
	public final BeanDefinition parse(Element element, ParserContext parserContext) {
		//模板方法,由子类完成,解析相应的标签,除了id以及name以外
		AbstractBeanDefinition definition = parseInternal(element, parserContext);
		if (definition != null && !parserContext.isNested()) {
			try {
				//解析该标签的id属性
				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));
					}
				}
				//将id作为beanName,结合definition构建BeanDefinitionHolder
				BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
				//以beanName->BeanDefinition的形式注册BeanDefinition
				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;
	}

这个方法主要做了这么几件事: 1、解析自定义标签相关属性parseInternal(element, parserContext);,此方法交由子类完成 2、获取节点的id属性,并将其作为beanName 3、注册BeanDefinition 由上面的类体系图可以得知,AbstractSingleBeanDefinitionParser实现了parserInternal

2.2.3.2.2、AbstractSingleBeanDefinitionParser.parserInternal
	protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
		//构建BeanDefinition
		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
		//设置parnetName属性
		String parentName = getParentName(element);
		if (parentName != null) {
			builder.getRawBeanDefinition().setParentName(parentName);
		}
		//设置beanClass
		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));
		BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
		if (containingBd != null) {
			// Inner bean definition must receive same scope as containing bean.
			builder.setScope(containingBd.getScope());
		}
		if (parserContext.isDefaultLazyInit()) {
			// Default-lazy-init applies to custom bean definitions as well.
			builder.setLazyInit(true);
		}
		//模板方法,交由子类实现
		doParse(element, parserContext, builder);
		return builder.getBeanDefinition();
	}

这个方法一共做了这么几件事: 1、构建BeanDefinition 2、设置相关基本属性 3、解析节点,由子类实现doParse 因此调用UserBeanDefinitionParse.doParse

2.2.3.2.3、最后调用具体实现类的doParse方法
   protected void doParse(Element element, BeanDefinitionBuilder builder) {
        String userName = element.getAttribute("userName");
        String password = element.getAttribute("password");
        if(StringUtils.hasText(userName)){
            builder.addPropertyValue("userName",userName);
        }
        if(StringUtils.hasText(password)){
            builder.addPropertyValue("password",password);
        }
    }

3、总结

自定义标签的解析过程到此结束