Spring源码教程02--Spring的IoC容器分析

最新推荐文章于 2025-08-18 22:47:43 发布
最新推荐文章于 2025-08-18 22:47:43 发布
阅读量77 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java
原文链接：https://juejin.im/post/5a6be836f265da3e2366b4d6
本文详细介绍了Spring框架中的IoC容器启动过程，包括Resource定位、Resource载入及注册等关键步骤，并深入分析了核心代码，帮助读者理解Spring如何初始化IoC容器。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

上一节“[原创]Spring教程01--Spring开始篇_Helloworld”中简单的介绍SpringFramwork的简单使用；通过Helloworld的程序做演示，本节将继续解读Spring的Ioc容器实现和分析。

Spring IoC容器启动过程

Spring的IoC容器启动大致分为下面的三个步骤：Resource定位、Resoure的载入、Resoured的注册 三个步骤；下面使用xml文件配置方式显示的配置方式步骤：

首先看下ApplicationContext的构造方法定义：

public FileSystemXmlApplicationContext(
		String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
		throws BeansException {
    
    //设置Context
	super(parent);
	//读取XML等配置文件定位
	setConfigLocations(configLocations);
	//创建BeanFactory的关键[重点]
	if (refresh) {
		refresh();
	}
}


@Override
//这个refresh()启动容器[重要的放在首位]
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			initMessageSource();

			// Initialize event multicaster for this context.
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			onRefresh();

			// Check for listener beans and register them.
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			finishRefresh();
		}

		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}

			// Destroy already created singletons to avoid dangling resources.
			destroyBeans();

			// Reset 'active' flag.
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetCommonCaches();
		}
	}
}
复制代码

Resource定位

为了便于理解；提前解析了Context的属性如下：

对象名类 型作 用归属类
configResourcesResource[]配置文件资源对象数组ClassPathXmlApplicationContext
configLocationsString[]配置文件字符串数组，存储配置文件路径AbstractRefreshableConfigApplicationContext
beanFactoryDefaultListableBeanFactory上下文使用的Bean工厂AbstractRefreshableApplicationContext
beanFactoryMonitorObjectBean工厂使用的同步监视器AbstractRefreshableApplicationContext
idString上下文使用的唯一Id，标识此ApplicationContextAbstractApplicationContext
parentApplicationContext父级ApplicationContextAbstractApplicationContext
beanFactoryPostProcessorsList存储BeanFactoryPostProcessor接口，Spring提供的一个扩展点AbstractApplicationContext
startupShutdownMonitorObjectrefresh方法和destory方法公用的一个监视器，避免两个方法同时执行AbstractApplicationContext
shutdownHookThreadSpring提供的一个钩子，JVM停止执行时会运行Thread里面的方法AbstractApplicationContext
resourcePatternResolverResourcePatternResolver上下文使用的资源格式解析器AbstractApplicationContext
lifecycleProcessorLifecycleProcessor用于管理Bean生命周期的生命周期处理器接口AbstractApplicationContext
messageSourceMessageSource用于实现国际化的一个接口AbstractApplicationContext
applicationEventMulticasterApplicationEventMulticasterSpring提供的事件管理机制中的事件多播器接口AbstractApplicationContext
applicationListenersSetSpring提供的事件管理机制中的应用监听器AbstractApplicationContext

1）设置存储配置文件路径

AbstractRefreshableConfigApplicationContext 的 setConfigLocations() 方法确定其文件的位置；代码比较简单。

public void setConfigLocations(@Nullable String... locations) {
	if (locations != null) {
		Assert.noNullElements(locations, "Config locations must not be null");
		this.configLocations = new String[locations.length];
		for (int i = 0; i < locations.length; i++) {
			this.configLocations[i] = resolvePath(locations[i]).trim();
		}
	}
	else {
		this.configLocations = null;
	}
}
复制代码

在上面的过程；我们获取配置文件的路径内容。下面看看具体的IoC容器的创建的具体过程了。

2）加载配置文件的路径

（1）创建BeanFactory

@Override
protected final void refreshBeanFactory() throws BeansException {
	if (hasBeanFactory()) {
		destroyBeans();
		closeBeanFactory();
	}
	try {
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		beanFactory.setSerializationId(getId());
		customizeBeanFactory(beanFactory);
		loadBeanDefinitions(beanFactory);
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}
复制代码

（2）读取文件配置 这个中间调用过程省略了；直接看结果：这里直接看log日志结果我们不用说太多了...

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	Assert.notNull(encodedResource, "EncodedResource must not be null");
	if (logger.isInfoEnabled()) {
		logger.info("Loading XML bean definitions from " + encodedResource.getResource());
	}

	Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
	if (currentResources == null) {
		currentResources = new HashSet<>(4);
		this.resourcesCurrentlyBeingLoaded.set(currentResources);
	}
	if (!currentResources.add(encodedResource)) {
		throw new BeanDefinitionStoreException(
				"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
	}
	try {
		InputStream inputStream = encodedResource.getResource().getInputStream();
		try {
			InputSource inputSource = new InputSource(inputStream);
			if (encodedResource.getEncoding() != null) {
				inputSource.setEncoding(encodedResource.getEncoding());
			}
			//下面开始解析XML方法
			return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
		}
		finally {
			inputStream.close();
		}
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException(
				"IOException parsing XML document from " + encodedResource.getResource(), ex);
	}
	finally {
		currentResources.remove(encodedResource);
		if (currentResources.isEmpty()) {
			this.resourcesCurrentlyBeingLoaded.remove();
		}
	}
}
复制代码

Resource的载入

下面我们接着根据路径配置，读取到内存中；采用SAX文件的解析；看源码：

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
	throws BeanDefinitionStoreException {
    ...
try {
	Document doc = doLoadDocument(inputSource, resource);
	//解析xml文件注册JavaBean
	return registerBeanDefinitions(doc, resource);
}
    ...
    //省略catch()代码...
复制代码

Resouce文件的解析

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.isInfoEnabled()) {
					logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
							"] not matching: " + getReaderContext().getResource());
				}
				return;
			}
		}
	}

	preProcessXml(root);
	//重点代码：注册JavaBean
	parseBeanDefinitions(root, this.delegate);
	postProcessXml(root);

	this.delegate = parent;
}
复制代码

其实写到这里感觉大家有兴趣的可以继续看看这个；如何读取xml文件如理 <bean> 等标签的操作...这里我推荐一片文章吧： Spring解密 - XML解析 与 Bean注册；后面写的比较具体。截止到目前通过XML解析；将配置文件读取到BeanDefine中；下面看看如何将其注册到IoC容器。

注册IoC容器

	@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		BeanDefinition oldBeanDefinition;

		oldBeanDefinition = this.beanDefinitionMap.get(beanName);
		if (oldBeanDefinition != null) {
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
						"': There is already [" + oldBeanDefinition + "] bound.");
			}
			else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (this.logger.isWarnEnabled()) {
					this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							oldBeanDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(oldBeanDefinition)) {
				if (this.logger.isInfoEnabled()) {
					this.logger.info("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + oldBeanDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (this.logger.isDebugEnabled()) {
					this.logger.debug("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + oldBeanDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			//将获取BeanName和之前解析BeanDefine放入Map集合中从而完成注册
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					if (this.manualSingletonNames.contains(beanName)) {
						Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
						updatedSingletons.remove(beanName);
						this.manualSingletonNames = updatedSingletons;
					}
				}
			}
			else {
				// Still in startup registration phase
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				this.manualSingletonNames.remove(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (oldBeanDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}
复制代码

上面的源码中我们呢需要关注this.beanDefinitionMap.put(beanName, beanDefinition);这句代码；这个Bean注入BeanDefineMap中；到此这里已经完成了IoC容器的初始化。

到这里基本已经结束了；ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");这样一句代码其实；也写了一章节；其实如果你是看着篇文章可以参考我的方法堆栈进行阅读。最后文章的部分其实源都简明的展示给你；后期我希望可以使用更多图展示给大家。

参考资料：

Spring IOC---invokeBeanFactoryPostProcessors源码分析
gongsenlin341的博客
09-06 6543
文章目录1.概述2.准备工作。3.源码调试invokeBeanFactoryPostProcessors3.1.getBeanFactoryPostProcessors（）3.2.invokeBeanFactoryPostProcessors(3.2.1 先来介绍一下这个方法中出现的集合。3.2.2 源码调试分析3.2.2.1 处理手动添加的 实现了BeanDefinitionRegistryPostProcessor接口的类3.2.2.2 处理Spring自带的后置处理器ConfigurationClas
Spring 源码分析--Spring源码面试系列---Spring注解实现IOC的过程解析
java技术专家全栈成长之路
05-13 633
第一章：基于Annotation的IOC初始化 1、Annotation的前世今生 2、定位Bean扫描路径 3、读取Annotation元数据 4、扫描指定包并解析为BeanDefinition 5、载入注解Bean 第二章：Spring自动装配之依赖注入 1、依赖注入发生的时间 2、寻找获取Bean的入口 3、开始实例化 4、选择Bean实例化策略 5、执行Bean实例化 6、准备依赖注入 7、解析属性注入规则 8、注入赋值 第三章：IOC容器中那些鲜为人知的事 关于延时
Spring IoC容器源码深度解析
boydoy1987的专栏
08-15 949
IoC(Inversion of Control)是Spring框架的基础，它负责管理对象的创建、配置和生命周期。Spring的IoC容器主要由和接口定义。
一 spring源码分析--- IOC容器
yamorn的专栏
03-04 928
前言 在分析spring源码之前，推荐Spring作者 Rod Johnson的两本书： Expert One-on-One J2EE Design and DevelopmentExpert One-on-One J2EE Development without EJB 这两本书是spring 作者多年的J2EE工作中总结的思想和经验，spring框架就是在这些思想上开发出来的
Spring - 手把手分析 IoC 容器创建过程
业精于勤荒于嬉
10-25 2797
Spring - 手把手分析 IoC 容器创建过程
Spring-IoC源码分析
一名蒟蒻的博客
05-25 2423
IoC源码分析 1、IoC定义 将原本在程序中⼿动创建对象的控制权，交由Spring框架来管理。 IoC 容器是 Spring⽤来实现 IoC 的载体， IoC 容器实际上就是个Map（key，value），Map 中存放的是各种对象 将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注⼊。 IoC 容器就像是⼀个⼯⼚⼀样，当我们需要创建⼀个对象的时候，只需要配置好配置⽂件/注解即 可，完全不⽤考虑对象是如何被创建出来的。 IoC 的实现原理就是工厂模式加反射机制 优点： 代
Spring源码分析：IOC容器的刷新 - refresh()
adobe754的博客
01-04 1609
Spring源码分析：IOC容器的刷新 - refresh()
Spring源码深度解析-2、IOC容器的设计
开始写bug~~~
12-27 571
前言 前面暂时结束jvm与java基础的整理，今天开始整理spring的内容。 demo 先从一个demo开始，最开始学spring，大家都写过这样的demo。 //实体类 package com.ycf.test; public class User { private String userName; private int userAge; public String getUser...
【01】Spring源码-手写篇-手写IoC实现
波波烤鸭的博客
08-24 1160
Spring源码系列-手写篇之手写IoC
Spring IOC 容器源码分析 - 余下的初始化工作
GarfieldEr007的专栏
12-23 1097
1. 简介 本篇文章是“Spring IOC 容器源码分析”系列文章的最后一篇文章，本篇文章所分析的对象是 initializeBean 方法，该方法用于对已完成属性填充的 bean 做最后的初始化工作。相较于之前几篇文章所分析的源码，initializeBean 的源码相对比较简单，大家可以愉快的阅读。好了，其他的不多说了，我们直入主题吧。  2. 源码分析 本章我们来分析一下 initi...
spring源码-2022-08-14spring源码spring源码spring源码
08-14
在2022年8月14日更新的Spring源码中，我们可以深入理解其设计理念和实现机制。 Spring框架的主要组成部分包括： 1. **核心容器**：这是Spring的基础，主要包括BeanFactory和ApplicationContext。BeanFactory负责...
01-Spring源码手写篇-手写IOC.md
10-23
01-Spring源码手写篇-手写IOC.md
spring-ioc源码分析
01-10
Spring IoC源码分析涉及的内容非常广泛，不仅包括容器的初始化、Bean的加载与依赖注入，还包括生命周期管理、作用域定义、延迟加载以及新版本中的Java配置等。通过分析这些关键组件和概念，开发者可以更加深入地理解...
Java——琐碎知识点2
2401_88065518的博客
08-15 744
Java基础知识点：Java官方帮助文档、Scanner扫描器、快捷键、“==”做比较、获取代码运行时间、打印对象名时不会出现内存地址的类型、Arrays类常用方法、循环标号的使用、Lambda表达式、异常处理、Java浮点数的精度问题（BigDecimal）、DecimalFormat格式化数字工具、printf格式化输出
08.常见文本处理工具
最新发布
weixin_56408536的博客
08-18 506
查看二进制文件的不同。
JavaScript 核心基础：类型检测、DOM 操作与事件处理
热爱音乐和二次元！
08-15 1331
本文系统梳理 JavaScript 核心知识点，包括数据类型检测规则、遍历方式、DOM操作和事件处理。重点解析 typeof 运算符对不同数据类型的检测结果，数组与对象的遍历方法差异，以及使用 querySelector 获取元素的现代方案。同时详细讲解事件绑定的两种方式（onclick 覆盖 vs addEventListener 多播）和事件冒泡机制，帮助开发者构建扎实的 JS 基础，写出更健壮的代码。
cat本地部署
Chaser______的博客
08-15 744
CAT监控系统部署指南 环境准备：JDK1.8、Tomcat、MySQL 获取CAT包：通过Git克隆源码或下载官网war包 部署步骤： 创建/data目录结构并设置权限 配置client.xml、datasources.xml和server.xml 导入SQL文件创建数据库 将cat.war部署到Tomcat的webapps目录 启动服务：启动Tomcat后访问http://ip:8080/cat 注意事项：将配置文件中的127.0.0.1替换为实际IP地址 （98字）
Java集合Map与Stream流：Map实现类特点、遍历方式、Stream流操作及Collections工具类方法
FUYY'S BLOG
08-15 735
Stream流是Java 8引入的处理集合数据的高级工具，它不是数据结构，而是数据处理管道，可以对集合、数组等数据源进行高效的聚合操作（如过滤、排序、统计等）。
蓝凌EKP产品：JSP 性能优化和 JSTL/EL要点检查列表
wwwhongxia的专栏
08-17 997
使用或获取 Spring BeanFilter 本身由 Tomcat 管理，但业务逻辑由 Spring 管理支持 Redis 缓存、限流、统计等功能JSP 内置对象作用域优化临时页面变量使用page作用域避免使用 request/session/application 存储短期临时数据提升性能，降低内存压力。
深入学习Spring框架源码分析-版本2.5.4
学习Spring源码的过程需要从理解Spring的基本原理开始，比如IoC容器的工作原理、bean的生命周期、事务管理机制等。然后，深入阅读源码，理解Spring的设计模式和架构。可以通过阅读官方文档、源码注释、在线教程和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值