Spring Bean加载过程（源码解读）

最新推荐文章于 2024-08-01 22:51:38 发布
置顶 最新推荐文章于 2024-08-01 22:51:38 发布
阅读量487 收藏 3
点赞数
分类专栏： Spring & SpringMVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37968613/article/details/109090610
版权

BeanFactory与ApplicationContext区别

BeanFactory是ApplicationContext的一个子集，BeanFactory只提供简单容器的功能，就像只有一个水桶，水桶里面只装了水。（水桶就像beanFactory，水就是bean）。ApplicationContext除了有容器功能以外，还提供了国际化，事件监听等，就像水桶了除了装了水，还有鱼，虾。

Spring Bean加载过程

言归正传，看bean的加载过程。我们只要选一个BeanFactory（单纯的水桶）作为例子来讲解，来看看水桶是怎么一步一步装水的。

测试代码：
/**
 * <pre>类名: ApplicationContextTest</pre>
 * <pre>描述: 应用上下文测试</pre>
 * <pre>版权: web_chen@163.com</pre>
 * <pre>日期: 2020/10/15 9:16</pre>
 * <pre>作者: chenwb</pre>
 */
public class ApplicationContextTest {

    public static void main(String[] args) {
        XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("/XmlConfig.xml"));
        System.out.println(((User)xmlBeanFactory.getBean("user")).getName());
    }
}

XmlConfig.xml，就是一个简单的user Bean

<?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:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	<bean id="user" class="ioc.User">
		<property name="name" value="Jerry"/>
	</bean>
</beans>

执行结果就是打印一次Jerry

十月 15, 2020 9:33:54 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [XmlConfig.xml]
Jerry
进入XmlBeanFactory：

它继承了DefaultListableBeanFactory，这是一个最常见的bean工厂实现。XmlBeanFactory内容很少，只有一个专门针对XML配置读取的XmlBeanDefinitionReader，XmlBeanDefinitionReader负责读取XML的Bean定义。

public class XmlBeanFactory extends DefaultListableBeanFactory {

	private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
	
	public XmlBeanFactory(Resource resource) throws BeansException {
		this(resource, null);
	}
	public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
		super(parentBeanFactory);
		this.reader.loadBeanDefinitions(resource);
	}
}

在DefaultListableBeanFactory中，主要有一个ConcurrentHashMap用来beanDefinition的定义（因为我们这次只管Bean的加载，就只管beanDefinition吧）：

	/** Map of bean definition objects, keyed by bean name */
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);
我们开始载入bean，XmlBeanDefinitionReader.loadBeanDefinitions(Resource resource)：
	@Override
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}
	
	// 进行BeanDefinitions载入
	public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		// resourcesCurrentlyBeingLoaded是一个ThreadLocal，用来记录当前正在载入的资源（主要是为并发场景考虑的，但我们这里没有并发）
		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
		if (currentResources == null) {
			currentResources = new HashSet<EncodedResource>(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		// 并发场景重复载入资源时报错
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
		try {
			// 将encodedResource转为InputStream，再转为InputSource 
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				// 真正开始加载bean定义
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				// threadLocal用完之后移除
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}
	
	// 前面资源格式进行了转换，接下来进行“真家伙”了
	protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
		try {
			// 加载Document
			Document doc = doLoadDocument(inputSource, resource);
			// 根据Document注册Bean
			return registerBeanDefinitions(doc, resource);
		}
		...省略异常捕获
	}
接下来就是doLoadDocument与registerBeanDefinitions了，就是一个取水，并将水加入水桶一样：

先看doLoadDocument，默认使用的是DefaultDocumentLoader：

	protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
		return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
				getValidationModeForResource(resource), isNamespaceAware());
	}
	
	/**
	 * Load the {@link Document} at the supplied {@link InputSource} using the standard JAXP-configured
	 * XML parser.
	 */
	@Override
	public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
			ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
		// 创建构建工厂
		DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
		// 获取构造器
		DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
		// 生成Document
		return builder.parse(inputSource);
	}

再看registerBeanDefinitions：

	// 返回的是本次注册的bean定义数量
	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		// BeanDefinitionDocumentReader 采用的是DefaultBeanDefinitionDocumentReader，不过这里采用的是反射，见下面
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		documentReader.setEnvironment(getEnvironment());
		int countBefore = getRegistry().getBeanDefinitionCount();
		// 根据documentReader读取BeanDefinitions； 后面会讲createReaderContext(resource)
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}
	// 通过反射实现，使用的Reader是可以进行自定义配置的
	protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
		return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));
	}
	private Class<?> documentReaderClass = DefaultBeanDefinitionDocumentReader.class;
进入DefaultBeanDefinitionDocumentReader.registerBeanDefinitions：
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		// 获取Document的根节点
		Element root = doc.getDocumentElement();
		// 从根节点进行加载
		doRegisterBeanDefinitions(root);
	}

```java
	protected void doRegisterBeanDefinitions(Element root) {
		// bean定义解析委托给BeanDefinitionParserDelegate 
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);
		
		if (this.delegate.isDefaultNamespace(root)) {
			// 读取profile属性，根据profile进行bean的注册，不符合profile的bean就不进行注册
			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)) {
					return;
				}
			}
		}
		// 解析前
		preProcessXml(root);
		// 开始解析BeanDefinitions
		parseBeanDefinitions(root, this.delegate);
		// 解析后
		postProcessXml(root);
		this.delegate = parent;
	}
前面已经获取了Document、根据Profile选取要加载的Beans，并将解析的工作委托给DefaultBeanDefinitionDocumentReader，接下来看DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)对每个Element进行解析：
	/**
	 * Parse the elements at the root level in the document:
	 * "import", "alias", "bean".
	 * @param root the DOM root element of the document
	 */
	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		// 如果是默认的命名空间http://www.springframework.org/schema/beans
		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);
					}
				}
			}
		}
		// 否则根据自定义的XSD进行自定义节点的解析
		else {
			delegate.parseCustomElement(root);
		}
	}
	
	// 校验默认的节点名称
	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		// import节点
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		// alias节点
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		// bean节点，下面会讲
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			processBeanDefinition(ele, delegate);
		}
		// 如果是beans节点，则进行递归
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}
前面我们水桶有了beanDefinitionMap，水也取到了parseBeanDefinitions，那后来水是如何放入水桶的呢？：

那就是在上面提到的processBeanDefinition方法了：

	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		// 解析BeanDefinition，并交给BeanDefinitionHolder 持有。
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			// 添加bean的其他属性，如scope，lazy-init等
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// 将bean注册进工厂 ，看下面
				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));
		}
	}
	
	// BeanDefinitionReaderUtils.registerBeanDefinition
	public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// 获取beanName，通过注册器BeanDefinitionRegistry 将bean注入到工厂中。这个注册器是XmlBeanDefinitionReader提供的
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
	    ......
	}

上面提到的注册器是XmlBeanDefinitionReader提供的，如果你还记得，一开始的XmlBeanFactory定义的就是这个XmlBeanDefinitionReader(this)，并将DefaultListableBeanFactory实现的BeanDefinitionRegistry注入到XmlBeanDefinitionReader中。而在registerBeanDefinitions(Document doc, Resource resource)中，createReaderContext方法又将XmlBeanDefinitionReader传递下去，使解析的时候可以通过getReaderContext().getRegistry()获取到一开始在DefaultListableBeanFactory实现的BeanDefinitionRegistry。

而registerBeanDefinition又是DefaultListableBeanFactory实现的

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

		BeanDefinition oldBeanDefinition;
		synchronized (this.beanDefinitionMap) {
			oldBeanDefinition = this.beanDefinitionMap.get(beanName);
			if (oldBeanDefinition != null) {
				//......校验
			}
			else {
				this.beanDefinitionNames.add(beanName);
				this.frozenBeanDefinitionNames = null;
			}
			// 将beanDefinition加入到beanDefinitionMap中
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
	}
总结：

这是一个拿桶，取水，装水的过程。先看整体，再仔细看细节。

c&0xff00
关注
专栏目录
【微服务】spring 控制bean加载顺序使用详解
congge
09-26 5745
spring 控制bean加载顺序使用详解
SpringBean生命周期——refresh源码解读
流楚丶格念的博客
11-01 1216
ApplicationContext没有Bean初始化，依赖注入等功能他都没有，他得简介的调用BeanFactory 来对Bean进行管理，ApplicationContext委托给BeanFactory 来干这些活，ApplicationContext做的是扩展的活，Bean的核心功能是在BeanFactory 中。下面我们深入探究下里面的ResourceEditorRegistrar资源类型转化器，我们可以看到不同的资源类型用不同转化器转化。我们在prepareRefresh();
Spring的Bean加载流程
m0_67393828的博客
08-02 328
这一步就是找到用户自定义的构造函数，然后调用它。①如果Bean实现了InitializingBean接口，执行afeterPropertiesSet()方法②如果Bean在Spring配置文件中配置了init-method属性，则会自动调用其配置的初始化方法。...
Spring源码(三)：bean的加载-准备阶段
最新发布
bashenanking的博客
08-01 387
我们先来看下bean的加载-准备阶段，此阶段主要是为真正开始创建bean做好前置工作（如处理FactoryBean、提前设置创建bean相关变量、后处理器应用、解决循环依赖等）
Spring中bean的加载过程
weixin_44227923的博客
02-19 7593
1.获取配置文件资源： 通过 ResourceLoader 来完成资源文件位置的定位，DefaultResourceLoader 是默认的实现， 同时上下文本身就给出了 ResourceLoader 的实现，可以从类路径、文件系统, URL 等方式 来定为资源位置。 2.对bean定义信息的解析： 容器通过 BeanDefinitionReader 来完成 bean 定义信息的解析，使 用的是...
Spring Bean加载过程
苦行僧
03-06 349
文章目录Spring Bean的加载过程Spring Bean的创建过程Spring Bean循环依赖解决方式 近期重新阅读Spring源码，总结了Spring Bean的加载过程如下： Spring Bean的加载过程 Spring Bean的创建过程 Spring Bean循环依赖解决方式 Spring中将循环依赖分成三种情况， 构造器循环依赖：无法解决，抛出BeanCurrentlyInCreationException异常。 setter循环依赖：只能解决单例Bean的循环依赖。 protot
Spring Bean生命周期源码详解
qq_44027353的博客
04-23 1624
之后child需要根据BeanDefinition来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition，也就是RootBeanDefinition。我们知道BeanPostProcessor接口的作用是在bean初始化前和初始化后执行一些方法，Spring提供了该接口的子接口来进行实例化前后执行的一些方法。可以在这个步骤中，对Bean最终进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返回的对象才是最终的Bean对象。
Spring容器启动流程（源码解读）
qq_37904909的博客
09-12 303
Spring Framework 是 Java 语言中影响最为深远的框架之一，其中的 IOC 和 AOP 两个经典思想更是一直被程序员津津乐道，后面推出的 Spring Boot、Spring Cloud 系列也是在其基础之上开发，要想搞明白 Spring 全家桶系列，必须脚踏实地的从 Spring Framework 学习起。
Spring源码——bean的加载
等一杯咖啡的博客
09-26 4510
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第五章的部分，依照书中内容以及个人理解对Spring进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 在前几篇文章中，我们已经完成了将XML配置文件的信息转换为 B...
spring 的bean加载流程
wenliying的博客
03-22 255
https://www.jianshu.com/p/9ea61d204559 bean加载细节，排版有点乱但是值得看 https://blog.csdn.net/dc282614966/article/details/81480002 顺便把beanPostProcessor的用途看下，例如@Autowired注解的解析过程 https://blog.csdn.net/qq_2...
Spring Bean 的加载过程
webot123456的博客
07-07 145
一个是populateBean,一个是initializeBean，这两个方法完成了bean的赋值与初始化。 这里有一个BeanDefinitionValueResolver，这个类用来解析property里的value，如果是依赖其他bean则会到容器中找是否存在如果有则返回，没有则创建一个。spring又为每个对象的属性定义了一个数据结构：PropertyValue,这样做加大了容器对bean属性的修改的灵活性，上面的方法就是对每个属性进行处理然后通过beanWapper的setPropertyValu
Spring bean的加载过程源码分析
持之以恒
07-27 860
spring-beans模块囊括了DI、IOC等经典实现；Bean密切相关的接口BeanFactory，与IOC容器、依赖注入、依赖查找等 有着千丝万缕的关系～ 其中默认实现类DefaultListableBeanFactory覆盖了这些功能，也可以通俗的理解DefaultListableBeanFactory实例就是一个IOC容器，bean的生命周期都围绕着它来完成 public class DefaultListableBeanFactory extends AbstractAuto.
spring bean的加载过程
horse_xiao的博客
11-16 1014
前景提要： spring中bean的加载过程的默认配置单例模式，且允许循环依赖。单例加载模式为懒加载。在添加注解@denpendOn的情况下会比变成从从BeanDefinition中的BeanDefinitionMap中获取该类的配置信息中加载到BeanFactory. 运行流程 类的扫描过程 扫描过程： beanFactory主要通过BeanDinition的相关子类来获取类信息。由上图可见BeanDinition的子类中记载了扫描的对象的配置信息以及基本信息。 其中当我们需要扫描一个新的
Spring的Bean加载过程
li_ya_kun的博客
10-26 157
在加载Bean时需要经历11个步骤 instantiate bean 对象实例化 属性注入 如果Bean 实现了BeanNameAware 执行setBeanName 方法 如果Bean实现了BeanFactoryAware 或者ApplicationContextAware 可执行设置工厂setBeanFactory 方法或者上下文对象setApplicationContext方法 如果Bea...
Spring加载Bean过程
weixin_44504392的博客
07-26 250
一、读取注解 先通过扫描指定路径下的spring注解或者XML配置，然后将其解析并封装到BeanDefintaion这个接口的实现类中。 二、bean生命周期 2.1 实例化 AbstractAutoWireCapableBeanFactory.doCreateBean中会调用createBeaninstance()方法，该阶段主要是从beanDefinitionMap循环读取bean，获取他的属性，然后利用反射读取对象的构造方法。 2.2 初始化 初始化包括两个步骤，一个是属性填充，另一个是具体初始化过程
Spring框架源码解析：bean与aspect深度探讨
"Spring源码解读.pptx 是一份关于深入理解Spring Framework的演讲稿，旨在帮助学习者掌握Spring的核心概念和工作原理。作者通过讲解bean的产生过程和AOP（面向切面编程）的概念，提供了对Spring Framework的深入洞察...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值