Spring源码系列：容器的基本实现

最新推荐文章于 2022-11-25 00:00:08 发布
最新推荐文章于 2022-11-25 00:00:08 发布
阅读量1k 收藏 2
点赞数 4
分类专栏： Java Spring 文章标签： spring 容器 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zong_0915/article/details/122830281
版权
Java 同时被 2 个专栏收录
74 篇文章 6 订阅
订阅专栏
Spring
30 篇文章 3 订阅
订阅专栏

Spring源码系列：容器的基本实现

前言

什么是容器？

  1. Spring容器是Application的一个实例对象。
  2. 容器负责的实例化、配置Bean、管理Bean的生命周期。
  3. Spring容器将我们代码中的PoJo类、XML配置文件转化为一个可用的系统。

那么接下来会以spring-beans包下的一些核心类展开来讲解容器是怎么实现的。

一. 容器的基本实现

要想了解Spring容器的概念和深入源码，相信一切都得从这个容器的出生开始，那么在此以DefaultListableBeanFactory为切入点来讲解。

那么DefaultListableBeanFactory类是干什么的呢？用百度翻译一下源码中的注释，如下：

  1. 作为ConfigurableListableBeanFactory和BeanDefinitionRegistry接口的默认实现。
  2. 一个基于bean定义元数据的工厂类，用于注册所有的bean。（可能是PoJo类、配置文件）。
  3. 可以操作预先解析的bean元数据对象。

那么来看下这个类的关系图：
在这里插入图片描述
我们可以重点关注图中蓝色框圈起来的部分，我们可以做个总结，DefaultListableBeanFactory类对bean的作用有两个方向：

  • 进行监听，对于满足条件的bean进行定义和注册。
  • 对bean进行增删改查等操作（一些动作实现）。

DefaultListableBeanFactory作为整个bean加载的核心部分，是Spring注册和加载bean的一个默认实现。其还有个子类XmlBeanFactory，主要用于从XML文件中读取BeanDefinition。

我个人理解是这样的：

  • 一些PoJo类，其加载一般交给DefaultListableBeanFactory来执行。
  • 而对于XML形式配置的Bean，则交给XmlBeanFactory来执行。

Tip：

Definition是什么意思？其单词本意是：定义。
而BeanDefinition像是对Bean的一个抽象模板，定义了Bean的一些行为、属性等。
那么自然而然的，BeanDefinitionRegistry就是该模板的注册器了。

1.1 资源的读取

Spring的大部分功能都是以配置作为切入点。而上文提到的，XmlBeanFactory负责XML配置形式的Bean的加载。而从XML这类资源文件中读取、解析以及注册等流程，则交给XmlBeanDefinitionReader来完成。

来看下XmlBeanDefinitionReader的类关系图：
在这里插入图片描述
XmlBeanDefinitionReader类下有这么几个重要的成员：

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
	// 定义从资源文件加载到转化为Document的功能
	private DocumentLoader documentLoader = new DefaultDocumentLoader();
	// 前者负责转化为Document，那么documentReaderClass 就负责读取Document 并注册 BeanDefinition
	private Class<? extends BeanDefinitionDocumentReader> documentReaderClass = DefaultBeanDefinitionDocumentReader.class;
}

XmlBeanDefinitionReader类的父类AbstractBeanDefinitionReader下又有这么几个重要的成员：

public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader, EnvironmentCapable {
	// 定义资源加载器，主要应用于根据给定的资源文件地址，返回对应的Resource。
	private ResourceLoader resourceLoader;
}

将上文做个总结，XmlBeanDefinitionReader主要做的事情就是：

  1. 利用父类AbstractBeanDefinitionReader的ResourceLoader来将资源文件路径转化为对应的Resource。
  2. 将Resource进行文件转换，转换为Document文件。
  3. 使用DefaultBeanDefinitionDocumentReader进行文件解析。

1.1.1 Resource资源

Spring的配置文件是通过ClassPathResource来封装的，我们来看下他的类关系图：
在这里插入图片描述
顶层接口InputStreamSource只提供了一个方法：提供返回InputStream流的方法。

public interface InputStreamSource {
	InputStream getInputStream() throws IOException;
}

Resource接口用于封装底层资源，抽象了所有Spring内部使用到的资源：Flie、URL、Classpath等。提供了3个判断当前资源状态的方法。

  1. 存在性exists()。
  2. 可读性isReadable()。
  3. 是否处于打开状态isOpen()。

同时还提供了不同资源到URL、URI、File类型的转换，Resource接口的具体实现有：

  1. FileSystemResource（文件）。
  2. ClassPathResource（ClassPath资源）。
  3. UrlResource（URL资源）。
  4. InputStreamSource（InputStream资源）。
  5. ByteArrayResource（Byte数组）。

1.2 资源的加载和解析

在Spring将配置文件封装为Resource类型的实例后，就会由XmlBeanDefinitionReader来完成资源加载。
我们来直接看其核心方法loadBeanDefinitions()，上文读取好的资源文件（Resource实例）则作为其参数传入：

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
	@Override
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}
}

直观的来看这个方法，我们发现，在做Bean加载之前，会对Resource实例对象进行编码。

// 先对Resource资源进行编码封装
new EncodedResource(resource)

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	Assert.notNull(encodedResource, "EncodedResource must not be null");
	if (logger.isTraceEnabled()) {
		logger.trace("Loading XML bean definitions from " + encodedResource);
	}
	// 用来记录 已经加载完成的资源 的Set集合
	Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
	// 1.如果发现，该资源已经被加载过，那么抛异常，说明你这个资源重复加载了。
	if (!currentResources.add(encodedResource)) {
		throw new BeanDefinitionStoreException(
				"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
	}
	// 2.获取每个Resource资源对应的inputStream流
	try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
		InputSource inputSource = new InputSource(inputStream);
		// 2.1 设置对应的编码，这是考虑到Resource可能存在编码要求的情况
		if (encodedResource.getEncoding() != null) {
			inputSource.setEncoding(encodedResource.getEncoding());
		}
		// 2.2 进行真正的Bean加载
		return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
	}
	// ...
}

再看下核心的doLoadBeanDefinitions(inputSource, encodedResource.getResource())方法：

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {

	try {
		Document doc = doLoadDocument(inputSource, resource);
		int count = registerBeanDefinitions(doc, resource);
		if (logger.isDebugEnabled()) {
			logger.debug("Loaded " + count + " bean definitions from " + resource);
		}
		return count;
	}
	// 以下都是各种catch方法，我们主要关注try语句块中做的事情即可。
}

这个方法主要做三件事情：

  1. 获取XML文件的验证模式。
  2. 加载XML文件，并得到对应的Document。
  3. 根据返回的Document注册Bean信息。

而doLoadDocument()这个方法，则做了前两件事情。我们以这行代码为切入点，来展开。

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
	// 这里的documentLoader指的是上文提到的DefaultDocumentLoader，负责将Resource实例转化为Document
	return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
			getValidationModeForResource(resource), isNamespaceAware());
}

1.2.1 获取XML的验证模式

XML的验证模式有什么用？其保证了XML文件的正确性。常用的验证模式有两种：

DTD

Document Type Definition：文档类型定义，一种XML约束模式语言，是XML文件的验证机制。 属于XML文件组成的一部分。可以通过比较XML文档和DTD文件来判断文档是否符合规范。一个DTD文档包含：

  1. 元素的定义规则。
  2. 元素间关系的定义规则。
  3. 元素可使用的属性。
  4. 可使用的实体或者符号规则。

DTD案例：注意DOCTYPE

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"  
"http://www.springframework.org/dtd/spring-beans-2.0.dtd">  
<beans>  
  
</beans>
XSD

XML Schemas Definition：XML Schema语言就是XSD。描述了XML文档的结构。XML Schema 本身就是XML文档，符合其语法结构，可以用通用的XML解析器来解析。一个XSD包括：

  1. 文档中出现的元素。
  2. 文档中出现的属性、子元素。
  3. 子元素的数量和顺序。
  4. 元素是否为空。
  5. 元素和属性的数据类型。
  6. 元素或属性的默认和固定值。

XSD案例：

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"  
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"  
    xsi:schemaLocation="  
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
  
</beans>

使用XML文档的时候，必须做到几点：

  1. 声明名称空间xmlns="http://www.springframework.org/schema/beans" 。
  2. 指定该名称空间对应的XML Schema文档的存储位置xsi:schemaLocation="xxx" 。一部分是名称空间的URI，另一部分是该名称空间所标识的XML Schema文件位置或者URL地址。

其他：

  1. 声明XML Schema 实例xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

言归正传，我们回到代码本身，来关注下getValidationModeForResource()方法：

protected int getValidationModeForResource(Resource resource) {
	int validationModeToUse = getValidationMode();
	// 如果手动制定了验证模式，则使用指定的验证模式
	if (validationModeToUse != VALIDATION_AUTO) {
		return validationModeToUse;
	}
	// 如果没有手动指定，那么使用自动检测
	int detectedMode = detectValidationMode(resource);
	if (detectedMode != VALIDATION_AUTO) {
		return detectedMode;
	}
	return VALIDATION_XSD;
}

其实detectValidationMode()方法并不是很难理解，我只会贴出最最核心的代码：

private static final String DOCTYPE = "DOCTYPE";

if (hasDoctype(content)) {
	isDtdValidated = true;
	break;
}

private boolean hasDoctype(String content) {
	return content.contains(DOCTYPE);
}

说白了就是，如果发现文档中包含了DOCTYPE，该XML模式就是DTD，否则就是XSD。（看到这里可以回顾下上文的DTD案例）

1.2.2 获取Document

在验证完XML模式的合法性后，会将Resource实例转化为Document，再来回顾这行代码：

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
	// 这里的documentLoader指的是上文提到的DefaultDocumentLoader，负责将Resource实例转化为Document
	return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
			getValidationModeForResource(resource), isNamespaceAware());
}

其本质是通过SAX解析XML文档。

SAX解析：逐行扫描文档，一边扫描一边解析。其工作原理简单地说就是：
对文档进行顺序扫描，当扫描到文档（document）开始与结束、元素（element）开始与结束、文档（document）结束等地方时通知事件处理函数，由事件处理函数做相应动作，然后继续同样的扫描，直至文档结束。

我们先来看下getEntityResolver()这个方法是干什么的：

protected EntityResolver getEntityResolver() {
	if (this.entityResolver == null) {
		// Determine default EntityResolver to use.
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader != null) {
			this.entityResolver = new ResourceEntityResolver(resourceLoader);
		}
		else {
			this.entityResolver = new DelegatingEntityResolver(getBeanClassLoader());
		}
	}
	return this.entityResolver;
}
EntityResolver

什么是EntityResolver？

如果SAX应用程序需要实现自定义的处理外部实体，则必须实现此接口并使用setEntityResolver方法向SAX驱动器注册一个实例。

而对于项目本身而言，则可以提供一个寻找DTD声明的方法。
我们来看下EntityResolver接口：

public interface EntityResolver {
    public abstract InputSource resolveEntity (String publicId, String systemId) throws SAXException, IOException;
}

他接收俩参数，publiId和systemId
以上文的DTD和XSD案例为例，若是读取XSD配置文件，则获得的参数如下：

  • publiId：null
  • systemId：http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

若读取的是DTD文件：

  • publiId：-//SPRING//DTD BEAN 2.0//EN
  • systemId：http://www.springframework.org/dtd/spring-beans-2.0.dtd

为啥会出现不同呢？Spring使用DelegatingEntityResolver来实现该接口：

public class DelegatingEntityResolver implements EntityResolver {
	public static final String DTD_SUFFIX = ".dtd";
	public static final String XSD_SUFFIX = ".xsd";
	@Override
	@Nullable
	public InputSource resolveEntity(@Nullable String publicId, @Nullable String systemId) throws SAXException, IOException {
		if (systemId != null) {
			// 若加载dtd类型，则直接截取systemId最后的xx.dtd，然后去当前路径下寻找
			if (systemId.endsWith(DTD_SUFFIX)) {
				return this.dtdResolver.resolveEntity(publicId, systemId);
			}
			// 若加载xsd类型，则默认到META-INF/Spring.schemas文件中找到systemId对应的XSD文件并加载。
			else if (systemId.endsWith(XSD_SUFFIX)) {
				return this.schemaResolver.resolveEntity(publicId, systemId);
			}
		}
		return null;
	}
}

最后，关于如何转换Document，即loadDocument()方法的最终实现就简单概括，其由DefaultDocumentLoader来完成。

public class DefaultDocumentLoader implements DocumentLoader {
	@Override
	public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
			ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

		DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
		if (logger.isTraceEnabled()) {
			logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
		}
		DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
		return builder.parse(inputSource);
	}
}

主要做三件事：

  1. 创建DocumentBuilderFactory工厂。
  2. 工厂创建一个文档构造器DocumentBuilder。
  3. 解析inputSource来生成Document对象。

1.2.3 解析和注册BeanDefinition

上文的代码里，只剩下这行代码没有讲解了，也就是在将文件转化为Document后，重点做的事情：提取和注册Bean。

// doc则是1.2.2中获取到的Document
int count = registerBeanDefinitions(doc, resource);

代码展开：

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		// 1.实例化BeanDefinitionDocumentReader 
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		// 2.获取之前已经加载好的BeanDefinition个数
		int countBefore = getRegistry().getBeanDefinitionCount();
		// 3.加载和注册Bean
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		// 4.记录本次加载的BeanDefinition个数
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}
}

BeanDefinitionDocumentReader只是一个接口，应用单一职责的原则，将具体的逻辑registerBeanDefinitions()方法委托给单一的类去进行处理。具体的实现类为DefaultBeanDefinitionDocumentReader，我们来看下其具体的实现：

public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader {
	@Override
	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)) {
			// 处理profile属性
			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()) {
						log..
					}
					return;
				}
			}
		}
		// 解析前处理，交给子类实现。父类给子类提供模板，即模板模式的一个体现
		preProcessXml(root);
		parseBeanDefinitions(root, this.delegate);
		// 解析后处理，交给子类实现
		postProcessXml(root);

		this.delegate = parent;
	}
}

profile属性，用于在配置文件中指定开发环境，这样可以方便的进行切换开发、部署环境。常用的是更换不同的数据库。
如同一个配置文件中：

<bean profile="dev">xx</bean>
<bean profile="production">xx</bean>

那么集成到Web环境中，则在web.xml中加入以下代码：

<context-param>
	<param-name>Spring.profiles.active</param-name>
	<param-value>dev</param-value>
</context-param>

接下来再看看parseBeanDefinitions方法：

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	// bean处理
	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 ele) {
				// bean处理
				if (delegate.isDefaultNamespace(ele)) {
					parseDefaultElement(ele, delegate);
				}else {
					// bean处理
					delegate.parseCustomElement(ele);
				}
			}
		}
	}
	else {
		delegate.parseCustomElement(root);
	}
}

Spring的XML配置中Bean的声明方式有两大类：

  • 默认的：<bean id = "xx" class="xx.xx"/>
  • 自定义的：<tx:annotation-driven/>

上述代码也就是对不同情况进行不同的Bean处理。其中核心的parseDefaultElement和parseCustomElement方法则在下文继续讲解。

1.3 总结

在这里，先对上文做个总结，方便大家思考和理解。

DefaultListableBeanFactory作为Bean加载的一个核心部分，是Spring注册和加载Bean的一个默认实现。有两个重要的功能：

  • 注册和加载Bean。（顶层实现AliasRegistry）
  • 对Bean进行增删改查等操作。(顶层实现BeanFactory)

Spring的大部分功能都是以配置作为切入点。XML这类资源文件的读取、解析和注册都是在XmlBeanDefinitionReader类中来完成。

资源读取：

  • Spring有自己的资源接口Resource，用于将不同类型的资源对象抽象成Resource实例对象。

资源解析：

  • XmlBeanDefinitionReader的loadBeanDefinitions()方法进行Bean的加载解析。
  • 对Resource实例对象进行编码。
  • 获取XML文件的验证模式（共两种：DTD、XSD）。
  • 若验证通过，加载XML文件（使用Sax解析，即一边扫描XML一边解析），将Resource实例对象中的InputStream流转化为对应的Document对象doc。

资源注册：

  • 根据doc来提取和注册Bean。
  • 通过DefaultBeanDefinitionDocumentReader的registerBeanDefinitions()方法先处理profile属性（用于在配置文件中指定开发环境）。
  • 然后再解析标签处理生成BeanDefinition。

到这里Spring的Bean容器（工厂）对资源的处理工作也就做完了，更深层次的，对于Bean层面的解析和加载则交给后文。

二. 简单的小案例

我是在Spring5.0.x版本源码项目上，创建了自己的Test，如图：
在这里插入图片描述
创建User类：

public class User {
	private int id;
	private String name;
	// get set
}

在test目录下的resources资源文件目录中，创建user.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	   xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	   xsi:schemaLocation="
   	http://www.springframework.org/schema/beans
   	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   	http://www.springframework.org/schema/aop
   	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   	http://www.springframework.org/schema/tx
   	http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   	http://www.springframework.org/schema/context
   	http://www.springframework.org/schema/context/spring-context-3.0.xsd">
	<bean name="user" class="org.springframework.beans.User">
		<property name="id" value="1" />
		<property name="name" value="你好" />
	</bean>
</beans>

测试类：

package org.springframework.beans;

import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class Test {
	@org.junit.jupiter.api.Test
	public void test() {
		ClassPathResource resource = new ClassPathResource("user.xml");
		XmlBeanFactory factory = new XmlBeanFactory(resource);
		User user = (User) factory.getBean("user");
		System.out.println(user.getId());
		System.out.println(user.getName());
	}
}

结果如下：
在这里插入图片描述
一般读取XML形式的Bean，有三步：

  1. 通过ClassPathResource加载对应的xml文件。
  2. 通过resource实例对象创建出Bean工厂XmlBeanFactory。
  3. Bean工厂通过Name来获取对应的Bean。

备注：注意，XmlBeanFactory对于Spring来说，已经是个过时的类了。不推荐使用。上述代码可以改为（本质一样的）：

@org.junit.jupiter.api.Test
public void test() {
	BeanFactory factory = new DefaultListableBeanFactory();
	XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((BeanDefinitionRegistry) factory);
	
	ClassPathResource resource = new ClassPathResource("user.xml");
	reader.loadBeanDefinitions(resource);
	
	User user = (User) factory.getBean("user");
	System.out.println(user.getId());
	System.out.println(user.getName());
}

本篇文章，从外层看，已经介绍了Bean容器对资源的一个加载和解析流程，而上述的案例中，Spring是如何把XML配置中的Bean加载进来的？又是如何得到我们配置的字段值的？答案也就是源码中核心的parseDefaultElement和parseCustomElement方法。下篇文章则从标签的解析来做具体的展开介绍。

Zong_0915
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
简单Spring容器实现
梦想从这里开始
06-23 320
在写完《IOC原理分析》，本来就准备写这个《简单Spring实现》的， 但是因为复习数据结构和Collection，就一直拖到现在了，今天还是抽一天时间来把这个的总结和代码都写了吧.      恩，《IOC原理分析》中已经很详细的说明了Spring的IOC理念，在这里，就不累述了。      今天我们要做以下几件事 ：          一.进行OO分析， 给出代码框架      
Spring(一)：容器的实现——两大核心类
GDUT_Trim的博客
09-09 615
分析容器如何实现Spring的结构组成beans包的层级结构核心类DefaultListableBeanFactoryXmlBeanDefinitionReaderXmlBeanDefinitionReader的执行步骤 分析容器如何实现 在Sping官网中的一段入门代码 todo 步骤如下 读取Spring的配置文件 从配置文件中找到对应Bean的信息（bean的那一段信息） 根据找到的Bean信息进行实例化Bean 所以要想实现容器，至少需要3个类 ConfigReader：用来读取和校验配置文.
实现一个简单的 Spring Bean 容器
良月柒
11-25 127
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 6分钟。来自：网络，侵删面对复杂的源码，试着找到开头和结尾是一件非常具有挑战的事。为了让更多的初学者上手，从本文开始，我们将通过实践的方式带领读者逐步实现 Spring 框架的核心链路和功能逻辑。简化上手、凸显重点、摒弃冗余，让更多的初学者都能在这场学习旅途中收获满满。旅途即将开始，你准备好了吗？本文难度：★☆☆☆☆本文重点：...
Spring容器的基本实现
yfxlr的博客
03-07 464
1.容器的基本用法 bean是Spring中最核心的东西，因为Spring就像是个大水桶，而bean就像是容器中的水，水桶脱离了水也便没什么用处了。 Spring的目的就是让我们的bean能成为一个纯粹的POJO，这也是Spring所追求的。 2.功能分析 bean完成的功能无非就是以下几点： ·读取配置文件 ·根据配置文件中的配置找到对应的类的配置，并实例化。 ·调用实例化后的实例 如果需要完成我们预想的功能，至少需要3个类。 ·ConfigReader：用于读取及验证配置文件 ·ReflectionUt
spring源码学习（二）获取Document
晓晨的博客
08-25 951
这篇主要是学习doLoadBeanDefinitions函数中的doLoadDocument方法，用来获取Document对象 函数里只有2行代码。第一行代码把要解析的东西转换为Document对象，第二行通过registerBeanDefinitions行数来注册对象。进入doLoadDocument，发现它调用了DefaultDocumentLoader的loadDocument方法。
深入解析Spring IoC源码：核心机制与实践应用
12-13
本文深入探讨了Spring框架中IoC容器的源码机制，涵盖了容器的初始化、Bean工厂的实例化、Bean定义的读取及Spring Bean的生命周期管理。通过精细的分析，本文揭示了AnnotationConfigApplicationContext的实例化过程，...
深入解析Spring IoC：源码与实践指南
最新发布
12-13
本文深入探讨了Spring IoC容器的加载过程及其源码实现，揭示了Spring中最为根本的概念之一。这包括从AnnotationConfigApplicationContext的实例化开始，到DefaultListableBeanFactory工厂的建立，再到...
Spring源码学习三：BeanFactory解析1
08-04
BeanFactory是用于访问Spring Bean容器的根接口，是一个单纯的Bean工厂，也就是常说的IOC容器的顶层定义，各种IOC容器是在其基础上为了满
java8源码-spring_master:spring源码探究
06-04
容器的基本实现 spring源码剖析，大部分都是基于Springframework5.0 交代： spring最核心的两个类： DefaultListableBeanFactory && XmlBeanDefinitionReader 容器的基础XMLBeanFactory XmlBeanFactory继承自...
java8源码-spring-learning:spring学习
06-04
容器：Spring 负责创建和管理对象（Bean）的生命周期和配置。 MVC：对 web 应用提供了高度可配置性，其他框架的集成也十分方便。 事务管理：提供了用于事务管理的通用抽象层。Spring 的事务支持也可用于容器较少的...
spring源码解析-容器的基本实现
qq_22270363的博客
10-13 426
spring源码解析-容器的基本实现，本人精心整理，包含详细的流程图。
Spring IoC的细节--XmlBeanDefinitionReader.doLoadDocument(InputSource inputSource, Resource resource)
aidaowuqiong的博客
10-09 399
参考博客：https://blog.csdn.net/lyc_liyanchao/article/details/83004510 XmlBeanDefinitionReader： protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStore...
Spring源码——容器的基本实现
等一杯咖啡的博客
07-27 2005
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第二章的部分，依照书中内容以及个人理解对Spring进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework I. 容器基本用法 测试工程 在上一篇文章中，已...
spring(2) spring容器的实现过程
DFL_always的专栏
12-16 452
spring 容器的实现过程编程式Ioc容器 资源位置 ClassPathResource res = new ClassPathResource("beans.xml") 读入器的实现， DefaultListableBeanFactory factory = new DefaultListableBeanFactory() 这个是默认的容器，即读入器将bean存储的map。 XmlBeanDe
Spring容器初始化过程都做了哪些事儿
杨安康的博客
04-01 8018
1.ClassPathXmlApplicationContext为入口构造方法中有个refresh()方法用来初始化Spring refresh运行的大致流程： ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();—-2 invokeBeanFactoryPostProcessor
Spring 容器及对象创建的过程
u014282804的博客
06-13 5323
     Spring容器负责对象的创建过程，配置并且管理他们的创建过程，从创建到被回收。Spring有多种容器的实现，分为两种类型，bean工厂，最简单的容器，提供DI的支持。应用上下文是基于beanFactory构建的，提供企业极的服务。    常用的几种应用上下文： 　 ① AnnotationConfigApplicationContext:从一个或多个基于java的配置类中加载上下文定义...
Spring容器初始化过程
weixin_33937778的博客
06-07 2209
一、Spring 容器高层视图 Spring 启动时读取应用程序提供的Bean配置信息，并在Spring容器中生成一份相应的Bean配置注册表，然后根据这张注册表实例化Bean，装配号Bean之间的依赖关系，为上层应用提供准备就绪的运行环境。 二、内部工作机制 该图描述了Spring容器从加载配置文件到创建出一个完整Bean的作业流程： １、ResourceLoader从存储介质中...
Spring 容器的基本实现
RainSun
05-18 362
自定义标签的解析
《Spring源码深度解析》学习笔记——Spring的整体架构与容器的基本实现
热门推荐
benhuo931115的博客
07-06 12万+
Spring的整体架构Spring框架是一个分层架构，它包含一系列的功能要素，并被分为大约20个模块，如下图所示这些模块被总结为以下几个部分： Core ContainerCore Container(核心容器)包含有Core、Beans、Context和Expression Language模块 Core和Beans模块是框架的基础部分，提供IoC(转控制)和依赖注入特性。这里的基础概念是Bea
spring 容器启动流程源码解析一步一步解释源码
06-02
好的，我会尽力解释 Spring 容器的启动流程源码。 1. 加载配置文件 Spring 容器启动时，首先会读取配置文件，通常是 `applicationContext.xml`。配置文件中定义了需要被 Spring 管理的 bean，以及它们的依赖关系等信息。 2. 创建 BeanDefinition Spring 容器会解析配置文件，创建对应的 BeanDefinition 对象。BeanDefinition 定义了 bean 的基本信息，如 bean 的类名、scope、依赖关系等等。 3. 注册 BeanDefinition 接下来，Spring 容器将创建的 BeanDefinition 注册到 BeanDefinitionRegistry 中。BeanDefinitionRegistry 是一个接口，它定义了注册、查询、删除 BeanDefinition 的方法。 4. 实例化 Bean 接下来，Spring 容器将开始实例化 bean。Spring 容器使用反射创建 bean 的实例，然后根据配置文件中的信息对 bean 进行初始化。 5. 填充属性值 在 bean 实例化之后，Spring 容器会开始填充属性值。Spring 容器会根据配置文件中的信息，自动为 bean 填充属性值。这些属性可以是基本类型、引用类型、集合类型等等。 6. 调用 BeanPostProcessor 在填充完属性值之后，Spring 容器会调用 BeanPostProcessor 的方法。BeanPostProcessor 是一个接口，它定义了在 bean 实例化和初始化过程中的回调方法。通过实现 BeanPostProcessor，我们可以在 bean 实例化和初始化的过程中做一些自定义的操作。 7. 初始化 Bean 在填充完属性值和调用 BeanPostProcessor 之后，Spring 容器会调用 bean 的初始化方法。初始化方法可以是 init-method 指定的方法，也可以是实现了 InitializingBean 接口的 afterPropertiesSet() 方法。 8. 注册销毁方法 当 bean 的生命周期结束时，Spring 容器会调用它的销毁方法。销毁方法可以是 destroy-method 指定的方法，也可以是实现了 DisposableBean 接口的 destroy() 方法。 以上就是 Spring 容器启动流程的大概过程。其中，BeanDefinition、BeanPostProcessor、InitializingBean、DisposableBean 等接口和类都是 Spring 框架中提供的，它们为我们提供了更加灵活的配置和扩展方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Zong_0915

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值