Spring 源码深度解析 – wiki基地

作者： /

Spring源码深度解析：揭秘核心机制与设计哲学

作为Java生态中最具影响力的框架之一，Spring以其强大的功能、灵活的配置和优雅的设计征服了无数开发者。我们每天使用着Spring IoC容器管理Bean，利用AOP实现切面编程，享受着声明式事务的便捷。然而，这些看似神奇的功能背后，隐藏着一套精妙而复杂的机制。深入探索Spring框架的源码，不仅能帮助我们更好地理解其工作原理，解决疑难问题，更能学习到顶级的软件设计思想和实现技巧。

本文将带你踏上一段Spring源码的深度解析之旅，重点聚焦于Spring框架的两个核心基石：IoC（Inversion of Control，控制反转）容器和AOP（Aspect-Oriented Programming，面向切面编程）。我们将剥开层层包装，一探其内部的核心接口、类以及关键的执行流程。

1. 为何要深入Spring源码？

在开始之前，让我们先思考一下，为何要花费时间和精力去阅读和理解一个庞大框架的源码？

  1. 知其所以然，解决问题事半功倍： 当遇到Bean生命周期异常、AOP切面不生效、事务传播行为困惑等问题时，理解底层原理能帮助我们快速定位问题根源，而不是仅仅停留在表面现象。
  2. 提升设计能力： Spring源码中蕴含着大量优秀的设计模式、架构思想和编程技巧。学习这些可以极大地提升我们自身设计和编写高质量代码的能力。
  3. 定制与扩展： 理解源码使我们能够更自信地对Spring进行扩展，例如自定义Bean的创建过程、实现自定义的后置处理器等。
  4. 拥抱变化，适应新技术： Spring框架不断演进，新的功能和模块层出不穷。掌握其核心原理，有助于我们更快地理解和掌握Spring生态中的新技术，如Spring Boot、Spring Cloud等。
  5. 参与社区，贡献代码： 对于有志于参与开源项目的开发者来说，理解源码是贡献力量的基础。

2. Spring框架概览：模块化与核心理念

Spring框架并非一个单一的庞大实体，而是由一系列模块组成的。这种模块化的设计使得开发者可以根据需求选择性地引入所需的模块。其核心模块包括：

  • Core Container (核心容器): 包括 spring-core, spring-beans, spring-context, spring-expression (SpEL) 等模块。这是框架的基础，提供了IoC和依赖注入功能。
  • AOP (面向切面编程): spring-aop 模块，提供了面向切面编程的实现。
  • Data Access/Integration (数据访问/集成): 包括 JDBC, ORM (JPA, Hibernate), OXM, JMS, Transactions 等模块，提供了数据访问和事务管理的支持。
  • Web (Web): 包括 spring-web, spring-webmvc, spring-websocket, spring-portlet 等模块，提供了Web开发相关的功能，如MVC框架。

Spring的核心理念可以概括为：

  • IoC / DI (Dependency Injection): 控制反转/依赖注入，将对象的创建和依赖关系的管理交给容器。
  • AOP: 关注点分离，将横切关注点（如日志、事务）与业务逻辑分离。
  • Abstraction (抽象): 对底层技术（如数据库访问、消息队列）进行抽象，提供统一的编程接口。
  • Convention over Configuration (约定优于配置): 在Spring Boot等新一代框架中体现得尤为明显，通过约定减少配置。

本文的源码深度解析将主要围绕Core Container和AOP展开。

3. IoC容器深度解析：Bean的生老病死

Spring IoC容器是框架的核心。它负责管理Bean的生命周期，包括创建、配置、依赖注入以及销毁。理解IoC容器的工作原理，关键在于理解它是如何加载配置、创建Bean、处理依赖以及如何利用扩展点进行定制的。

3.1 核心接口：BeanFactory 与 ApplicationContext

  • BeanFactory: Spring IoC容器的最底层接口，提供了最基本的容器功能，如根据名称获取Bean。它是一个懒加载的容器，即Bean只有在被需要时才创建。
  • ApplicationContext: BeanFactory 的子接口，提供了更多企业级特性，如国际化支持、事件发布、统一的资源加载方式以及对Web应用的支持。它通常是一个立即加载的容器（但可以通过配置改变），会在启动时创建所有单例Bean。

在实际开发中，我们通常使用 ApplicationContext 的实现类，如 ClassPathXmlApplicationContext, FileSystemXmlApplicationContext, AnnotationConfigApplicationContext, WebApplicationContext 等。

3.2 BeanDefinition：Bean的“蓝图”

在Spring容器内部，每个Bean的定义都不是直接以Java对象形式存在的，而是被抽象成一个 BeanDefinition 对象。BeanDefinition 包含了创建Bean所需的所有信息：

  • Bean的类名 (class name)
  • Bean的作用域 (scope, 如 singleton, prototype)
  • Bean的构造函数参数
  • Bean的属性值
  • 依赖的Bean (通过 ref 引用)
  • 初始化方法 (init-method)
  • 销毁方法 (destroy-method)
  • 是否是抽象的、延迟加载的、主要的等等标记

Spring容器启动时，首先会读取各种配置源（XML, Annotation, Java Config），将这些配置信息解析成 BeanDefinition 对象，并注册到一个 BeanDefinitionRegistry 中，通常是 DefaultListableBeanFactory。

3.3 容器的启动流程：refresh() 方法的秘密

ApplicationContext 启动的核心方法是 refresh()。这是一个模板方法，定义了容器初始化的标准流程。理解 refresh() 的执行步骤，就掌握了Spring容器初始化的脉络：

“`java
// AbstractApplicationContext.java (简化版)
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1. 准备刷新，设置容器状态，记录启动时间，初始化属性源等
prepareRefresh();

    // 2. 获取或创建一个新的 BeanFactory
    // 如果是 AbstractRefreshableApplicationContext 子类，会在这里创建 DefaultListableBeanFactory
    // 并加载 BeanDefinition
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

    // 3. 配置 BeanFactory，例如添加 BeanPostProcessor，设置忽略的接口，注册一些特殊的 Bean
    prepareBeanFactory(beanFactory);

    try {
        // 4. 允许在 BeanFactory 标准初始化后，注册自定义的 BeanFactoryPostProcessor
        // 重要的步骤：处理 <bean id="myProcessor" class="...BeanFactoryPostProcessor"/>
        // BeanFactoryPostProcessor 可以修改 BeanDefinition
        postProcessBeanFactory(beanFactory);

        // 5. 调用 BeanFactoryPostProcessor，它们可以修改 BeanDefinition 或注册新的 BeanDefinition
        // 这是 Spring 扩展机制的关键点之一
        invokeBeanFactoryPostProcessors(beanFactory);

        // 6. 注册 BeanPostProcessor，它们用于拦截 Bean 的创建过程
        // 重要的步骤：处理 <bean id="myProcessor" class="...BeanPostProcessor"/>
        // 注意：此时仅仅是注册 BeanPostProcessor 的定义，它们本身还没被创建
        registerBeanPostProcessors(beanFactory);

        // 7. 初始化消息源 (用于国际化)
        initMessageSource();

        // 8. 初始化应用事件广播器
        initApplicationEventMulticaster();

        // 9. 留给子类实现，用于在特定容器刷新时执行额外逻辑
        onRefresh();

        // 10. 注册监听器，包括从 Bean 定义中找到的监听器
        registerListeners();

        // 11. 初始化所有非延迟加载的单例 Bean (Bean 的真正创建和依赖注入发生在这里！)
        // 这是 IoC 容器最重要的步骤之一
        finishBeanFactoryInitialization(beanFactory);

        // 12. 完成刷新过程，发布 ContextRefreshedEvent 事件
        finishRefresh();
    }
    catch (BeansException ex) {
        // 如果刷新过程中出现异常，销毁已创建的单例 Bean，并取消刷新
        destroyBeans();
        cancelRefresh(ex);
        throw ex;
    }
    finally {
        // 重置缓存，清理资源等
        resetCommonCaches();
    }
}

}
“`

理解 refresh() 方法的每个步骤，特别是 加载BeanDefinition (步骤2)，调用 BeanFactoryPostProcessor (步骤5)，注册 BeanPostProcessor (步骤6)，以及 实例化单例Bean (步骤11)，对于掌握Spring容器至关重要。

3.4 Bean的生命周期：从创建到销毁

Bean的生命周期是IoC容器管理的另一个核心。一个Bean从被定义到最终销毁，会经历多个阶段，并且Spring提供了丰富的扩展点供开发者介入：

  1. Resource Loading: 容器加载配置文件，如 XML, Properties, Java Config 等。
  2. BeanDefinition Loading: 将配置解析为 BeanDefinition 对象，注册到 BeanDefinitionRegistry。
  3. BeanFactoryPostProcessor Processing: BeanFactoryPostProcessor 在此时执行，可以修改 BeanDefinition，比如 PropertyPlaceholderConfigurer (Spring 3.1 前) / PropertySourcesPlaceholderConfigurer 用于解析属性占位符。
  4. BeanPostProcessor Registration: 注册 BeanPostProcessor 的定义。
  5. Bean Instantiation: 根据 BeanDefinition 创建Bean的实例。Spring使用反射或者CGLIB来完成。
  6. Populate Properties: 依赖注入阶段。根据 BeanDefinition 中的属性信息，为Bean实例注入依赖。Spring使用 BeanWrapper 接口来方便地设置Bean的属性。
  7. Aware Interface Processing: 如果Bean实现了特定的 Aware 接口（如 BeanNameAware, BeanFactoryAware, ApplicationContextAware），Spring会调用相应的方法，将容器或Bean自身的信息注入。
  8. BeanPostProcessor#postProcessBeforeInitialization: 调用所有已注册的 BeanPostProcessor 的 postProcessBeforeInitialization() 方法。这里是Spring AOP自动创建代理的入口之一 (AbstractAutoProxyCreator)。
  9. InitializingBean#afterPropertiesSet 或 Custom Init Method: 调用Bean自身定义的初始化逻辑。如果Bean实现了 InitializingBean 接口，会调用 afterPropertiesSet() 方法；如果 BeanDefinition 指定了 init-method，会调用该方法。注意执行顺序：先 InitializingBean#afterPropertiesSet，后 init-method。
  10. BeanPostProcessor#postProcessAfterInitialization: 调用所有已注册的 BeanPostProcessor 的 postProcessAfterInitialization() 方法。Spring AOP自动创建代理的入口之二是这里。
  11. Bean is Ready: Bean对象已完全创建、配置并初始化完成，可以使用了。对于单例Bean，它会存放在容器的单例缓存中 (singletonObjects map)。
  12. DisposableBean#destroy 或 Custom Destroy Method: 容器关闭时，对实现 DisposableBean 接口或定义了 destroy-method 的Bean，会调用相应的销毁方法。

关键扩展点： BeanFactoryPostProcessor (影响 Bean 定义) 和 BeanPostProcessor (影响 Bean 实例)。理解它们在生命周期中的位置和作用，是掌握Spring定制能力的关键。

3.5 依赖注入的实现细节

Spring如何实现依赖注入？主要有三种方式：构造器注入、Setter注入和字段注入。

  • Constructor Injection: 容器在创建Bean实例时，通过反射调用匹配的构造函数，并将依赖作为参数传入。这是Spring推荐的方式，因为它强制依赖关系，使得对象创建后就是完整的可用状态。
  • Setter Injection: 容器创建Bean实例后，通过反射调用Setter方法将依赖注入。
  • Field Injection: （主要通过注解实现，如 @Autowired）容器创建Bean实例后，通过反射直接设置字段的值（可能绕过Setter）。

无论哪种方式，Spring都需要先获取依赖的Bean。在 AbstractAutowireCapableBeanFactory 的 populateBean() 和 doCreateBean() 等方法中可以看到具体的注入逻辑。当需要注入一个依赖Bean (A依赖B)时，容器会先尝试从缓存中获取Bean B。如果B尚未创建，则会递归地走一遍Bean B的创建流程，直到B被创建并注入到A中。这种递归创建过程可能导致循环依赖的问题（通常Spring只能解决单例Bean的setter注入或字段注入的循环依赖）。

4. AOP深度解析：解耦横切关注点

Spring AOP是基于代理（Proxy）实现的。它允许开发者定义切面（Aspect），将日志、事务、安全等横切关注点从核心业务逻辑中分离出来，使得代码更加模块化和易于维护。

4.1 AOP核心概念回顾

  • Aspect (切面): 横切关注点的模块化单元，可以包含多个通知和切点。例如，事务管理就是一个切面。
  • Join point (连接点): 程序执行过程中的某个特定点，如方法的调用、异常的抛出等。Spring AOP只支持方法执行连接点。
  • Advice (通知): 切面在特定连接点执行的动作。例如，在方法调用前记录日志（前置通知）、方法调用后提交事务（后置通知）等。
    • @Before (前置通知)
    • @After (后置通知)
    • @AfterReturning (返回通知)
    • @AfterThrowing (异常通知)
    • @Around (环绕通知)
  • Pointcut (切点): 定义了通知将作用于哪些连接点。通过表达式匹配特定的方法。
  • Advisor (通知器): 将通知（Advice）和切点（Pointcut）组合在一起的对象。Spring AOP内部使用Advisor来表示一个完整的切面配置。
  • Target Object (目标对象): 被一个或多个切面所通知的对象。
  • Proxy (代理): Spring AOP创建的对象，它封装了目标对象，并由它来管理切面逻辑的执行。
  • Weaving (织入): 将切面应用到目标对象并创建代理对象的过程。Spring AOP是在运行时（默认在Bean初始化时）进行织入的。

4.2 Spring AOP的实现机制：动态代理

Spring AOP默认使用动态代理来实现。主要有两种方式：

  1. JDK Dynamic Proxy: 如果目标对象实现了接口，Spring会使用JDK动态代理。它要求目标对象实现一个或多个接口，代理对象和目标对象实现相同的接口。代理对象的创建由 java.lang.reflect.Proxy 类完成。
  2. CGLIB Proxy: 如果目标对象没有实现接口，Spring会使用CGLIB库生成一个目标对象的子类作为代理。CGLIB通过修改字节码生成代理类，因此不需要目标对象实现接口。

选择哪种代理方式取决于目标对象：有接口用JDK代理，无接口用CGLIB代理。Spring也可以强制使用CGLIB代理（例如通过 @EnableAspectJAutoProxy(proxyTargetClass = true)）。

4.3 源码中的 AOP 关键类

AOP的实现与IoC容器紧密集成。前面在Bean生命周期中提到，BeanPostProcessor 是一个关键的扩展点。Spring AOP的自动代理创建者 (AbstractAutoProxyCreator 的子类，如 AnnotationAwareAspectJAutoProxyCreator) 就是一个 BeanPostProcessor。

让我们看看自动代理创建的核心流程：

  1. 注册 AutoProxyCreator: 在 refresh() 方法的步骤6 (registerBeanPostProcessors) 中，如果你的配置启用了AOP（例如使用了 <aop:aspectj-autoproxy/> 或 @EnableAspectJAutoProxy），Spring会注册一个 AutoProxyCreator 的 BeanDefinition。
  2. 创建 AutoProxyCreator 实例: 在 finishBeanFactoryInitialization() (步骤11) 中，实例化其他Bean之前，会先实例化所有的 BeanPostProcessor。此时 AutoProxyCreator 的实例会被创建。
  3. AutoProxyCreator 工作: AutoProxyCreator 作为 BeanPostProcessor，会在 Bean 的生命周期中介入：
    • postProcessBeforeInstantiation: 在 Bean 实例化前，尝试创建代理。如果匹配到切点，并且早期创建代理有必要（例如为了解决循环依赖），可能会在这里创建代理并返回，跳过标准的实例化和依赖注入流程。
    • postProcessAfterInitialization: 这是创建代理的主要入口。在 Bean 完成实例化、属性注入、初始化回调之后， AutoProxyCreator 的 postProcessAfterInitialization() 方法会被调用。
      • 在该方法中，AutoProxyCreator 会检查当前 Bean 是否需要被代理（通过查找适用于该 Bean 的 Advisor）。
      • 如果需要代理，它会收集所有适用的 Advisor (包含了 Pointcut 和 Advice)。
      • 然后，它会使用这些 Advisor 和目标 Bean，通过 ProxyFactory (或其子类) 创建代理对象。
      • ProxyFactory 内部根据目标对象是否有接口以及配置决定使用 JDK Dynamic Proxy 或 CGLIB Proxy。
      • postProcessAfterInitialization() 方法最终返回的是这个代理对象，而不是原始的目标 Bean。

因此，当你在容器中通过 applicationContext.getBean("myService") 获取一个被AOP通知的Bean时，你拿到的实际上是它的代理对象。所有方法调用首先会经过代理，代理再根据配置决定是否执行Advice，最后才调用目标对象的实际方法。

核心类/接口梳理:

  • Advisor: 切点和通知的组合。
  • Pointcut: 定义连接点的接口。常见的实现有 AspectJExpressionPointcut。
  • Advice: 通知接口，有各种子接口对应不同的通知类型（如 MethodBeforeAdvice, AfterReturningAdvice, MethodInterceptor 等）。
  • AopProxy: 创建代理的接口，有两个主要实现：JdkDynamicAopProxy 和 CglibAopProxy。
  • ProxyFactory: 创建 AopProxy 的工厂类。
  • TargetSource: 提供目标对象。
  • AutoProxyCreator (如 AbstractAutoProxyCreator, AnnotationAwareAspectJAutoProxyCreator): BeanPostProcessor 的实现，负责在 Bean 初始化后自动创建代理。

通过阅读这些类的源码，你可以深入了解Spring如何解析AspectJ注解 (@Aspect, @Before, @After 等)，如何匹配切点表达式，如何在代理中编织通知逻辑，以及如何处理通知的执行顺序。

4.4 事务管理与AOP

Spring的声明式事务管理是AOP的一个典型应用。通过 @Transactional 注解，开发者可以轻松地将事务应用到方法上，而无需编写繁琐的事务管理代码。

其实现原理是：

  1. @Transactional 注解被解析，Spring将其转换为 Advisor。
  2. AutoProxyCreator 发现带有 @Transactional 注解的Bean，为其创建代理。
  3. 代理对象拦截带有 @Transactional 的方法调用。
  4. 在方法执行前，代理使用配置的事务管理器 (PlatformTransactionManager) 开启事务。
  5. 执行目标方法。
  6. 根据方法执行结果（正常返回或抛出异常），代理调用事务管理器提交或回滚事务。

相关的核心类包括 TransactionInterceptor (实现了 MethodInterceptor 通知接口，负责事务的实际逻辑) 和 BeanFactoryTransactionAttributeSourceAdvisor (一个Advisor，包含了解析 @Transactional 注解的 TransactionAttributeSource 和 TransactionInterceptor)。这些都在 spring-tx 模块中。

5. 其他重要机制概述

除了IoC和AOP，Spring源码中还有许多值得探索的部分：

  • Resource加载 (spring-core): Resource 接口及其实现 (如 ClassPathResource, FileSystemResource, UrlResource)，以及 ResourceLoader 接口，提供了统一的资源访问方式。
  • 事件机制 (spring-context): ApplicationEvent, ApplicationListener, ApplicationEventPublisher 接口，实现了观察者模式，允许Bean之间进行异步的消息通信。
  • 类型转换与数据绑定 (spring-beans, spring-core): TypeConverter, PropertyEditor, ConversionService, DataBinder 等，用于将属性值从一种类型转换为另一种类型，以及将请求参数绑定到Java对象。
  • Spring Expression Language (SpEL, spring-expression): 强大的表达式语言，用于在运行时查询和操作对象图，经常用于注解、XML配置和模板引擎中。
  • 各种 Reader 和 Parser: 用于解析不同配置格式的类，如 XmlBeanDefinitionReader, PropertiesBeanDefinitionReader, AnnotatedBeanDefinitionReader, XML Namespace handler 等。

6. 从源码中学习设计思想

阅读Spring源码，不仅是学习其实现细节，更是学习其背后蕴含的优秀设计思想：

  • 接口至上： Spring大量使用接口进行抽象，使得代码具有良好的扩展性和可替换性。
  • 模板方法模式： 如 AbstractApplicationContext.refresh() 方法，定义了核心流程骨架，允许子类实现特定步骤。
  • 策略模式： 在多种实现方式并存的地方使用，如代理创建（JDK/CGLIB）、资源加载方式、事务同步管理器等。
  • 工厂模式： BeanFactory 本身就是一个巨大的工厂。
  • 观察者模式： 事件发布/监听机制。
  • 后置处理器 (PostProcessor): 强大的扩展机制，允许在核心流程的各个阶段插入自定义逻辑。
  • 组合优于继承： 通过组合不同的组件（如 Advisor 包含 Pointcut 和 Advice）构建功能。

7. 如何开始你的源码探索之旅？

  1. 选择版本： 从一个相对稳定、你熟悉的版本开始（例如 Spring 5.x）。
  2. 搭建环境： 将Spring源码导入你的IDE (如 IntelliJ IDEA, Eclipse)。确保能够编译通过，并且可以运行测试用例。
  3. 从入口开始： 找到一个你熟悉的应用场景的入口，例如启动一个简单的 AnnotationConfigApplicationContext，或者一个Web应用的 ContextLoaderListener。
  4. 使用调试器： 这是最有效的手段！在 refresh() 方法、getBean() 方法、AbstractAutowireCapableBeanFactory.doCreateBean()、AbstractAutoProxyCreator.postProcessAfterInitialization() 等关键方法上设置断点，单步调试，观察调用栈和变量值。
  5. 聚焦核心： 不要试图理解所有代码。先聚焦于IoC容器的启动和Bean创建、依赖注入、AOP代理创建等核心流程。
  6. 阅读关键接口和类的文档： Spring源码中的Javadoc非常详细，是理解代码的重要辅助。
  7. 结合测试用例： Spring源码中包含了大量的单元测试和集成测试，这些测试用例展示了代码的使用方式和预期行为，是理解代码功能的好帮手。
  8. 参考社区资源： 阅读优秀的源码分析文章、博客、书籍，可以帮助你梳理思路，少走弯路。

8. 总结

Spring源码是一座宝藏，深入挖掘它，不仅能让你成为一名更优秀的Spring开发者，更能学习到软件工程领域的顶级设计思想和实现技巧。本文从IoC容器的启动、Bean的生命周期，到AOP的代理机制和事务管理，为你揭示了Spring核心机制的冰山一角。

这是一段充满挑战但也回报丰厚的旅程。不需要一次性理解所有细节，可以从一个点切入，循序渐进。愿你在Spring源码的探索中，收获满满！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部