Spring源码学习-XML 配置方式的IoC容器启动过程分析

最新推荐文章于 2024-07-23 16:56:45 发布
最新推荐文章于 2024-07-23 16:56:45 发布
阅读量96 收藏
点赞数
分类专栏： Spring 文章标签： spring ioc java
以FileSystemXmlApplicationContext为例，把Spring IoC容器的初始化流程走一遍： 

ApplicationContext context = new FileSystemXmlApplicationContext
            ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml");

<beans>
	<import resource="classpath:config/spring/that-other-xml-conf.xml"/>
	<alias name="trianglePoint" alias="triangle-alias"/>
	<bean id="yourCoolBean" class="org.jdong.MyCoolBean">
		<property name="age">100</property>
	</bean>
</beans>

整个流程可用一句话简单概括：
读入并解析XML文件，把文件中Bean的定义保存在Map里

相应的要做以下几件事：
1.定位Resource
2.读入Resource，解析并创建BeanDefinition
3.把BeanDefinition注册到Map里

第1步由DefaultResourceLoader实现（FileSystemXmlApplicationContext是DefaultResourceLoader的子类）
第2步交给了BeanDefinitionReader，而BeanDefinitionReader又委托给BeanDefinitionParserDelegate
注意这一步创建的不是Bean的实例，Bean的实例化是在整个配置文件解析完毕之后再进行
第3步比较简单，交给BeanDefinitionReaderUtils


首先要明确，FileSystemXmlApplicationContext是实现了ResourceLoader、ResourcePatternResolver接口，继承了DefaultResourceLoader：
利用org.apache.commons.lang.ClassUtils可以查看FileSystemXmlApplicationContext都实现了哪些接口，都继承了哪些类 

allInterfaces:
interface org.springframework.beans.factory.BeanNameAware
interface org.springframework.beans.factory.InitializingBean
interface org.springframework.context.ConfigurableApplicationContext
interface org.springframework.context.ApplicationContext
interface org.springframework.beans.factory.ListableBeanFactory
interface org.springframework.beans.factory.BeanFactory
interface org.springframework.beans.factory.HierarchicalBeanFactory
interface org.springframework.context.MessageSource
interface org.springframework.context.ApplicationEventPublisher
interface org.springframework.core.io.support.ResourcePatternResolver
interface org.springframework.core.io.ResourceLoader
interface org.springframework.context.Lifecycle
interface org.springframework.beans.factory.DisposableBean
allSuperclasses:
class org.springframework.context.support.AbstractXmlApplicationContext
class org.springframework.context.support.AbstractRefreshableConfigApplicationContext
class org.springframework.context.support.AbstractRefreshableApplicationContext
class org.springframework.context.support.AbstractApplicationContext
class org.springframework.core.io.DefaultResourceLoader
class java.lang.Object

因此查看AbstractXmlApplicationContext就不会迷惑了： 

	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		//ResourceLoader是this，因为AbstractXmlApplicationContext实现了ResourceLoader接口
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		initBeanDefinitionReader(beanDefinitionReader);
		loadBeanDefinitions(beanDefinitionReader);
	}


由于Spring支持太多的配置方式了，阅读源码时跳来跳去，容易迷失
因此，最好是根据上面要做的几件事，一个一个的去找

1.资源定位
DefaultResourceLoader的getResource方法显示，有三种形式的Resource： 

	public Resource getResource(String location) {
		if (location.startsWith(CLASSPATH_URL_PREFIX)) {
			return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
		}
		else {
			try {
				URL url = new URL(location);
				return new UrlResource(url);
			}
			catch (MalformedURLException ex) {
				return getResourceByPath(location);
			}
		}
	}

FileSystemXmlApplicationContext是第三种： 

	protected Resource getResourceByPath(String path) {
		if (path != null && path.startsWith("/")) {
			path = path.substring(1);
		}
		return new FileSystemResource(path);
	}

DefaultResourceLoader.getResource(string)在哪被调用呢？
在AbstractBeanDefinitionReader： 

public int loadBeanDefinitions(String location, Set actualResources)  {
		ResourceLoader resourceLoader = getResourceLoader();

		if (resourceLoader instanceof ResourcePatternResolver) {
			try {
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				int loadCount = loadBeanDefinitions(resources);
				return loadCount;
			}
		}
	}

OK，Resource找到了

2.读取XML并创建BeanDefinition
XmlBeanDefinitionReader（Spring是用DOM的方式来解析XML的）： 

	protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
		try {
			int validationMode = getValidationModeForResource(resource);
			Document doc = this.documentLoader.loadDocument(
					inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());
			return registerBeanDefinitions(doc, resource);
		}

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

顺着上面的方法一直看下去（我们只看XML Namespace为default的那部分）
到了DefaultBeanDefinitionDocumentReader： 

	//遍历XML root里的每个Element（通常是一个Bean定义）
	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;
				parseDefaultElement(ele, delegate);
		}
	}

	//三部分，import, alias, bean我们主要看bean那部分
	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (DomUtils.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		else if (DomUtils.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		else if (DomUtils.nodeNameEquals(ele, BEAN_ELEMENT)) {
			processBeanDefinition(ele, delegate);
		}
	}

	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//读取bean配置
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		//注册到Map
		BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
	}

接着去到了BeanDefinitionParserDelegate，这个类承担了大部分的“脏活”： 

	//从下面代码中可见，如果定义了id，则beanName=id，否则取name列表中的第一个为beanName。除了beanName外，其他称为alias
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
		String id = ele.getAttribute(ID_ATTRIBUTE);
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

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

		String beanName = id;
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
		}

		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
	}

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

		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		AbstractBeanDefinition bd = createBeanDefinition(className, parent);

		parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
		parseMetaElements(ele, bd);
		parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
		parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
		parseConstructorArgElements(ele, bd);

		//主要看一下这个方法
		parsePropertyElements(ele, bd);
		parseQualifierElements(ele, bd);

		return bd;
	}

	//可能有多个Property
	public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			parsePropertyElement((Element) node, bd);
		}
	}

	public void parsePropertyElement(Element ele, BeanDefinition bd) {
			Object val = parsePropertyValue(ele, bd, propertyName);
			PropertyValue pv = new PropertyValue(propertyName, val);
			parseMetaElements(ele, pv);
			pv.setSource(extractSource(ele));
			bd.getPropertyValues().addPropertyValue(pv);
	}

	public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {

		/*Property有多种形式，例如
		<property name="message" value="Hello World!"/>  
        <property name="age">  
            <value>1</value>  
        </property>  
		也可以是List, Map等等
		*/
		// Should only have one child element: ref, value, list, etc.
		NodeList nl = ele.getChildNodes();
		Element subElement = null;
		for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				subElement = (Element) node;
			}
		}

		boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
		boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);

		//ref="..."
		if (hasRefAttribute) {
			String refName = ele.getAttribute(REF_ATTRIBUTE);
			RuntimeBeanReference ref = new RuntimeBeanReference(refName);
			ref.setSource(extractSource(ele));
			return ref;
		}
		//value="..."
		else if (hasValueAttribute) {
			TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
			valueHolder.setSource(extractSource(ele));
			return valueHolder;
		}
		//非直接量，例如List
		else if (subElement != null) {
			return parsePropertySubElement(subElement, bd);
		}
	}

	//这个方法涵盖了List, Map, Array等等
	public Object parsePropertySubElement(Element ele, BeanDefinition bd, String defaultValueType) {
	    if (nodeNameEquals(ele, REF_ELEMENT)) {
			// A generic reference to any name of any bean.
			String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
			boolean toParent = false;
			if (!StringUtils.hasLength(refName)) {
				// A reference to the id of another bean in the same XML file.
				refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);
				if (!StringUtils.hasLength(refName)) {
					// A reference to the id of another bean in a parent context.
					refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
					toParent = true;
					if (!StringUtils.hasLength(refName)) {
						error("'bean', 'local' or 'parent' is required for <ref> element", ele);
						return null;
					}
				}
			}
			if (!StringUtils.hasText(refName)) {
				error("<ref> element contains empty target attribute", ele);
				return null;
			}
			RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
			ref.setSource(extractSource(ele));
			return ref;
		}
		else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
			return parseIdRefElement(ele);
		}
		else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
			return parseValueElement(ele, defaultValueType);
		}
		else if (nodeNameEquals(ele, NULL_ELEMENT)) {
			// It's a distinguished null value. Let's wrap it in a TypedStringValue
			// object in order to preserve the source location.
			TypedStringValue nullHolder = new TypedStringValue(null);
			nullHolder.setSource(extractSource(ele));
			return nullHolder;
		}
		else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
			return parseArrayElement(ele, bd);
		}
		else if (nodeNameEquals(ele, LIST_ELEMENT)) {
			return parseListElement(ele, bd);
		}
		else if (nodeNameEquals(ele, SET_ELEMENT)) {
			return parseSetElement(ele, bd);
		}
		else if (nodeNameEquals(ele, MAP_ELEMENT)) {
			return parseMapElement(ele, bd);
		}
		else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
			return parsePropsElement(ele);
		}
		else {
			error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
			return null;
		}
	}



Spring IoC容器启动过程是相当复杂，因为它支持各种灵活的配置——这可能是一个框架所必须的吧
但就我个人而言，在可能的情况下，我会限定只采用一两种配置（例如XML），从而简化逻辑，所谓“约定大于配置”

参考文章：[url]http://www.ibm.com/developerworks/cn/java/j-lo-beanxml/[/url]
参考文章里面把流程做成了图片，方便我们把握整个脉络
bylijinnan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
官方原版源码spring-framework-5.1.4.RELEASE.zip
01-11
例如，关于IoC（Inversion of Control，控制反转）的实现，Spring使用了XML配置或注解来定义bean的依赖关系，通过反射机制动态加载和管理bean。另外，AOP模块实现了切面编程，允许我们定义横切关注点，如日志、事务...
[spring] 源码简析 容器启动和创建实例
weixin_33976072的博客
04-11 113
Spring的IOC容器在实现控制反转和依赖注入的过程，可以划分为两个阶段 容器启动阶段 Bean实例化阶段 本文主要从这两个角度来解析源码的执行流程。 我们知道启动容器阶段会创建beanFactory，同时会将spring.xml中定义的beanDefinition注册到beanFactory中,or 在解析xml的过程中会找到对应标签的解析器(比如comp...
Spring配置文件及容器的实例化
nuc_cheryl的专栏
06-29 463
spring的配置文件格式     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://www.springframework.org/schema/beans            http://www.springframework.org/schema/be
【Spring实战】Spring容器初始化完成后执行初始化数据方法
热门推荐
honghailiang的专栏
06-16 4万+
一、背景知识在做WEB项目时，经常在项目第一次启动时利用WEB容器的监听、Servlet加载初始化等切入点为数据库准备数据，这些初始化数据是系统开始运行前必须的数据，例如权限组、系统选项、默认管理员等等。而项目采用了Spring依赖注入来管理对象，而servlet并不受Spring的管理。若此时在servlet中注入Spring管理的对象，则无法使用，如下：
Spring之一 Spring容器XmlWebApplicationContext实例化与启动过程
nongfuyumin的专栏
04-21 965
XmlWebApplicationContext它既是 DispatcherServlet 的 (WebApplicationContext)默认策略，又是 ContextLoaderListener 创建 root WebApplicationContext(根容器，同时也是 DispatcherServlet 的 WebApplicationContext 的父容器)的默认策略。 X...
Spring中解析xml配置文件以及Bean实例化后的存放位置和Bean声明周期的管理
yunzhonghefei的博客
02-27 2204
配置文件的加载方式，bean被实例化后的存放位置     Spring容器不只是一个，自带了多个容器，可以归纳为两种类型         1.beanFactory，由org.springframework. beans.factory.BeanFactory接口定义是最简单的容器,提供基本的DI支持.         2. 应用上下文（由org.springframework.context.A...
官方原版源码 spring-framework-5.1.15.RELEASE.zip
05-06
Spring Core负责基础的IoC（Inversion of Control）容器，Spring Beans则实现了Bean的生命周期管理和配置，Spring Context则是基于Core之上构建的，提供了一个应用上下文，可以管理Bean并与其他Spring模块集成。...
官方源码spring-framework-5.0.15.RELEASE.zip
08-05
在源码中，我们可以看到`org.springframework.beans`和`org.springframework.context`包，它们是IoC容器的基础，通过BeanFactory和ApplicationContext实现对象的创建、配置和管理。 2. AOP支持：Spring的AOP模块...
spring源码spring-framework-4.2.5.RELEASE
12-04
1. **IoC（Inversion of Control）容器**：Spring的核心组件，负责管理对象的生命周期和依赖关系。在`org.springframework.beans`和`org.springframework.context`包中，我们可以看到BeanFactory和...
官方原版源码spring-framework-5.2.1.RELEASE.zip
11-04
IoC容器是Spring的核心，它负责管理对象的生命周期和依赖关系。AOP则为应用程序提供了一种模块化和解耦的方式，可以方便地实现横切关注点，如日志、事务管理等。 在Spring 5.2.1中，源码的改进主要集中在以下几个...
【Spring启动过程分析】启动流程简介
try to do
03-19 1万+
https://blog.csdn.net/moshenglv/article/details/53517343 首先，对于一个web应用，其部署在web容器(tomcat)中，web容器提供其一个全局的上下文环境，这个上下文就是ServletContext，其为后面的spring IoC容器提供宿主环境； spring容器启动流程 定位 在spring中，使用统一的资源表现方式Res...
Spring 启动流程：基于Xml配置启动做了什么？
以后的今天的博客
01-21 872
Spring 3.0之前主要基于xml配置，它的启动流程中，做了些什么？ 这里基于Spring5.0.8版本：对ClassPathXmlApplicationContext进行讲解，同时没有集成spring-web包，所以启动过程跳过servlet实现： ApplicationContext applicationContext = new ClassPathXmlApplicationConte...
Servlet容器（Tomcat）是如何启动和创建 Spring 容器的？
scorpio的博客
10-15 4606
Servlet容器（Tomcat）是如何启动和创建 Spring 容器的？
Spring纯注解开发
Admans的专栏
07-18 859
Spring3.0引入了纯注解开发的模式，框架的诞生是为了简化开发，那注解开发就是简化再简化。Spring的特性在整合MyBatis方面体现的淋漓尽致哦注解开发前，配置Bean时是在xml里将class分别写在Bean标签里，然后起id，就像这样注解开发后，配置Bean时首先将xml里的标签删掉，然后在类上添加@Component注解即可在xml文件中来写一个扫描包的注解标签，对象就装进IOC容器里了component-scan:component意为组件，scan意为扫描。
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 397
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
小哇
07-23 211
zookeeper安装并成功运行。
SpringMVC 控制层框架-下
woai3364的博客
07-20 1022
因此，在开发过程中，合理处理异常、避免异常产生、以及对异常进行有效的调试是非常重要的。如果张三负责的模块按照 A 方案处理异常，李四负责的模块按照 B 方案处理异常...各个模块处理异常的思路、代码、命名细节都不一样，那么就会让整个项目非常混乱。在Web 应用三层架构体系中，表述层负责接收浏览器提交的数据，业务逻辑层负责数据的处理。一个网站有 5、6个资源，其中有一个为登录资源，两个无需登录即可访问，另外三个需要登录后才能访问，如果不登录就访问那三个资源，需要拦截，并且提示登录后访问。
Springboo3中使用虚线程
java scala
07-19 373
Java中的虚线程类似Go中的协程，简单来说可以通过同步编程的方式来达到异步编程模式的效果，
Java面试八股之Spring容器的启动流程
最新发布
u012151345的博客
07-23 618
在整个过程中，Spring遵循了IoC（控制反转）和DI（依赖注入）原则，确保Bean的创建、配置、组装和管理都在容器的统一控制之下，实现了松耦合和可扩展的软件架构。创建BeanDefinition：解析配置信息的过程中，Spring会为每个Bean生成对应的BeanDefinition对象，它包含了Bean的类型、构造方法参数、属性值、初始化方法、依赖关系、作用域、生命周期回调方法等所有相关信息。Spring容器的启动流程涉及一系列有序的操作，以确保容器正确初始化并准备好管理应用程序中的Bean。
Spring源码揭秘：IOC容器详解与BeanFactory核心功能
学习Spring源码有助于开发者深入了解其内部工作机制，比如BeanDefinition的解析、Autowire机制、以及如何通过各种配置元数据如XML配置文件、注解等方式动态构建bean实例。通过分析源码，我们可以优化应用性能，提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值