Spring源码解析(3)——解析配置文件

最新推荐文章于 2023-02-21 14:33:39 发布
原创 最新推荐文章于 2023-02-21 14:33:39 发布 · 267 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

回顾上篇

上篇文章读取配置文件中，我们已经分析到spring如何读取配置文件（BeanFactoryTest.xml），并最终把配置文件转换成Document 对象。接下来Spring会去解析Document 对象，并将解析出来的信息放到BeanDefinition中。最后BeanDefinition会被封装到BeanDefinitionHolder中。接下来我们就跟着源码，看看这一步是如何来实现的。

分析源码实现

首先我们debug一下，看看解析BeanFactoryTest.xml配置文件后创建出来的BeanDefinition里面都有什么属性。

AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

在这里插入图片描述
由于我们配置文件写的比较简单，只配置了一个id和class,所以在BeanDefinition中我们就看到一个beanClass属性的值是我们再配置文件中配置的。也就是说解析完配置文件之后，我们配置的class属性，就会保存在BeanDefinition的beanClass这个字段中。

下面我们就看看Spring怎么去解析Document对象，生成BeanDefinition的。

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
			
		Document doc = doLoadDocument(inputSource, resource);
		int count = registerBeanDefinitions(doc, resource);
		
		if (logger.isDebugEnabled()) {
			logger.debug("Loaded " + count + " bean definitions from " + resource);
		}
		
		return count;
	}

在上面代码中（为了阅读方便，这里把try-catch的代码删除了），我们看到，获取到Document对象后，就把Document作为参数，传入了registerBeanDefinitions方法里。

	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

这里首先是创建了一个BeanDefinitionDocumentReader， 然后调用BeanDefinitionDocumentReader的registerBeanDefinitions方法来去处理解析和注册的逻辑。前面读取XML，将XML配置文件转换成Document都是在XmlBeanDefinitionReader这个类里面进行处理的，现在使用BeanDefinitionDocumentReader来对Document对象进行解析和注册bean。这里很好的体现了面向对象里单一职责的原则。进入到registerBeanDefinitions方法里面，看看里面的处理逻辑。

	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		doRegisterBeanDefinitions(doc.getDocumentElement());
	}

protected void doRegisterBeanDefinitions(Element root) {

		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			if (StringUtils.hasText(profileSpec)) {
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
				// We cannot use Profiles.of(...) since profile expressions are not supported
				// in XML config. See SPR-12458 for details.
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isDebugEnabled()) {
						logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
								"] not matching: " + getReaderContext().getResource());
					}
					return;
				}
			}
		}

		preProcessXml(root);
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);

		this.delegate = parent;
	}

在registerBeanDefinitions中，只是提取了root。然后将root作为参数传入doRegisterBeanDefinitions中，进行解析。这里主要的解析逻辑是在parseBeanDefinitions(root, this.delegate)这行代码中。

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

这里我们先看看root里面都有什么东西。

在这里插入图片描述
我们看到root里面保存的其实就是XML文件里面配置的beans节点的信息。在parseBeanDefinitions这个方法主要逻辑是

1、判断是否为默认命名空间。其实就是判断节点namespaceURI是不是http://www.springframework.org/schema
/beans。是的话就是默认命名空间。

2、获取root节点的子节点（NodeList nl = root.getChildNodes()）。这里获取的子节点中包含了两个text节点和一个bean节点，bean节点就是XML配置文件中我们配置的bean，而text节点是不会去解析的，这个节点只是我们在XML中配置bean的时候，换行产生的，里面就是换行符。

3、循环遍历所有子节点，默认命名空间调用默认解析方法parseDefaultElement，非默认命名空间调用自定义解析方法parseCustomElement。

由于我们配置的bean是默认的命名空间，所以应该调用默认解析方法。

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

这里分别对四种节点（import、alias、bean、beans )进行判断，不同的节点使用不同的方法进行解析。我们这边传入的bean节点，所以看到解析bean节点的方法processBeanDefinition。
（解析其它节点的方法暂时先忽略，等看完如何解析bean之后，再去看就会容易很多了）

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//1、解析bean节点得到一个BeanDefinitionHolder
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			//2、如果节点存在自定义属性，那么就还需要对自定义的属性进行解析
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// 3、注册BeanDefinition
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// 4、发送注册事件，通知监听器，bean已经加装完成
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

我们先看 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);这行代码。

解析bean节点得到一个BeanDefinitionHolder
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		String id = ele.getAttribute(ID_ATTRIBUTE);
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		List<String> aliases = new ArrayList<>();
		if (StringUtils.hasLength(nameAttr)) {
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}

		String beanName = id;
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
			if (logger.isTraceEnabled()) {
				logger.trace("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}

		if (containingBean == null) {
			checkNameUniqueness(beanName, aliases, ele);
		}

		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						beanName = this.readerContext.generateBeanName(beanDefinition);
						// Register an alias for the plain bean class name, if still possible,
						// if the generator returned the class name plus a suffix.
						// This is expected for Spring 1.2/2.0 backwards compatibility.
						String beanClassName = beanDefinition.getBeanClassName();
						if (beanClassName != null &&
								beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
								!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
							aliases.add(beanClassName);
						}
					}
					if (logger.isTraceEnabled()) {
						logger.trace("Neither XML 'id' nor 'name' specified - " +
								"using generated bean name [" + beanName + "]");
					}
				}
				catch (Exception ex) {
					error(ex.getMessage(), ele);
					return null;
				}
			}
			String[] aliasesArray = StringUtils.toStringArray(aliases);
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

这段代码大致做了下面几件事

1、解析id和name属性，并将beanName的值设置为id的值。这里id的值就是我们XML配置文件中配置的id的值myTestBean。

2、进一步解析其它的属性，并返回一个AbstractBeanDefinition，这个AbstractBeanDefinition其实是GenericBeanDefinition，也是后面往Spring里注册的BeanDefinition。

这里我们看看具体代码

	public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {

		this.parseState.push(new BeanEntry(beanName));

		//解析class属性
		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		//解析parent属性
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
			//创建AbstractBeanDefinition，进入createBeanDefinition你可以看到这边创建的是一个GenericBeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);

			//解析默认bean的各种属性 例如 scope、abstract、lazy-init、init-method、destroy-method
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
			//解析元数据
			parseMetaElements(ele, bd);
			//解析lookup-method属性
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			//解析replaced-method属性
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
			//解析构造函数参数
			parseConstructorArgElements(ele, bd);
			//解析property
			parsePropertyElements(ele, bd);
			//解析qualifier
			parseQualifierElements(ele, bd);

			bd.setResource(this.readerContext.getResource());
			bd.setSource(extractSource(ele));

			return bd;
		}
		catch (ClassNotFoundException ex) {
			error("Bean class [" + className + "] not found", ele, ex);
		}
		catch (NoClassDefFoundError err) {
			error("Class that bean class [" + className + "] depends on not found", ele, err);
		}
		catch (Throwable ex) {
			error("Unexpected failure during bean definition parsing", ele, ex);
		}
		finally {
			this.parseState.pop();
		}

		return null;
	}

每个步骤做什么注释上都已经写了，具体怎么解析的可以进入到每一个步骤里面去详细了解。到这里所有的解析工作都已经完成了，我们已经看到Spring创建了一个AbstractBeanDefinition，这里已经包含一个bean的所有信息。

在这里插入图片描述
3、beanName没有值，则使用默认规则生成beanName。如果我们在xml中配置bean的时候，既没有配置bean的class属性，也没有配置name属性，那么这里beanName就会没有值。

4、将AbstractBeanDefinition、beanName、aliasesArray封装到BeanDefinitionHolder中。

到这里解析bean节点得到一个BeanDefinitionHolder的工作就已经完成了。

深入 MyBatis-Spring 源码解析 ——揭秘 MyBatis 与 Spring 的完美融合
喵手的博客
12-09 1742
当谈到 Java 的持久层框架，MyBatis 几乎总会出现在讨论中；它轻量、灵活，非常适合需要复杂 SQL 查询的场景。而我们的大管家 Spring，除了帮我们管理依赖和控制反转之外，还可以跟 MyBatis 完美地配合在一起！这就是我们今天要讨论的主题——。在这个分析中，我们将通过源码来揭秘 MyBatis-Spring 是如何在两者间架起桥梁的，希望让你对其工作原理有一个深入的理解。MyBatis-Spring 是 Spring 提供的一个适配器模块，它的目标是帮助开发者在 Spring 应用中。
Spring 源码学习（三）—— 注解式配置解析
最新发布
weixin_63445802的博客
10-30 1003
AbstractTypeHierarchyTraversingFilter 抽象类只有两个使用 final 修饰的属性，分别为匹配时是否考虑匹配父类或接口的 considerInherited 与 considerInterfaces 属性；AbstractClassTestingTypeFilter 抽象类实现了 match 方法，其直接获取 metadataReader 参数的 ClassMetadata 原始参数并使用该对象执行单一参数的 match 方法；
Spring配置文件解析源码分析
qwerty的博客
04-01 304
文章目录   我们可以使用占位符去从设置Bean的属性值，可以使用context:property-placeholder标签来指定我们需要使用到的配置文件，Spring解析BeanDefinition的占位符格式的属性，会从配置文件中去查找对应的值替换调原本的占位符。 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instan
spring 解析配置文件BeanDefinition
xuyunti的博客
09-30 153
  1：ResourceLoader 加载配置文件 默认实现ResourcePatternResolver 2：XmlBeanDefinitionReader  读取配置文件封装BeanDefinition 3：BeanDefinitionRegistry 注册BeanBeanDefinition 默认实现是DefaultListableBeanFactory   解析配置文件默认由...
spring读取配置文件
08-03
spring读取配置不同目录下的配置文件，使用ClassPathXmlApplicationContext与FileSystemXmlApplicationContext
Spring源码分析 1：配置文件解析
Fisher3652的博客
10-03 1155
Springspring项目搭建1. 导入jar依赖2. XSD引入3. spring 容器加载方式源码精读1. 容器加载核心方法2. 测试类3. xml解析3.1 核心方法`AbstractApplicationContext#refresh()`3.2 obtainFreshBeanFactory()3.3 AbstractRefreshableApplicationContext#refreshBeanFactory()3.3.1 AbstractXmlApplicationContext#loadB
Spring学习（三）Spring配置文件的解析
一点莹的博客
03-15 216
1.bean标签： <!--bean讲解： 1.没有id，没有name，我们依旧可以获取这个对象，但是不建议使用、需要使用类的class对象获取； User bean = context.getBean(User.class); 2.id 就是对象的名字 3.class 就是要实例化的类 4.name就是别名 有id的时候，name是别名 ， 没有id的时候，name就是对象的名字 别名可以起多个 --> <bean id="user" name="userTwo
Spring源码解析.pdf
03-09
### Spring源码解析知识点 #### 一、Spring IoC 容器详解 ##### 1. BeanFactory —— 最基础的IoC容器 - **概念**：`BeanFactory` 是Spring框架中最基本的IoC容器，它负责管理Bean的生命周期，包括创建、配置和...
Spring源码深度解析——入门到精通
描述中提到的“spring源码解析 zip文件 有详细目录 spring入门必看书籍”，明确指出了该电子书的格式为zip文件，并且强调了书籍的结构条理清晰，读者可以借助详细目录快速定位所需内容。此外，此书被定位为“spring...
Java Spring 源码解析 Xmind 思维导图
03-20
在Spring源码解析中，时序图用于描绘不同组件之间的调用关系，如AOP代理的生成过程、事件发布机制、数据访问层（DAO）与业务逻辑层（Service）的交互等。这有助于开发者理解Spring如何处理复杂的应用场景。 再者，...
spr-bmp转化工具。能够将spr文件、BMP文件互相转化.zip
09-13
spr-bmp转化工具。能够将spr文件、BMP文件互相转化.zip
Spring之配置类解析源码解析
枫度柚子
04-23 402
Spring之配置类解析源码解析 解析配置类流程 总结 解析配置类流程 public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { List<BeanDefinitionHolder> configCandidates = new ArrayList<>(); // 拿到之前注册好的 String[] candidateNames = registry.getBeanDefini
Spring 配置文件详解
m0_70336653的博客
02-21 174
Spring 配置文件详解
Spring源码解读『配置文件解析』
卓立的博客
07-10 591
之前的文章详细介绍了Bean的实例化和初始化的过程，但其实Bean能实例化、初始化的前提是Spring容器在启动时，间配置文件（配置类）中的配置加载成BeanDefinition，这一点我们再之前的文章Spring源码解读『IOC容器1-自定义实现IOC容器』一文中看得比较清楚。关于Spring对配置文件（配置类）的处理，我们还没有介绍，本篇文章我们就来介绍一下Spring容器启动时是如何加载xml配置文件并加载成BeanDefinition的，在下篇文章来介绍@Configuration配置类。首先来看一
spring5.3 十二：spring配置类解析源码解析
admin522043032的博客
08-05 460
一：在启动Spring时，需要传入一个配置类，例如上面传入AppConfig.class。ApplicationContext会根据AppConfig类封装为一个BeanDefinition，这种BeanDefinition我们把它称为配置类BeanDefinition。二：ConfigurationClassPostProcessor中会把配置类BeanDefinition取出来。......
springboot源码4---配置文件解析
piliang719719的博客
12-05 704
解析前工作 1.加载EnvironmentPostProcessor 开始解析 1.加载所有profile profile加载顺序如下： 注意：与解析后加入environment中的PropertySource顺序相反 2.遍历profile解析 获取搜索路径和文件名 遍历搜索路径下的配置文件 解析、加入缓存 3.缓存添加到environment
JAVA日记之SpringIoC&DI详解,注意是详解! ----喝最烈的酒.
thenumb的博客
06-24 459
1. spring概述 1.1 Spring是什么（理解） Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。 提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众...
解析配置文件
ahappyman的博客
09-25 143
请见代码哈哈
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值