spring源码：解析xml中的import和alias标签

最新推荐文章于 2024-01-07 10:33:00 发布
最新推荐文章于 2024-01-07 10:33:00 发布
阅读量2.1k 收藏 4
点赞数
分类专栏： spring源码 文章标签： import标签 alias bean别名
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bronze5/article/details/101908642
版权

一、介绍

  spring允许xml中有两类标签：默认标签和扩展标签 。

  1. 默认标签有四种：beans、bean、import、alias ；
    其中bean标签为最基础的标签，其他三个标签都是围绕bean标签来做封装或者修饰的
  • beans：包含多个bean标签
  • import：表示导入另外一个xml，xml又包含这些标签
  • alias：修饰某个bean的别名
  1. 扩展标签包括spring的扩展标签和用户自定义的扩展标签，如：
<tx:annotation-driven/>

本篇主要分析默认标签中两个：import标签和alias标签。

二、整体脉络

  1. spring读取xml，把xml文档转换为一个Document对象
  2. 循环处理这个document对象中的各个标签，根据标签的命名空间不同，来判断是默认标签还是扩展标签。
  3. 处理默认标签：根据子节点的标签类型，使用不同的方法处理
    3.1 解析bean标签：主要工作为把bean标签的信息封装到GenericBeanDefinition中，然后把该实例注册到一个Map中。
    3.2 解析beans标签：递归调用3.1
    3.3 解析import标签：递归调用2
    3.4 解析alias标签：复用3.1中的注册别名方法

三、相关类和方法

  • DefaultBeanDefinitionDocumentReader#parseBeanDefinitions：解析xml中标签的入口
  • DefaultBeanDefinitionDocumentReader#parseDefaultElement：解析默认标签
  • DefaultBeanDefinitionDocumentReader#importBeanDefinitionResource：解析import标签
  • DefaultBeanDefinitionDocumentReader#processAliasRegistration：解析alias标签

四、源码分析

  1. 解析xml中标签入口，其中入参root就代表该xml文档的根节点
	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)) {
						// 1.解析默认标签
						parseDefaultElement(ele, delegate);
					}
					else {
						// 2.解析扩展标签
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}
  1. 解析默认标签
	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			// 1.处理import标签（本篇讲述）
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			// 2.处理alias标签（本篇讲述）
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			// 3.处理bean标签（参考历史文章）
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// 4.处理beans标签
			doRegisterBeanDefinitions(ele);
		}
	}

2.1 解析import标签

	protected void importBeanDefinitionResource(Element ele) {
		// 获取resource属性
		String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
		// 如果不存在resource属性 则不做处理
		if (!StringUtils.hasText(location)) {
			getReaderContext().error("Resource location must not be empty", ele);
			return;
		}

		// 解析系统属性，格式如: e.g. "${user.dir}"
		location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

		Set<Resource> actualResources = new LinkedHashSet<>(4);

		// 判断location是绝对uri还是相对uri
		boolean absoluteLocation = false;
		try {
			absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
		}
		catch (URISyntaxException ex) {
			// cannot convert to an URI, considering the location relative
			// unless it is the well-known Spring prefix "classpath*:"
		}

		// Absolute or relative?
		// 如果是绝对uri，则直接根据地址加载对应的配置文件
		if (absoluteLocation) {
			try {
				//根据指定路径加载xml文件  点进去
				int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
				if (logger.isDebugEnabled()) {
					logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
				}
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error(
						"Failed to import bean definitions from URL location [" + location + "]", ele, ex);
			}
		}
		else {
			// No URL -> considering resource location as relative to the current file.
			// 如果是相对地址，则根据相对地址计算出绝地地址
			try {
				int importCount;
				// 使用ClassPathResource获取resource
				Resource relativeResource = getReaderContext().getResource().createRelative(location);
				if (relativeResource.exists()) {
					importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
					actualResources.add(relativeResource);
				}
				else {
					String baseLocation = getReaderContext().getResource().getURL().toString();
					// location可能指定了多个地址，使用ResourcePatternResolver获取resource
					importCount = getReaderContext().getReader().loadBeanDefinitions(
							StringUtils.applyRelativePath(baseLocation, location), actualResources);
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
				}
			}
			catch (IOException ex) {
				getReaderContext().error("Failed to resolve current resource location", ele, ex);
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
						ele, ex);
			}
		}
		// 解析后进行监听器激活处理
		Resource[] actResArray = actualResources.toArray(new Resource[0]);
		getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
	}

	public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
		}

		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				// 加载多个resources，相当于加载多个xml
				int loadCount = loadBeanDefinitions(resources);
				if (actualResources != null) {
					for (Resource resource : resources) {
						actualResources.add(resource);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
				}
				return loadCount;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		else {
			// Can only load single resources by absolute URL.
			Resource resource = resourceLoader.getResource(location);
			// 复用加载beanDefinition的方法
			int loadCount = loadBeanDefinitions(resource);
			if (actualResources != null) {
				actualResources.add(resource);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
			}
			return loadCount;
		}
	}

	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		int counter = 0;
		for (Resource resource : resources) {
			// 循环调用加载xml的方法
			counter += loadBeanDefinitions(resource);
		}
		return counter;
	}

	// 被复用加载BeanDefinition的方法，相当于重新开始加载一个xml
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}

2.2 解析alias标签

	protected void processAliasRegistration(Element ele) {
		// 获取beanName属性值
		String name = ele.getAttribute(NAME_ATTRIBUTE);
		// 获取alias属性值
		String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
		boolean valid = true;
		if (!StringUtils.hasText(name)) {
			getReaderContext().error("Name must not be empty", ele);
			valid = false;
		}
		if (!StringUtils.hasText(alias)) {
			getReaderContext().error("Alias must not be empty", ele);
			valid = false;
		}
		if (valid) {
			try {
				// 注册alias核心代码（同解析bean标签时分析的alias属性）
				getReaderContext().getRegistry().registerAlias(name, alias);
			}
			catch (Exception ex) {
				getReaderContext().error("Failed to register alias '" + alias +
						"' for bean with name '" + name + "'", ele, ex);
			}
			// 别名注册后，通知监听器做相应处理
			getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
		}
	}

注册alias的核心代码，跟解析bean标签的alias属性使用的是同一个方法。最终别名的信息会保存在SimpleAliasRegistry对象的aliasMap属性中。之前的文章讲过，里面逻辑也很简单，就不复述了。

Bronze5
关注
专栏目录
Spring03：别名和多xml文件合并import
Sephir的博客
10-03 162
别名 <!-- id和name配置一个即可--> <!-- name后面可以跟多个名字--> <!-- 通过逗号，分号，空格分隔--> <bean id = "dog" name="a;b,c d" class="com.xxx.Dog"> <!-- 根据构造器参数的类型赋值--> <constructor-arg type="java.lang.String" value="Sep"&
Spring源码之XML默认标签解析
个人站点：javatv.net
10-26 595
Spring具有非常庞大的体系，但无论多大都是由一个个小的模块组合而来，不管是 SpringMvc 还是 SpringBoot，都是在Spring的基础上延伸而来，因此，看源码要找对方向。 我们知道，在SpringBoot之前，对象的管理和配置都是通过XML的方式来实现的，那么Spring是怎么读取配置文件，并且管理我们的实体对象的呢？这就需要从Spring容器开始了解。 1. 什么是Spring容器 Spring 容器是 Spring 框架的核心，是用来管理对象的。容器将创建对象，把它们连接在一起，配置它
【Spring源码解析】Spring xml配置import、alias、beans标签解析
燃尽余火的博客
07-14 1295
以上就是import、alias、beans标签的解析。其实和开始说的一样，都是对bean标签解析功能的增强和扩展。下面会讲下自定义标签的内容，希望每次查看源码都有收获，共勉！
spring应用手册-IOC（XML配置实现）-(18)-alias标签
10-03 286
戴着假发的程序员出品 alias标签 spring应用手册（第一部分） alias从字面意思理解就是别名。而这个标签的实际作用就是给bean添加别名。 看下面案例： <!-- 注册accountService --> <bean id="accountService" name="a_service" autowire="byType" c
@Import标签
qq_41835813的博客
11-27 284
当你用@Bean时，可以直接使用@import让它生成Bean public class Mapper { @Bean public StudentMapper getsStudentMappe() { return ApplicationContextConfig.getApplicationContext().getBean(StudentMapper.class); } }...
使用import alias
qq_45060976的博客
11-28 830
import alias 在我做记账项目时我发现每一次引入一个文件都需要输入很长的一段目录名，如图： 如果我想在Money.vue里面引入Tags.vue组件的话，那么我需要输： import Tags form '…/component/Money/Tags.vue’这么一长串目录路径，这里我得先去找到Tags所在的目录，然后一层一层的往上查看，一不小心还会输错路径 那么有没有什么方法可以避免这个过程呢，有的 使用import alias 我们这样写 import Tags from '@/compon
Spring源码解密之默认标签的解析
08-28
本篇文章将深入解析Spring源码，聚焦于默认标签的解析，特别是`<bean>`标签的处理流程。 首先，Spring在解析XML配置时，会调用`DefaultBeanDefinitionDocumentReader`类来处理文档中的各个元素。`...
spring源码：@Bean注解解析
小小少年的博客
06-13 1850
目的 在前面的自动扫描bean原理这篇文章中，主要说的是spring是如何将@ComponentScan注解声明的包下，加了@Component注解的业务类扫描到spring容器中的；在这篇文章中，没有说明一个知识点，在这里说明一下： spring将业务类转换为BeanDefinition的方式有三种 @ComponentScan注解+@Component注解 @Bean @Import注解，引入ImportBeanDefinitionRegistrar和ImportSelector的实现类 这是我目前通
Spring源码解析之xml解析
cblstc的博客
12-10 537
关键类的层级关系 BeanDefinition BeanFactory ApplicationContext Spring IOC源码解析 Spring容器的初始化（以xml配置为例） 首先进入AbstractApplicationContext的构造方法，追踪找到refresh()方法，这个方法是IOC容器初始化的核心方法。我们需要关注下obtainFreshBeanFactory()方法，主要是解析xml配置文件并封装成BeanDefinition对象 // org.springframework.co
Spring Boot：基本应用和源码解析
bier_zm的博客
11-13 1844
SpringBoot 基本应用 约定优于配置 约定优于配置（Convention over Configuration），又称按约定编程，是一种软件设计范式。 本质上是说，系统、类库或框架应该假定合理的默认值，而非要求提供不必要的配置。比如说模型中有一个名为 User 的类，那么数据库中对应的表就会默认命名为 User。只有在偏离这一个约定的时候，例如想要将该表命名为 person，才需要写有关这个名字的配置。 比如平时架构师搭建项目就是限制软件开发随便写代码，制定出一套规范，让开发人员按统一的要求
XML标签
心中镶着龙
09-17 654
XML关键字： "&lt;" "&amp;" &lt;![cdata[ ]]&gt;标签是为了规避XML解析器解析带有关键字的表达式
Next.JS 的 import alias (@/*)
最新发布
步子哥的博客
01-07 1124
在Next.js中，你可以使用import别名（import alias）来创建更短、更具描述性的模块导入路径。这可以使你的代码库更清晰、更易于维护，避免了在较大的项目中使用冗长的相对路径可能变得繁琐的问题。要在Next.js中设置import别名，你需要在项目中配置。文件，具体取决于你是使用JavaScript还是TypeScript。希望这些步骤能帮助你在Next.js中设置import别名。如果你想了解更多关于import别名的信息，可以参考下面的来源。
applicationContext.xml import spring模块配置文件
小兵qwer的专栏
01-18 3639
applicationContext.xml import spring模块配置文件       在struts2 + spring + hibernate集成开发柜架中，spring的配置文件也可以分模块，然后在applicationContext.xml中引入即可，方法如下： [xhtml] view plain copy prin
Import-Alias 帮助信息
Windows PowerShell
11-02 869
如下说明是翻译PowerShell中: help Import-Alias 产生的帮助信息. 译者: Edengundam(马涛) Import-Alias 大纲从文件中导入别名列表. 语法Import-Alias [-path] [-passThru] [-scope ] [-force] [-whatIf] [-confirm] [] 详细描述
java中import标签,Spring IOC 之解析Bean：解析 import 标签
weixin_34283655的博客
03-11 266
如果根节点或者子节点采用默认命名空间的话，则调用parseDefaultElement()进行默认标签解析否则调用delegate.parseCustomElement()方法进行自定义解析默认标签解析过程，源码如下：private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {/...
spring应用手册-IOC（XML配置实现）-（4）-import引入其他配置文件
10-02 179
文字说明 看文字嫌累的可以查看后面的视频说明（(__) ……） 我们可以通过import在一个配置文件中引入其他的配置文件。 例如： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLoca
spring源码之-import标签解析
自恃无情的博客
07-28 869
1.Import标签示例        在SpringBoot之前，Spring配置文件的小伙伴都知道，配置文件的维护会让人觉得恐怖，如果配置文件太多，所有配置都放在一个 spring.xml 配置文件中，那么这个文件就会变得很臃肿，所有针对这种情况 ，Spring 提供了一个分模块的思路，利用 import 标签，可以将各个不...
spring 的import 用法
lpp的专栏
06-15 1498
applicationContext.xml======================================......==================================注意，该import语义同java中的语义恰好相反，即：imported.xml中的bean可以引用applicationContext.xml中的bean,反过来则不能。 
Spring配置之import-alias-及bean的别名
疯狂的菜鸡
05-01 289
Spring配置之import,alias,及bean的别名 1.别名(alias) 在xml配置文件中可以对bean设置别名, 设置别名的方式有两种 使用alias标签 <!--使用name属性设置别名--> <bean id="user01" class="com.ml.pojo.User" name="user02,user03"> <property name="id" value="1"/> <property name="name.
Spring源码深度解析：默认标签与Bean定义
"Spring源码解析：默认标签的解析与自定义标签处理" 在Spring框架中，XML配置文件是常见的配置方式，它包含了两种类型的标签：默认标签和自定义标签。默认标签是Spring预定义的，如`<bean>`，而自定义标签则是用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值