Spring IoC原理(五) obtainFreshBeanFactory()方法(二)

已于 2022-07-20 19:51:14 修改
阅读量114 收藏
点赞数
分类专栏： Spring IoC原理 文章标签： spring java
于 2022-07-02 17:18:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33770578/article/details/125563894
版权

Spring IoC原理(五) obtainFreshBeanFactory()方法(二)

文章目录

前言

   在Spring IoC原理(四) obtainFreshBeanFactory()方法(一)文章中对BeanDefinition的Resource定位过程进行了分析，本文将继续对BeanDefinition的载入与解析过程进行分析。

一、BeanDefinition的载入


图1-1 BeanDefinition的载入过程
   在上节调用getResources()方法得到XML资源后将对XML资源进行载入与解析,图1-1为BeanDefinition的载入过程，接下来将详细介绍调用过程中的方法：

loadBeanDefinitions
   通过调用getResources()方法得到XML资源并将得到结果resources，将得到的resources作为参数进行后续的BeanDefinition载入。

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

	if (resourceLoader instanceof ResourcePatternResolver) {
		// Resource pattern matching available.
		try {
			Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
			int count = loadBeanDefinitions(resources);
		}
	}
}

registerBeanDefinitions
   在经过一系列loadBeanDefinitions相关方法后将调用DefaultBeanDefinitionDocumentReader类中的registerBean Definitions()方法。首先创建一个BeanDefinitionDocumentReader类型的读取器documentReader ，并将resource转换为XmlReaderContext类型以便进行读取。调用documentReader的registerBeanDefinitions方法，将读取的DOM文件以及转换后的resource作为参数。

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

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

doRegisterBeanDefinitions
   documentReader 的registerBeanDefinitions并未直接进行BeanDefinition的载入，而是获取DOM文档的根节点，如图1-2所示，将得到的根节点作为参数调用DefaultBeanDefinitionDocument Reader类中的doRegisterBeanDefinitions()方法。


图1-2 getDocumentElement结果

   doRegisterBeanDefinitions()方法中首先创建BeanDefinitionParserDelegate类型的parent，从名字就可以看出为BeanDefinition解析的委托类。将parent以及DOM根节点root作为参数调用parseBeanDefinitions()方法，进行后续的载入过程。

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

parseBeanDefinitions
   parseBeanDefinitions()方法对获取传入DOM根节点下的所有子节点，并调用parseDefaultElement()方法对每个子节点进行处理。

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;
				// 判断ele是否为默认命名空间
				if (delegate.isDefaultNamespace(ele)) {
					parseDefaultElement(ele, delegate);
				}
				// 非默认命名空间进行特殊处理
				else {
					delegate.parseCustomElement(ele);
				}
			}
		}
	}
	else {
		delegate.parseCustomElement(root);
	}
}

parseDefaultElement
   parseDefaultElement()方法将根据子节点的不同类型进行相应的处理，由于载入的节点标签为，因此将调用processBeanDefinition()方法对子节点进行处理。

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

processBeanDefinition
   processBeanDefinition()方法中将调用parseBeanDefinitionElement()方法对子节点进行解析，并得到BeanDefinitionHolder类型的bdHolder用来储存解析出来的BeanDefinition。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// Register the final decorated instance.
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}
		catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		// Send registration event.
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

二、BeanDefinition的解析

parseBeanDefinitionElement
  BeanDefinitionParserDelegate类中有多个重载的parseBeanDefinitionElement()方法，BeanDefinition的解析首先调用的parseBeanDefinitionElement()方法对节点进行解析并将解析出的BeanDefinition存入BeanDefinitionHolder。方法内首先对bean属性进行简单的解析得到id、name属性，并进行合法性检查。在完成相关处理后将调用parseBeanDefinitionElement()方法进行进一步解析。在得到beanDefinition后将对其包装为BeanDefinitionHolder类型并返回。

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

parseBeanDefinitionElement
  此处的parseBeanDefinitionElement()方法将继续对bean属性进行解析得到class和parent属性，并根据class和parent创建一个AbstractBeanDefinition。接下来将对bean进行全面解析，parseBeanDefinitionAttributes()将对当前bean进行属性解析，parseProperty Element()解析当前bean的property设置，parseConstructorArgElements()对设置的构造函数进行解析等等。

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

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

	String className = null;
	if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
		className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
	}
	String parent = null;
	if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
		parent = ele.getAttribute(PARENT_ATTRIBUTE);
	}

	try {
		AbstractBeanDefinition bd = createBeanDefinition(className, parent);

		parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
		bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

		parseMetaElements(ele, bd);
		parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
		parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

		parseConstructorArgElements(ele, bd);
		parsePropertyElements(ele, bd);
		parseQualifierElements(ele, bd);

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

三、总结

  经过了BeanDefinition的载入与解析，在XML文件中设置的bean相关信息已经全部转化为数据结构，接下来将在解析后的BeanDefinition的基础上进行bean的注册。

王水水啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springIoc实现原理
04-20
**Spring Ioc 实现原理详解** Spring Ioc（Inversion of Control，控制反转）是Spring框架的核心特性之一，它改变了传统应用程序中对象的创建和管理方式。在传统的软件设计中，对象的创建和依赖关系的维护通常由...
Spring IOC原理详解
08-28
Spring IOC原理详解 Spring IOC（Inversion of Control，控制反转）是 Spring 框架的核心概念，它解决了对象之间的耦合问题，实现了松耦合编程。IOC 的思想是，Spring 容器来实现对象之间的创建、协调工作，而不是...
IOC初始化bean的流程
weixin_45955787的博客
09-09 400
Bean的声明周期 1）容器启动时创建Bean 2）给Bean通过DI设置对象属性 3）如果Bean实现了BeanFactoryAware方法，则会调用BeanFactoryAware方法中的SetBeanName(); 4)如果 bean实现了BeanFactoryAware 接口，工厂通过传递自身的实例来调用setBeanFactory()。 5）如果存在与 bean 关联的任何BeanPostProcessors（前置处理器），则调用preProcessBeforeInitialization() 方
Spring IOC容器Bean初始化流程
qq_27284933的博客
09-18 318
1、开篇 通过Spring IoC容器初始化Bean的流程，在之前的章节中介绍了Spring IoC容器是如何从配置文件中读取Bean信息，并且将其转换为BeanDefinition并且注册到Spring IoC容器中进行统一管理的。今天讲的是，在Spring IoC 容器中的Bean实例是如何被创建出来的，也就是解决如何从Spring IoC取出Bean进行使用。今天有如下内容： ● 创建Bean的时序图 2、创建Bean的时序图 由于一个Bean的创建经历了若干个类，调用了很多方法，为了将这个过程理解
Spring源码解析——IOC之bean 的初始化
Tyson0314的博客
10-09 186
客户定制的初始化方法除了我们熟知的使用配置init-method外，还有使自定义的bean实现InitializingBean接口，并在afterPropertiesSet中实现自己的初始化业务逻辑。init-method与afterPropertiesSet都是在初始化bean时执行，执行顺序是afterPropertiesSet先执行，而init-method后执行。在invokeInitMethods方法中就实现了这两个步骤的初始化调用。// 是否实现 InitializingBean。
【Spring】二、SpringIOC Bean的初始化流程
weixin_43333483的博客
06-01 286
【Spring】二、SpringIOC Bean的初始化流程
Spring-IOC底层原理-Bean的初始化过程解析
qq_39188134的博客
04-21 199
Bean的初始化过程图解 BeanFactoryPostProcessor、 BeanPostProcessor、 InitializingBean这些操作需要被spring容器加载 示例如下： BeanFactoryPostProcessor操作 //自定义BeanFactoryPostProcessor的操作 public class MyBeanFactory implements BeanFactoryPostProcessor { @Override //工厂后
简单谈谈Spring Ioc原理解析
08-26
Spring的IoC（控制反转）和DI（依赖注入）是其核心设计理念，它们极大地简化了Java应用程序的开发，特别是企业级应用。IoC的核心思想是将对象的创建和管理权交给了Spring容器，而不是由对象自身负责。这使得对象间的...
简单实现Spring的IOC原理详解
08-28
简单实现Spring的IOC原理详解 Spring IOC（Inversion of Control，控制反转）是一种软件设计模式，它将对象的创建和管理交给容器，实现了对象之间的解耦合。Spring IOC容器是Spring框架的核心，用于管理应用程序中...
Spring IOC原理
09-29
Spring IOC原理，类的继承关系，依赖注入和控制反转等关系
Spring IOC容器初始化之Bean创建流程深入剖析
舞鹤白沙编码日志
01-03 145
一. SpringBean的生命周期图 二. Bean⽣命周期关键时机点 思路：创建⼀个类 LagouBean ，让其实现⼏个特殊的接⼝，并分别在接⼝实现的构造器、接⼝⽅法中断点，观察线程调⽤栈，分析出 Bean 对象创建和管理关键点的触发时机。 LagouBean类 package com.lagou.edu; import org.springframework.beans.BeansException; import org.springframework.beans.factory.
Spring中ioc的初始化过程
蜗牛_在努力的博客
07-11 197
相信大家都知道Spring这个东西，我们经常来用他一些特性，比如说他的AOP，IOC，那今天就带大家解析下SpringIOC的加载过程。 首先我们需要从上节Spring源码的refresh()方法入手去观察： finishBeanFactoryInitialization(beanFactory); beanFactory.preInstantiateSingletons() 两个方法是递进的关系，从第一个方法点进去之后便会发现第二个方法，进去之后找到一个getBean(beanName)的方法此时便是
Spring Ioc容器初始化过程
weixin_42655186的博客
04-07 371
Spring Ioc容器初始化过程流程简介启动过程refresh() //初始化入口1. prepareRefresh() //准备工作2. BeanFactory beanFactory = obtainFreshBeanFactory()3.prepareBeanFactory()4.postProcessBeanFactory(beanFactory)5.invokeBeanFactoryPostProcessors(beanFactory)6.registerBeanPostProcess
Spring IOC 初始化过程（笔记）
qfzhangwei的专栏
11-25 550
1 从ClassPathXmlApplicationContext 的构造方法说起 ---->refresh方法 ---->同步锁内依次进行：beanName-> beanDefinition 的 map 定义解析即（ConfigurableListableBeanFactory beanFactory） --->设置类加载器同时添加几个BeanPostProcessor----->postProcessBeanFactory(beanFactory); BeanFact
Spring IOC容器初始化过程以及Bean的生命周期（学习备用）
orange_bug的博客
04-28 793
Spring IOC容器初始化过程以及Bean的生命周期
Spring-IOC-Bean的生命周期(Bean的初始化阶段)
xiaopang2020的博客
10-22 282
bean实例化研究了createBeanInstance方法。 接下来看bean的初始化。 主要点如下： 1.bean 的属性赋值 & 组件依赖注入 2.bean 的初始化方法回调 3.重要的 BeanPostProcessor 功能解析 doCreateBean protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationExce
Spring IoC源码学习：obtainFreshBeanFactory 详解
最新发布
2401_84009929的博客
04-18 973
又是一年求职季，在这里，我为各位准备了一套Java程序员精选高频面试笔试真题，来帮助大家攻下BAT的offer，题目范围从初级的Java基础到高级的分布式架构等等一系列的面试题和答案，用于给大家作为参考以下是部分内容截图《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**
Spring IOC容器加载Bean的初始化过程
zhyk1117的博客
04-02 1470
这是我的第一篇博客，正式开启小奋之旅。 主要记录了Spring 加载Bean的过程。主要参考了如下链接，谢谢。 Spring容器IOC初始化过程---今天终于进行总结了 https://juejin.im/post/5ab30714f265da237b21fbcc 谈一谈我对Spring Resource的理解 ...
Spring IOC初始化bean对象创建的N种实现方式理解
IT-CRUD
03-15 554
Spring IOC基础 此部分内容是借鉴于凯涛的博客：IoC 之 2.1 IoC基础 ——跟我学Spring3 IoC是什么 Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下： 谁控制谁，控制什么：传统Java SE程序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值