栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

自定义标签解析总结

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

自定义标签解析总结

前言

spring配置文件有两种标签,默认标签(bean标签)和自定义标签(aop,mvc等除了bean以外的所有标签)。这里对自定义标签解析的全流程做一个总结。

一、自定义标签简介

下面是AOP的一套自定义标签




	
		
		
		

		
			
			
			


			
		

	

	

	

	

	


[aop:config]以这个标签为例,前者aop在这里其实对应了一个命名空【xmlns:aop=“http://www.springframework.org/schema/aop”】,后者config对应了一个解析器。
这里会有两个问题
1 命名空间有什么用
2 config对应的解析器在哪里,解析器有什么用
这两个问题在IOC启动后解析自定义标签的环节中可以找到答案

二、自定义标签解析流程

之前在跟IOC启动流程中,跟到过这个方法

public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader {
	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;
						//这里判断是否是默认标签的依据就是基于命名空间来判断的
						//命名空间是http://www.springframework.org/schema/beans的就是默认标签 其他的都是自定义标签
						if (delegate.isDefaultNamespace(ele)) {
							//之前跟了这个分支
							parseDefaultElement(ele, delegate);
						}
						else {
							//这次要跟这个分支了
							delegate.parseCustomElement(ele);
						}
					}
				}
			}
			else {
				delegate.parseCustomElement(root);
			}
		}
}

可以看到解析自定义标签是委托给BeanDefinitionParserDelegate类来完成的。继续跟parseCustomElement

//自定义标签解析 委托类
public class BeanDefinitionParserDelegate {
	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;
		}
		//基于命名空间拿到其对应的handler
		//this.readerContext.getNamespaceHandlerResolver()==DefaultNamespaceHandlerResolver
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		//调用handler的parse方法
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}
}

这里有两个分支
1 基于命名空间获取handler
2 调用handler的parse方法
接下来分别跟以下

2.1基于命名空间获取handler

方法this.readerContext.getNamespaceHandlerResolver()最终获取了一个命名空间解析器DefaultNamespaceHandlerResolver
接下来跟下DefaultNamespaceHandlerResolver的resolve方法

public class DefaultNamespaceHandlerResolver implements NamespaceHandlerResolver {
	public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers";
	public DefaultNamespaceHandlerResolver() {
		this(null, DEFAULT_HANDLER_MAPPINGS_LOCATION);
	}
	public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader) {
		this(classLoader, DEFAULT_HANDLER_MAPPINGS_LOCATION);
	}
	public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader, String handlerMappingsLocation) {
		Assert.notNull(handlerMappingsLocation, "Handler mappings location must not be null");
		this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());
		//其实 this.handlerMappingsLocation =  META-INF/spring.handlers
		this.handlerMappingsLocation = handlerMappingsLocation;
	}
	//解析方法
	public NamespaceHandler resolve(String namespaceUri) {
		//取到所有命名空间处理器的映射文件
		//key是命名空间 value是处理器的类全名 或者就是处理器本身
		Map handlerMappings = getHandlerMappings();
		//以AOP为例 这里通过命名空间拿到的处理器名称就是AopNamespaceHandler
		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");
				}
				//以AOP为例 这里通过反射构建AopNamespaceHandler对象
				NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
				//执行AopNamespaceHandler的init方法
				namespaceHandler.init();
				//这里将原来的handler全名换成了handler对象
				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映射文件
	private Map getHandlerMappings() {
		//这里可以看到其实handlerMappings 只会初始化一次
		Map 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
						//这里去各个项目目录下找META-INF/spring.handlers文件
						Properties mappings =
								PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
						if (logger.isTraceEnabled()) {
							logger.trace("Loaded NamespaceHandler mappings: " + mappings);
						}
						handlerMappings = new ConcurrentHashMap<>(mappings.size());
						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;
	}
}

这里看看AOP项目下的spring.handlers文件

http://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler

接下来我们看下AopNamespaceHandler的init方法

public class AopNamespaceHandler extends NamespaceHandlerSupport {
	//这里初始化了一堆解析器
	public void init() {
		// In 2.0 XSD as well as in 2.1 XSD.
		//还记得之前说的config对应一个解析器吗 就是在这里对应的
		registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
		registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
		registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

		// Only in 2.0 XSD: moved to context namespace as of 2.1
		registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
	}
}

所有handler的registerBeanDefinitionParser方法统一交给了父类NamespaceHandlerSupport做了封装
跟下registerBeanDefinitionParser

public abstract class NamespaceHandlerSupport implements NamespaceHandler {
	private final Map parsers = new HashMap<>();

	protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
		this.parsers.put(elementName, parser);
	}
}

可以看到父类将其加入了一个map中 待后续使用

2.2调用handler的parse方法

在回到自定义标签解析的委托类类 这次跟handler.parse

//自定义标签解析 委托类
public class BeanDefinitionParserDelegate {
	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;
		}
		//基于命名空间拿到其对应的handler
		//this.readerContext.getNamespaceHandlerResolver()==DefaultNamespaceHandlerResolver
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		//调用handler的parse方法
		//所有handler的parse方法统一交给了父类NamespaceHandlerSupport来做了抽象 所以直接跟NamespaceHandlerSupport
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}
}

再一次跟NamespaceHandlerSupport

public abstract class NamespaceHandlerSupport implements NamespaceHandler {
	//两步
	//1 找到对应的解析器
	//2 执行解析器的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) {
		String localName = parserContext.getDelegate().getLocalName(element);
		//还记得之前init中注册的parser吗,在这里被取出来了
		BeanDefinitionParser parser = this.parsers.get(localName);
		if (parser == null) {
			parserContext.getReaderContext().fatal(
					"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
		}
		return parser;
	}
}

接着还是以AOP为例 跟下ConfigBeanDefinitionParser的parse方法

//解析器主要用于解析和注册bean定义信息
class ConfigBeanDefinitionParser implements BeanDefinitionParser {
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		CompositeComponentDefinition compositeDef =
				new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
		parserContext.pushContainingComponent(compositeDef);
		//这里注册了一个AOP的入口类,既然到这里了就找以下AOP的入口类 方便后续对AOP的总结
		configureAutoProxyCreator(parserContext, element);

		List childElts = DomUtils.getChildElements(element);
		for (Element elt: childElts) {
			String localName = parserContext.getDelegate().getLocalName(elt);
			//解析注册 切入点
			if (POINTCUT.equals(localName)) {
				parsePointcut(elt, parserContext);
			}
			//解析注册 advisor
			else if (ADVISOR.equals(localName)) {
				parseAdvisor(elt, parserContext);
			}
			//解析注册 aspect
			else if (ASPECT.equals(localName)) {
				parseAspect(elt, parserContext);
			}
		}
		parserContext.popAndRegisterContainingComponent();
		return null;
	}
	
	//继续看下这里 这里可以找到AOP的入口类
	private void configureAutoProxyCreator(ParserContext parserContext, Element element) {
		//这里委托给了AopNamespaceUtils类
		AopNamespaceUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext, element);
	}
}

AopNamespaceUtils

public abstract class AopNamespaceUtils {
	//继续跟
	public static void registerAspectJAutoProxyCreatorIfNecessary(
			ParserContext parserContext, Element sourceElement) {
		//跟这里这里委托给了 AopConfigUtils来完成最终的注册
		BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(
				parserContext.getRegistry(), parserContext.extractSource(sourceElement));
		useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
		registerComponentIfNecessary(beanDefinition, parserContext);
	}
}

AopConfigUtils

public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(
			BeanDefinitionRegistry registry, @Nullable Object source) {
		//这里注册的就是AOP的入口类 
		return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
	}

详细AOP的内容 待AOP总结中AOP总结
到这里自定义注解的大体解析流程已经总结完了


总结

1 除了bean标签,其他标签都是自定义标签
2 一个自定义标签被冒号分割成两部分,前者对应一个命名空间,后者对应一个解析器
3 IOC容器启动后会解析自定义标签,解析方法是基于命名空间拿到其对应的处理器,对应关系在【MATE-INFO/spring.handlers配置文件中】
4 处理器被创建后会调用其init方法,创建一组解析器保存到一个集合中
5 当要处理一个标签时,会先通过标签冒号前的内容找到处理器,在通过标签冒号后的信息找到对应的一个解析器,完成最终的标签解析
6 额外的找了下AOP的入口类

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/986425.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号