【Spring 源码深度解析】容器基本实现

最新推荐文章于 2025-04-10 15:56:50 发布

movYou521

最新推荐文章于 2025-04-10 15:56:50 发布

阅读量974

点赞数

分类专栏： Java 架构 Spring 全家桶文章标签： spring 容器 java

本文链接：https://blog.youkuaiyun.com/green1997/article/details/120356987

版权

本文详细介绍了Spring框架的分层架构，包括CoreContainer、AOP、Instrument、Messaging、DataAccess/Integration和Web层。CoreContainer涉及Spring的核心工具类、BeanFactory和ApplicationContext。AOP模块提供面向切面编程，Instrument支持类植入。Messaging模块支持消息传递。DataAccess/Integration层包含JDBC、ORM、OXM、JMS和Transaction模块，用于数据访问和集成。Web层由Web、Web-Servlet、Web-WebSocket和Portlet模块组成，提供Web应用的支持。此外，文章还深入解析了BeanFactory的初始化过程，包括配置文件的封装、Bean的加载、EntityResolver的获取、XML验证模式的读取以及Document的解析和BeanDefinition的注册。

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

1 Spring 的整体架构

Spring 框架是一个分层架构，主要模块如下
在这里插入图片描述

1.1 Core Container

核心容器层包含有 spring-core，spring-beans，spring-context，Spring-context-support 和 spring-expression 模块。Core 和 Beans 模块是框架的基础部分，提供IoC9（反转控制）和 DI（依赖注入）特性。

（1）spring-core 模决主要包含 Spring 框架基本的核心工具类，Spring 的其他组件都要用到这个包里的类，Core 模块是其他组件的基本核心。

（2）spring-beans 模块提供了BeanFactory，是工厂模式的一个经典实现，是所有应用都要用到的，它包含访问配置文件、创建和管理 bean 以及进行 IoC 和 DI 操作相关的所有类。

（3）spring-context 模块构建于 Core Beans 模块基础之上，继承了 Beans 的特性，为 Spring 核心提供了大量扩展，添加了对国际化（例如资源绑定）、事件传播、资源加载和对 Context 透明创建的支持。Context 模块同时也支持 J2EE 的一些特性，例如 EJB，JMX 和基础远程处理。ApplicationContext 接口是 Context 模块的关键。

（4）Spring-context-support 模块支持整合第三方库到Spring应用程序上下文，特别是用于高速缓存（EhCache、JCache）和任务调度（CommonJ、Quartz）的支持。

（5）spring-context-indexer 模块作用是在编译时扫描 @Indexed 注解，确定 bean，生成索引文件。该模块是 Spring 5.x 新增的。

（6）spring-expression 模块提供了强大的表达式语言，用于在运行时查询和操纵对象。它是 JSP 2.1 规范中定义的 unifed expression languag 的扩展。该语言支持设置／获取属性的值，属性的分配，方法的调用，访问数组上下文、容器和索引器、逻辑和算术运算符、命名变量以及从 Spring 的 IoC 容器中根据名称检索对象。它也支持 list 投影、选择和一般的 list 聚合。

1.2 Aop 和 Instrument

（1）spring-aop 模块提供了一个符合AOP要求的面向切面的编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以便干净地解耦。

（2）spring-aspects 模块提供了与AspectJ的集成功能，AspectJ是一个功能强大且成熟的AOP框架。

（3）spring-instrument 提供了类植入（Instrumentation）支持和类加载器的实现，可以在特定的应用服务器中使用。

1.3 Messaging

Spring4.0以后新增了消息（spring-messaging）模块，该模块提供了对消息传递体系结构和协议的支持。

1.4 Data Access/Integration

数据访问/集成层包含 JDBC，ORM，OXM，JMS 和 Transaction 模块。

（1）spring-jdbc 模块提供一个 JDBC 抽象层，消除冗长的 JDBC 编码和数据库厂商特有的错误代码解析。该模块包含 Spring 对 JDBC 数据访问进行封装的所有类。

（2）spring-orm 模块为对象-关系映射 API，为 JPA，JDO，Hibernate，iBatis 等提供了一个交互层。利用 ORM 封装包，可以混合使用所有 Spring 提供的特性进行 O/R 映射。Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JPA，Hibernate，iBatis 所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

（3）spring-oxm 模块提供了一个对 Object/XML 映射实现的抽象层，Object/XML 映射实现包括 JAXB，Castor，XMLBeans，JiBX 和 XStrearn。

（4）spring-jms 模块主要包含了一些制造和消费消息的特性。Spring4.1以后，提供了与 spring-messaging 模块的集成。

（5）spring-tx 事务模块支持编程和声明式事务管理，这些事务类必须实现特定的接口，并对所有的 POJO 都适用。

1.4 Web

Web 层由 spring-web、spring-webmvc、spring-websocket 和 Portlet 模块组成。

（1）spring-web 模块提供了基础的面向 Web 的集成特性。例如，多文件上传、使用 servlet listeners 初始化 IoC 容器以及一个面向 Web 的应用上下文。它还包含 Spring 远程支持中 Web 的相关部分。

（2）spring-webmv 模块也称为 Web-Servlet 模块，包含用于 web 应用程序的 Spring MVC和 REST Web Services 实现。Spring MVC 框架提供了领域模型代码和 Web 表单之间的清晰分离，并与 Spring Framework 的所有其他功能集成。

（3）spring-websocket 模块是 Spring4.0 以后新增的模块，它提供了 WebSocket 和 SocketJS 的实现。

（4）spring-webmvc-portlet 即 Web-Portlet 模块类似于 Servlet 模块的功能，提供了 Portlet 环境下的 MVC 实现。

（5）spring-webflux 模块是 spring 5.0 中引入的新的反应式Web框架。与Spring MVC不同，它不需要 Servlet API，完全异步和非阻塞，并通过 Reactor 项目实现 Reactive Streams 规范。并且可以在诸如 Netty，Undertow 和 Servlet 3.1+ 容器的服务器上运行。

2 容器的基本实现

2.1 容器的基本语法

bean 是 Spring 中最核心的东西，Spring是一个水桶的话，bean就是水桶的水。

首选看一下 bean 的定义

//bean 的定义
public class TestBean {
   
	private String testStr = "testStr";

	public String getTestStr() {
   
		return testStr;
	}

	public void setTestStr(String testStr) {
   
		this.testStr = testStr;
	}
}

Spring 目的是让我们的 bean 能成为纯粹的 POJO，接下来看看配置文件：

<!--配置文件-->
<?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="testBean" class="org.springframework.test.base.TestBean"/>
    
</beans>

最后编写测试代码

//测试类
public class Main {
   

    public static void main(String[] args) {
   
        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("beanFactoryTest.xml"));
        TestBean testBean = beanFactory.getBean(TestBean.class);
        System.out.println(testBean.getTestStr());
    }
}

2.2 功能分析

上述代码完成的功能：

读取配置文件 beans2.xml。
根据 beans2.xml 中的配置找到对应的类的配置，并实例化。
调用实例化后的实例。

2.3 Spring 的结构组成

首先梳理 Spring 的框架结构，从全局的角度了解 Spring 结构组成。

2.3.1 beans 包的层次结构

beans 包中的各个源码包的功能如下。

src/main/java 用于展现 Spring 的主要逻辑
src/main/resources 用于存放系统的配置文件
src/test/iava 用于对主要逻辑进行单元测试
src/test/resources 用于存放测试用的配直文件

2.3.2 核心类介绍

在正式开始源码分析之前，必要了解 Spring 中核心的两个类。

1）DefaultListableBeanFactory
XmlBeanFactory 继承向 DefaultListableBeanFactory，而 DefaultListableBeanFactmy 是整个 bean 加载的核心部分，是 Spring 注册及加载 bean 的默认实现，而对于 XmlBeanFactory 与 DefaultListableBeanFactory 不同的地方其实是在 XmlBeanFactory 中使用了自定义的 XML 读取器 XmlBeanDefinitionReader，实现了个性化的 BeanDefinitionReader 读取， DefaultListableBeanFactory 继承了 AbstractAutowireCapableBeanFactory 并实现了 ConfigurableListableBeanFactory 及 BeanDefinitionRegistry 接口。相关类图如下。
在这里插入图片描述
（1）AliasRegistry：定义对 alias 的简单增删改查。

（2）SimpleAliasRegistry：主要使用 map 作为 alias 的缓存，对接口 AliasRegistry 的实现。
在这里插入图片描述
（3）SingletonBeanRegistry：定义对单例的注册及获取。

（4）BeanFactory：定义获取bean及bean的各种属性

（5）DefaultSingletonBeanRegistry：继承SimpleAliasRegistry对接口SingletonBeanRegistry的实现

（6）HierachicalBeanFactory：继承 BeanFactory，在其基础上，增加了对 parentFactory 的支持。
在这里插入图片描述
（7）BeanDefinitionRegistry：定义对 BeanDefinition 的各种增删改操作。

（8）FactoryBeanRegistrySupport：在 DefaultSingletonBeanRegistry 的基础上增加对 FactoryBean 的特殊处理。

（9）ConfigurableBeanFactory：提供配置Factory的各种方法
在这里插入图片描述
（10）ListableBeanFactory：根据各种条件定义获取bean的配置清单

（11）AbstractBeanFactory：综合 FactoryBeanRegistrySupport 和 ConfigurableBeanFactory 的功能

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
   
}

（12）AutowireCapableBeanFactory：提供创建bean，自动注入，初始化以及应用bean的后处理器

public interface AutowireCapableBeanFactory extends BeanFactory {
   
}

（13）AbstractAutowireCapableBeanFactory：综合 AbstractBeanFactory 并对接口 AutowireCapableBeanFactory 的实现

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
   
}

（14）ConfigurableListableBeanFactory：BeanFactory配置清单，指定忽略类型及接口

public interface ConfigurableListableBeanFactory
		extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
   
}

（15）DefaultListableBeanFactory：综合功能，主要是对bean注册后的处理

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
   

}

（16）XmlBeanFactory 对 DefaultListableBeanFactory 进行了扩展，对于注册及获取bean都是父类实现，主要扩展了从XML文档中读取BeanDefinition，通过XmlBeanDefinitionReader类。

public class XmlBeanFactory extends DefaultListableBeanFactory {
   

	/**
	 * 使用该类从xml中读取BeanDefinition，
	 * 对于获取以及注册都是继承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);
		//加载 beanDefinitions
		this.reader.loadBeanDefinitions(resource);
	}
}

2）XmlBeanDefinitionReader
XML 置文件的读取是 Spring 重要的功能，Spring 的大部分功能都是以配置作为切入点。因此我们可以从 XmlBeanDefinitionReader 中梳理下资源文件读取、解析及注册的大致脉络。下面是 XmlBeanDefinitionReader 的类图。
在这里插入图片描述
各个类的主要作用：
（1）ResourceLoader：定义资源加载器，主要用于根据给定的资源文件地址返回对应的 Resource。
（2）BeanDefinitionReader：主要定义资源文件读取并转化 BeanDefinition 的各个功能。
（3）EnvironmentCapable：定义获取 Environment 方法。
（4）DocumentLoader：定义资源文件加载到转换为 Document 的功能。
（5）AbstractBeanDefinitionReader：实现 EnvironmentCapable，BeanDefinitionReader 的功能。
（6）BeanDefinitionDocumentReader：定义读取 Document 并注册 BeanDefinition 功能。
（7）BeanDefinitionParserDelegate：定义解析 Element 的方法。

读取 XML 配置文件的主要流程：
（1）通过继承 AbstractBeanDefinitionReader 的方法，来使用 ResourceLoader 将资源文件路径转换为 Resource 文件。
（2）通过 DocumentLoader 对 Resource 文件进行转换，将 Resource 文件转换为 Document 文件。
（3）通过实现接口 BeanDefinitionDocumentReader 的 DefaultBeanDefinitionDocumentReader 类对 Document 进行解析，并使用 BeanDefinitionParserDelegate 对 Element 进行解析。

2.4 容器的基础 XmlBeanFactory

下面深入分析一以下功能的代码实现：

BeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("beanFactoryTest.xml"));

通过下面 XmlBeanFactory 初始化时序图看上面代码的执行逻辑。在这里插入图片描述
首先调用 ClassPathResource 的构造函数来构造 Resource 资源文件的实例对象，，这样后续的资源处理就可以用 Resource 提供的各种服务来操作了，当我们有了 Resource 后就可以进行 XmlBeanFactory 的初始化了。所以首先来看 Resource 资源是如何封装的。

2.4.1 配置文件的封装

Spring 对其内部使用到的资源进行了封装: Resource 接口封装底层资源。

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

/**
 * 该接口用来封装底层资源，
 * InputStreamSource：封装任何能返回InputStream的类，File，ClassPath下的ByteArray等
 * Resource：抽象所有Spring内部使用到的底层资源，File，URL，Classpath等
 */
public interface Resource extends InputStreamSource {
   

	/**
	 * 是否存在
	 */
	boolean exists();

	/**
	 * 是否可读
	 */
	default boolean isReadable() {
   
		return exists();
	}

	/**
	 * 是否处于打开状态
	 */
	default boolean isOpen() {
   
		return false;
	}

	/**
	 * Determine whether this resource represents a file in a file system.
	 */
	default boolean isFile() {
   
		return false;
	}

	/**
	 * Return a URL handle for this resource.
	 */
	URL getURL() throws IOException;

	/**
	 * Return a URI handle for this resource.
	 */
	URI getURI() throws IOException;

	/**
	 * Return a File handle for this resource.
	 */
	File getFile() throws IOException;

	/**
	 * Return a {@link ReadableByteChannel}.
	 */
	default ReadableByteChannel readableChannel() throws IOException {
   
		return Channels.newChannel(getInputStream());
	}

	/**
	 * Determine the content length for this resource.
	 */
	long contentLength() throws IOException;

	/**
	 * Determine the last-modified timestamp for this resource.
	 * 最后一次修改时间
	 */
	long lastModified() throws IOException;

	/**
	 * 基于当前资源创建一个相对资源
	 */
	Resource createRelative(String relativePath) throws IOException;

	/**
	 * Determine a filename for this resource, i.e. typically the last
	 * part of the path: for example, "myfile.txt".
	 */
	@Nullable
	String getFilename();

	/**
	 * Return a description for this resource,
	 * to be used for error output when working with the resource.
	 */
	String getDescription();
}

InputStreamSource 任何能返回 InputStream 的类，比如 File，Classpath 下的资源和 Byte Array等。它只有一个方法定义 getlnputStream()，该方法返回一个新的 InputStream 对象。

Resource 接口抽象了所有 Spring 内部使用到的底层资源： File，URL，Classpath 等。对不同来源的资源文件都有相应的 Resource 实现：

文件资源：FileSystemResourceClasspath。
Classpath 资源：ClassPathResource。
URL 资源：UrlResource。
InputStream 资源：InputStreamResource。
Byte 数组：ByteArrayResource。

相关类图如下，包含部分。
在这里插入图片描述
有了 Resource 接口便可以对所有资源文件进行统一处理。其实现是非常简单的，以 getlnputStream() 为例，ClassPathResource 中的实现方式便是通过 class 或者 classLoader 提供的底层方法实现。对于 FileSystemResource 更简单，直接使用 FileInputStream 对文件进行是实例化。

// ClassPathResource.java
public class ClassPathResource extends AbstractFileResolvingResource {
   
	@Override
	public InputStream getInputStream() throws IOException {
   
		InputStream is;
		if (this.clazz != null) {
   
			is = this.clazz.getResourceAsStream(this.path);
		}
		else if (this.classLoader != null) {
   
			is = this.classLoader.getResourceAsStream(this.path);
		}
		else {
   
			is = ClassLoader.getSystemResourceAsStream(this.path);
		}
		if (is == null) {
   
			throw new FileNotFoundException(getDescription() + " cannot be opened because it does not exist");
		}

最低0.47元/天解锁文章