【Spring 源码深度解析】03 自定义标签的解析

最新推荐文章于 2024-08-07 09:21:28 发布
最新推荐文章于 2024-08-07 09:21:28 发布
阅读量413 收藏 1
点赞数
分类专栏： Spring 全家桶 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/green1997/article/details/122708738
版权

1 parseCustomElement

当完成从配置文件到 Document 的转换并提取对应的 root 后，就开始了所有元素的解析，而在这过程中便开始了默认标签与自定义标签两种梢式的区分，函数如下：

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	//对 beans 的处理，根节点是beans
	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;
				//isDefaultNamespace ：node.getNamespaceURI() 返回的uri 和
				//"http://www.springframework.org/schema/beans" 对比
				if (delegate.isDefaultNamespace(ele)) {
					//默认标签的解析 如 <bean id="test" class="test.TestBean">
					parseDefaultElement(ele, delegate);
				}
				else {
					//对bean 的处理，自定义的<tx:annotation-driven>
					delegate.parseCustomElement(ele);
				}
			}
		}
	}
	else {
		//解析自定义的标签
		delegate.parseCustomElement(root);
	}
}

上面代码可以看出，当 Spring 拿到一个元素时首先要做的是根据命名空间进行解析，如果是默认的命名空间，则使用parseDefaultElement方法进行元素解析，否则使用parseCustomElement方法进行解析。

2 自定义标签的使用

Spring 提供了可扩展的 Schema 的支持(需要 spring-core 包)，解析工作主要包含以下几个步骤。

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

应用实例：
1）创建一个 POJO

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

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	@Override
	public String toString() {
		return "User{" +
				"userName='" + userName + '\'' +
				", email='" + email + '\'' +
				'}';
	}
}

2）定义一个 XSD 文件描述组件内容
在 META-INF 下定义

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
		targetNamespace="http://www.lyb.xyz/schema/user"
		xmlns:tns="http://www.lyb.xyz/schema/user">
	<element name="user">
		<complexType>
			<attribute name="id" type="string"/>
			<attribute name="userName" type="string"/>
			<attribute name="email" type="string"/>
		</complexType>
	</element>
</schema>

上述 XSD 文件描述了一个新的 targetNamespace，并定义了一个 name 为 user 的 element。

3）创建一个类实现 BeanDefinitionParser 接口，用来解析 XSD 文件中的定义和组件定义。

public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {

	@Override
	protected Class<?> getBeanClass(Element element) {
		return User.class;
	}

	//解析
	@Override
	protected void doParse(Element element, BeanDefinitionBuilder builder) {
		String userName = element.getAttribute("userName");
		String email = element.getAttribute("email");

		builder.addPropertyValue("userName", userName);
		builder.addPropertyValue("email", email);
	}

	@Override
	protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
		super.doParse(element, parserContext, builder);
	}
}

4）创建一个 Hadnler 文件，扩展自 NamespaceHandlerSupport，目的是将组件注册到 Spring 容器。

public class MyNamespaceHandler extends NamespaceHandlerSupport {

	@Override
	public void init() {
		//当遇到<user:xxx 开头的元素 就给 UserBeanDefinitionParser 解析
		registerBeanDefinitionParser("user", new UserBeanDefinitionParser());
	}
}

以上代码当遇到自定义标签 <user:aa 这样类似于以 user 开头的元素，就会把这个元素委托给对应的 UserBeanDefinitionParser解析。

5）编写 spring.handlers 和 spring.schemas 文件。默认位置在 /META-INF/ 文件夹下。

spring.schemas
http\://www.lyb.xyz/schema/user.xsd=META-INF/spring-user.xsd

spring.handlers
http\://www.lyb.xyz/schema/user=org.springframework.customtag.MyNamespaceHandler

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:mytag="http://www.lyb.xyz/schema/user"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.lyb.xyz/schema/user http://www.lyb.xyz/schema/user.xsd">

	<mytag:user id="userBean" userName="里斯" email="14813133"/>
</beans>

7）测试类

public class Main {

	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("test/customtag/customTag.xml");

		User userBean = (User) context.getBean("userBean");

		System.out.println(userBean);
	}
}

3 自定义标签的解析

// BeanDefinitionParserDelegate.java
public BeanDefinition parseCustomElement(Element ele) {
	return parseCustomElement(ele, null);
}

// containingBd为父类 bean, 顶层元素是 null
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
	//获取对应的命名空间
	String namespaceUri = getNamespaceURI(ele);
	if (namespaceUri == null) {
		return null;
	}
	//根据命名空间从上下文中获取 NamespaceHandler, 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;
	}
	//调用自定义的 NamespaceHandler 进行解析, 调用 NamespaceHandlerSupport 的 parse 方法
	return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

上述代码的解析步骤：

  1. 获取对应的命名空间
  2. 根据命名空间从上下文中获取 NamespaceHandler
  3. 调用自定义的 NamespaceHandler 进行解析

3.1 获取标签的命名空间

标签的解析都是从命名空间的提取开始，无论是区分默认标签和自定义标签还是区分自定义标签中不同的处理器都是以标签所提供的名称空间为基础的。

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

3.2 提取自定义标签处理器

有了命名空间，就可以进行 NamespaceHandler 提取了。由this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri)该方法实现，在 readerContext 初始化的时候 namespaceHandlerResolver 已经被初始化为了 DefaultNamespaceHandlerResolver 了。

namespaceHandlerResolver 初始化：

XmlBeanDefinitionReader.java

public XmlReaderContext createReaderContext(Resource resource) {
	return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
			this.sourceExtractor, this, getNamespaceHandlerResolver());
}

public NamespaceHandlerResolver getNamespaceHandlerResolver() {
	if (this.namespaceHandlerResolver == null) {
		this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
	}
	return this.namespaceHandlerResolver;
}

protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
	ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
	return new DefaultNamespaceHandlerResolver(cl);
}

进入 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 的初始化方法
			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);
		}
	}
}

上述代码主要步骤：
1）获取所有已经配置的 handler 映射，懒加载， getHandlerMappings 该操作将 spring.handlers 文件中的所有映射读取放入缓存 handlerMappings 中。

private Map<String, Object> getHandlerMappings() {
	Map<String, Object> handlerMappings = this.handlerMappings;
	// double check
	if (handlerMappings == null) {
		// 同步
		synchronized (this) {
			handlerMappings = this.handlerMappings;
			// 第一次加载
			if (handlerMappings == null) {
				if (logger.isTraceEnabled()) {
					logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");
				}
				try {
					// META-INF/spring.handlers 默认在这个文件中
					//以 Properties 的方式读取
					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;
}

2）根据命名空间在 handlerMappings 中查找对应的信息，如果已经解析过则直接返回。
3）如果没有解析过则反射生成 NamespaceHandler 实例。
4）调用 namespaceHandler 的初始化方法，注册 parser，将 namespaceHandler 放入缓存。

3.3 标签解析

得到了解析器以及要分析的元素后， Spring 就可以将解析工作委托给自定义解析器去解析了。在 Spring 中的代码为：

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

parse 方法在父类 NamespaceHandlerSupport 中实现。

// NamespaceHandlerSupport.java
public BeanDefinition parse(Element element, ParserContext parserContext) {
	//查找解析器 实现了 BeanDefinitionParser
	BeanDefinitionParser parser = findParserForElement(element, parserContext);
	// AbstractBeanDefinitionParser -> AbstractSingletonBeanDefinitionParser
	return (parser != null ? parser.parse(element, parserContext) : null);
}

解析过程：
1）找到对应的 parser

private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
	//获取元素名称，即 <myname:user 中的 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;
}

2）调用 parser.parse(element, parserContext) 方法

public final BeanDefinition parse(Element element, ParserContext parserContext) {
	//这里调用了自定义的解析函数
	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));
				}
			}
			//将 AbstractBeanDefinition 转换为 BeanDefinitionHolder
			BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
			//注册 holder ，放入缓存中，和默认标签注册一样
			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;
}

3）解析获得 AbstractBeanDefinition
说是对自定义配置文件的解析。但是，在这个函数中大部分的代码是用来处理将解析后的 AbstractBeanDefinition 转化为 BeanDefinitionHolder 并注册的功能，而真正去做解析的事情委托给了 parseInternal 方法。正是这句代码调用了自定义的解析函数。

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
	//建造者模式，封装了 GenericBeanDefinition
	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));
	//父类 bean
	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);
	}
	//调用自定义解析
	doParse(element, parserContext, builder);
	return builder.getBeanDefinition();
}

虽然在实例中我们定义 UserBeanDefinitionParser，但是在其中我们只是做了与自己业务逻辑相关的部分。在这个处理过程中同样也是按照 Spring 标准的处理方式进行，包括创建 BeanDefinition 以及进行相应默认属性的设置，并暴露出一些接口来供用户实现个性化的业务。

movYou521
关注
专栏目录
【Spring源码】4. 自己搞个标签?~自定义标签保姆级全过程(图解向，堆图预警)
aqin1012的博客
05-25 23万+
前言（放在开头的废话） 不知道你有没有注意过命名空间这个东西，或者你有没有注意过xmlns、xmlns:context、xmlns:xsi（更多瞅下图）... 问题来了，这些是啥么？ ​这些是Spring中的命名空间，其主要作用是避免命名冲突，打个比方就是你和张三都有一个叫做heheda的bean，但是由于你们用的是各自的命名空间，就会给你俩的heheda前分别加上表示你俩命名空间的前缀，以免混淆。 Spring中主要分两位两种命名空间：默认命名空间和自定义命名空间（函数parseBeanDef
使用带ParserContext参数的Xaml.Load方法
草莽的专栏
12-30 2525
使用带ParserContext参数的Xaml.Load方法。如果一段XAML中存在一个标记需要从外部命名空间中解析， 就需要用到ParserContext类
Spring 源码学习 ~ 8、自定义标签的解析
戴泽王的博客
10-27 531
Spring 源码学习
Spring源码学习——自定义标签
mk33092250的博客
09-01 136
1.自定义标签步骤 创建一个需要扩展的组件 定义xsd文件描述组件内容 创建一个文件，实现BeanDefinitionParser接口，解析xsd文件中的定义和组件定义 创建handler文件，扩展NamespaceHandlerSupport，注册组件到spring容器 编写spring.handlers和spring.schemas文件 2.代码如下 1.编写pojo public cla...
【Spring源码解析】Spring XML配置自定义标签的解析
燃尽余火的博客
07-16 472
spring bean自定义标签解析
《Spring源码深度分析》第4章 自定义标签的解析
qq_43783527的博客
03-05 525
Spring源码深度分析》持续更新中…在之前的章节中，我们提到了在 Spring 中存在默认标签与自定义标签两种，而在上一章节中我们分析了 Spring 中对默认标签的解析过程，相信大家一定已经有所感悟。那么，现在将开始新的里程，分析 Spring 中自定义标签的加载过程。【Spring学习】Spring自定义标签详细步骤i ++) {// 解析默认的标签元素 parseDefaultElement(ele , delegate);} else {
SpringCloud源码深度解析
01-27
SpringCloud是目前广泛应用的微服务框架，其源码解析对于开发者深入理解微服务架构和优化实践至关重要。在SpringCloud中，Eureka作为注册中心，它的功能和工作机制是整个微服务架构的关键。 Eureka的主要职责是管理...
Spring源码深度解析：默认标签与Bean定义
"Spring源码解析：默认标签的解析与自定义标签处理" 在Spring框架中，XML配置文件是常见的配置方式，它包含了两种类型的标签：默认标签和自定义标签。默认标签是Spring预定义的，如`<bean>`，而自定义标签则是用户...
spring源码深度解析(包含所有spring源码，带全部的注释以及案例，很适合入门级)
07-16
源码深度解析对于开发者来说，是理解Spring工作原理、提升技术水平的重要途径。本资源提供了完整的Spring源码，附带注释和实例，对初学者极其友好。 首先，我们来探讨Spring的核心模块： 1. **IoC容器**：Spring的...
Spring5 源码分析(第 2 版)-某Tom老师
07-04
《Spring5 源码分析(第 2 版)》是某Tom老师精心编写的深度解析文档，旨在帮助读者全面理解Spring5的核心机制和设计理念。Spring作为Java领域最为广泛应用的框架之一，其源码的深入理解对于开发者来说至关重要。这篇...
Spring源码深度解析与注解驱动开发1
08-08
本节主要探讨Spring的源码解析以及注解驱动的开发方式，帮助开发者深入理解Spring的工作机制，提高开发效率。 一、Spring注解驱动开发 1. 容器：Spring的核心是IoC（Inversion of Control，控制反转）容器，它负责...
org/springframework/expression/ParserContext
weixin_41758407的博客
05-31 3022
springboot 启动的时候： 异常：java.lang.NoClassDefFoundError: org/springframework/expression/ParserContext 解决方案：缺少spring-expression-4.1.4.RELEASE.jar包，丢进项目中就可以了 <dependency> <g...
Spring4.3.x 浅析xml配置的解析过程（8）——解析context命名空间之component-scan标签
chyohn的博客
02-09 2933
概述Spring context命名空间有property-placeholder、property-override、annotation-config、component-scan、load-time-weaver、spring-configured、mbean-export和mbean-server 8个标签。property-placeholder和property-override标签的解
5.SpringMVC源码关于annotation扫描3
拯救大白程序猿的博客
04-25 806
扫描器加载basePackages 再次回顾，ComponentScanBeanDefinitionParser这个类中的parse()，之前描述了配置扫描器configureScanner()，我们接着了解一下扫描器是如何加载这些包类的。 @Override public BeanDefinition parse(Element element, ParserContext parserC...
开源项目 `context-parser` 使用教程
最新发布
gitblog_00944的博客
08-07 897
开源项目 context-parser 使用教程 context-parserA robust HTML5 context parser that parses HTML 5 web pages and reports the execution context of each character.项目地址:https://gitcode.com/gh_mirrors/co/context-pa...
Spring基础系列-AOP源码分析
weixin_43140611的博客
09-09 183
一、概述 　　Spring的两大特性：IOC和AOP。 　　AOP是面向切面编程，Spring内置了自己实现的基于动态代理技术的AOP，同时还支持成熟的AspectJ框架，我们这里主要讲述的还是内置的基于动态代理的AOP实现。因为面对一些普通的需求，Spring内置的AOP已经绰绰有余。 　　AOP一般用于增强原来的代码的功能，这种增强体现在辅助方面，比如安全、日志、事务等。 二、术语 ...
Spring系列19：SpEL详解
m0_67394006的博客
08-02 4103
直接使用new方式，注意多维数组不可以初始化。/***数组生成*/@Test//一维数组可以初始化//多维数组不可以初始化}可以使用语法来引用表达式中的变量。通过在实现上使用方法设置变量。/***变量#*/@Test//使用预先的变量赋值Name属性}#this函数可以当做一种变量来注册和使用的。2种方式注册按变量设置方式按明确的方法设置方式，其实底下也是按照变量处理。/**方法注册和使用*/@Test。标准上下文环境#...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值