夜雨聆风学习资料网

ARTICLE · 1392630

读懂 Spring 源码,从"能编译"开始:Spring 7.0.8 环境搭建 + 阅读方法全攻略

读懂 Spring 源码,从"能编译"开始:Spring 7.0.8 环境搭建 + 阅读方法全攻略

版本基线:Spring Framework 7.0.8(Spring Boot 4.x 底层框架)环境基线:JDK 17 起步(推荐 25)· IntelliJ IDEA · Gradle Wrapper(源码自带,无需安装)

简历上写"熟悉 Spring 源码"的人很多,但 80% 止步于"下载了、没编译过、放弃了"。这篇以 Spring Framework 7.0.8 为基线,把环境搭建、预编译踩坑、断点调试到阅读方法论一次讲透,适合想系统读源码却总在第一步翻车的你。


一、面试现场:面试官真正想听什么

先还原一段真实面试。

面试官:你简历上写"深入研究过 Spring 源码",那我问个基础的——你本地把 spring-framework 跑起来了吗?用的什么 JDK、什么构建工具?

多数人的回答(听完就忘):

"呃……GitHub 上下来,IDEA 打开,然后……好像报了挺多错,后来就只看博客了。"

你可以这么答(有方法、有抓手):

"我锁的是 Spring Framework 7.0.8,JDK 17 起步、本机用 25,构建直接用源码自带的 Gradle Wrapper,不自己装 Gradle,避免版本打架。导入前先预编译 spring-oxm 和 spring-core,导入时排除 spring-aspects。跑通后我在 AbstractApplicationContext#refresh() 上打断点,顺着 12 步主干跟一遍 Bean 的生命周期。"

差别在哪?不在于你背了多少源码,而在于你能不能把环境跑起来,并且知道从哪一行开始看。

面试官真正在考察的是三件事:

  • 版本基线意识:知道 JDK 17/25、Jakarta EE 11、Gradle 9 这套 7.0 时代的组合
  • 工程排错能力:知道 spring-core 为什么飘红、spring-aspects 为什么必须排除
  • 可复现的阅读方法论:不是"我看完了",而是"我知道怎么查"

这篇准备篇,就把第一步一次性讲透,让你今天搭好,明天就能下断点。

先看整体路线,心里有底:


二、先对齐版本基线:版本错了,后面全是玄学

读源码第一件事不是打开 IDEA,而是先把版本对齐。这是 90% 初学者踩的第一个坑——网上大量教程还停留在 5.x(JDK 8/11)时代,你拿着旧教程去编译 7.0.8,第一步就会怀疑人生。

2.1 版本速查表

组件
要求
说明
Spring Framework
7.0.8
7.0 于 2025 年 11 月 GA,是 Spring Boot 4.0.x / 4.1.x 的地基
JDK
最低 17,推荐 25
17/21/25 是完整测试的 LTS;17 是字节码基线,25 是官方推荐的生产与构建版本
Jakarta EE
11
(Servlet 6.1 / JPA 3.2 / Bean Validation 3.1)
javax.*
 彻底移除,全部换成 jakarta.*,Tomcat 11 / Jetty 12.1
Gradle
用源码自带 Wrapper,锁定 9.5.1
以你本地 gradle-wrapper.properties 为准,不要自己装
IDEA
2024.1+ 起步,推荐 2025.3+
新版原生支持 JSpecify 空安全注解,索引体验更好
Kotlin / JUnit
Kotlin 2.2 · JUnit 6.0
顺手知道就行
内存 / 磁盘
建议 8G+ 内存、10G+ 磁盘
全量编译 + IDEA 索引是内存大户

这里有个关键认知,面试很加分:

Spring 7 没有强制 JDK 25。 它是"17 编译基线 + 25 推荐运行时"——团队可以分两步走:先升框架,再升 JDK。一句话记:跑用 25,读按 17。

两个提醒:

  • 别用 JDK 8/11,连编译都过不去(报错 Unsupported class file major version);
  • 尽量别用 EA 早期访问版,反射/字节码 API 可能变动,会导致 CGLIB 或 AOT 行为异常。

2.2 7.0.8 里值得"提前知道"的新东西

既然锁定 7.0.8,这些变化会直接影响你的阅读体验,后面读源码会反复遇到:

新能力 / 变化
位置
为什么值得关注
程序化 Bean 注册BeanRegistrar
 / BeanRegistry
纯 Java 的 if/for 条件批量注册,比 BeanDefinitionRegistryPostProcessor 干净十倍
核心韧性能力org.springframework.core.retry
、@Retryable、@ConcurrencyLimit
重试/限流从"外挂库"变成一等公民,不再需要 Spring Retry
API 版本治理@ApiVersion
框架级版本路由,不用自己写拦截器
声明式 HTTP 客户端@HttpExchange
 + 自动注册
Feign 的官方替代
JmsClient / RestTestClientorg.springframework.jms.JmsClient
 等
对标 JdbcClient / RestClient 的流式 API
JSpecify 空安全
取代 JSR 305 和 org.springframework.lang 注解
编译期用 NullAway 校验 @Nullable 一致性
移除 spring-jcl
改用 Commons Logging 1.3.0
老文章里的 jcl 操作可直接跳过
SpEL 操作数上限 10,000
可调 spring.expression.maxOperations
读 SpEL 源码时会遇到这个判断
JDK 25 新特性影子
虚拟线程、紧凑对象头等
配合 Multi-Release Jar 落地

还有一个阅读时会真实遇到的坑,先埋个伏笔:

技术亮点 · MRJAR 多源集:Java 24+ 的字节码读取改用 ClassFileMetadataReader(基于 JEP 484 Class-File API,替代了裁剪版 ASM)。但 spring-core 里 src/main/java、java21、java24 多份源集并存(Multi-Release Jar),IDEA 跳转时可能带你跳到非运行时生效的那份代码,对不上号时记得检查自己在看哪个源集。


三、环境搭建实战:六步走,一步别省

3.1 装 JDK:17 是底线,25 是甜点

java -version
# 期望看到:openjdk version "17.x" 或 "25.x"

版本不符就设置 JAVA_HOME:

# macOS / Linux
export JAVA_HOME=/path/to/jdk-25
export PATH=$JAVA_HOME/bin:$PATH
# Windows:系统属性 → 高级 → 环境变量

小技巧:不用卸载旧 JDK,IDEA 可以单独给 Gradle 指定 JVM 路径,不影响你机器上的其他项目。

踩坑提醒:JDK 大版本与构建插件(尤其 Kotlin/Dokka 插件)组合容易出现兼容性报错,历史上就有 "Uninitialized object exists on backward branch" 这类问题。原则:JDK 与项目基线严格对齐,不要"顺手升级"。

3.2 拿源码:认准 tag,别下 ZIP

# 完整历史(想看 git log 追演变就选它,但慢)
git clone https://github.com/spring-projects/spring-framework.git
cd spring-framework
git checkout v7.0.8          # 一定切 release tag,别看 main

# 只想读代码,推荐浅克隆,快得多
git clone --branch v7.0.8 --depth 1 https://github.com/spring-projects/spring-framework.git

国内直连慢的话,换 Gitee 镜像仓库拉同 tag 即可,速度能快 10 倍。

为什么必须用 Git 而不是下 ZIP? 三个原因:

  1. 源码里有基于 Git 信息的构建逻辑,ZIP 解压缺 .git 目录会导致构建元数据异常;
  2. git log / git blame 是读源码的"时光机",能看到关键代码为什么这么写;
  3. 想对比 7.0.0 → 7.0.8 的改动时,Git 是最高效的工具。

⚠️ 注意:--depth 1 浅克隆之后没法 git log 看历史,两种模式按需选。切完 tag 可以用 git branch --show-current 确认当前处于 v7.0.8 的 detached HEAD 状态。

3.3 Gradle:千万不要自己装,用 Wrapper

这是新手最大的误区——去官网下载 Gradle、配 GRADLE_HOME、配 PATH,结果版本和源码不匹配,报一堆莫名其妙的错。

Spring 源码自带 Gradle Wrapper,核心文件就四个:

spring-framework/
├── gradlew          # Linux/Mac 执行脚本
├── gradlew.bat      # Windows 执行脚本
└── gradle/
    └── wrapper/
        ├── gradle-wrapper.jar
        └── gradle-wrapper.properties  # 核心版本配置

验证一下(Windows 用 gradlew.bat -v):

./gradlew --version
# 看到 Gradle 9.x + JVM 版本就对了

7.0.8 的 gradle/wrapper/gradle-wrapper.properties 长这样:

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-bin.zip
networkTimeout=10000
retries=0
retryBackOffMs=500
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

它的工作机制:

技术亮点:Wrapper 机制把 Gradle 版本纳入项目版本管理,保证你、同事、CI 三处用的是同一个 Gradle 版本,彻底消灭"我这能编译,你那编译不过"的经典问题。这也是面试可以顺手提一句的工程化亮点。

顺带一个高频追问:Wrapper 四个文件分别什么作用?答:gradlew / gradlew.bat 是启动脚本;gradle-wrapper.jar 负责下载与校验;gradle-wrapper.properties 声明版本与地址。前三个不该手写,升级版本只用 ./gradlew wrapper --gradle-version x.x。

还有一个版本坑必须点破:

踩坑提醒:有旧教程写 Spring 7 用 Gradle 8.14——那是过时的说法。JDK 25 的 class file major version 是 69,Gradle 8.x 不认识,会直接报错;必须 Gradle 9.1+。7.0.8 的 Wrapper 锁定的是 9.5.1,以你本地 gradle-wrapper.properties 为准。

3.4 加速配置:镜像 + 内存,一次配好

① 给 Gradle 足够内存 + 并行加速,在根目录 gradle.properties 中:

# 给 Gradle 守护进程足够内存(大项目必备)
org.gradle.jvmargs=-Xmx4g -XX:MaxMetaspaceSize=1g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

# 并行构建 + 构建缓存 + 守护进程
org.gradle.parallel=true
org.gradle.caching=true
org.gradle.daemon=true

# 不读 Kotlin 协程源码的话可以关掉,省点依赖
kotlin.stdlib.default.dependency=false

这是官方与社区公认的提速组合:并行利用多核、缓存复用历史产物、守护进程避免 JVM 反复冷启动。实测多核机器上,编译时间能从十几分钟压到几分钟。

② 依赖镜像。别急着改源码里的 build.gradle,更优雅的做法是在用户目录 ~/.gradle/init.gradle(或 ~/.gradle/init.d/ 下)统一注入,对所有 Gradle 项目生效:

allprojects {
    repositories {
        mavenLocal()
        maven { url 'https://maven.aliyun.com/repository/public' }
        maven { url 'https://maven.aliyun.com/repository/spring' }
        mavenCentral()
    }
    buildscript {
        repositories {
            maven { url 'https://maven.aliyun.com/repository/public' }
            maven { url 'https://maven.aliyun.com/repository/gradle-plugin' }
        }
    }
}

同时在 settings.gradle 顶部补一段 pluginManagement,把插件仓库也指到镜像,否则插件下载经常卡死:

pluginManagement {
    repositories {
        maven { url 'https://maven.aliyun.com/repository/public' }
        maven { url 'https://maven.aliyun.com/repository/spring' }
        gradlePluginPortal()
        maven { url 'https://repo.spring.io/plugins-release' }
    }
}

注意:repo.spring.io 这类官方仓库必须保留,只加镜像、别全删,否则一些 Spring 自有构件会解析失败。

③ 如果连 Gradle 发行包都下不动(gradle-9.5.1-bin.zip),直接改 Wrapper 下载地址为国内镜像:

# gradle/wrapper/gradle-wrapper.properties
distributionUrl=https\://mirrors.cloud.tencent.com/gradle/gradle-9.5.1-bin.zip

注意 https\:// 的反斜杠是转义符,原样保留,别手欠删掉。也可以手动下载发行包放到 ~/.gradle/wrapper/dists 对应目录。

3.5 预编译:官方钦定的关键一步(90% 的人卡在这)

源码根目录有个 import-into-idea.md,官方步骤极简,原文就四条:

1. Precompile spring-oxm with ./gradlew :spring-oxm:compileTestJava
2. Import into IntelliJ (File -> New -> Project from Existing Sources -> 选 build.gradle)
3. When prompted exclude the spring-aspects module
4. Code away

第 1 步就是预编译,不是可选项:

./gradlew :spring-oxm:compileTestJava
# 官方同时建议把 spring-core 也预编译一遍
./gradlew :spring-core:compileTestJava

Windows 用户注意:命令是 gradlew.bat ...,不要照抄 ./(那是 Shell 语法)。首次执行要下载依赖,耗时 5~20 分钟正常,喝杯咖啡别慌。

面试官最爱追问:为什么要预编译它? 这是准备篇最有含金量的回答:

原因一:RepackJar 重打包产物。spring-core 把第三方库改名换姓塞进自己的 jar——为了零外部依赖、避免版本冲突。比如把 com.palantir.javapoet 重定位为 org.springframework.javapoet(AOT 代码生成用)、org.objenesis 重定位为 org.springframework.objenesis(实例化用),ASM、Kotlin 反射相关类同理。这些产物只有构建时才生成,IDEA 索引理解不了"动态生成"的类,不预编译就满屏红、跳不到定义。

原因二:XJC 生成源码。spring-oxm 的测试代码依赖构建期用 XJC 从 XSD 生成的 JAXB 类型,首次导入时这些类还不存在。

对应的构建脚本(7.0.8 节选):

// spring-core/spring-core.gradle
plugins {
    id 'org.springframework.build.multiReleaseJar'
}
// spring-core 用 Multi-Release Jar 支持 Java 21/24 的新特性
multiRelease {
    releaseVersions 21, 24
}
// 把 com.palantir.javapoet 重定位为 org.springframework.javapoet 后重打包
tasks.register('javapoetRepackJar', ShadowJar) {
    archiveBaseName = 'spring-javapoet-repack'
    configurations = [javaPoetConfig]
    relocate('com.palantir.javapoet', 'org.springframework.javapoet')
}
// 同理,把 org.objenesis 重定位为 org.springframework.objenesis
tasks.register('objenesisRepackJar', ShadowJar) {
    archiveBaseName = 'spring-objenesis-repack'
    relocate('org.objenesis', 'org.springframework.objenesis')
}
// spring-oxm/spring-oxm.gradle
xjc {
    xsdDir.set(layout.projectDirectory.dir("src/test/schema"))
    defaultPackage.set('org.springframework.oxm.jaxb.test')
}
// XJC 生成的源码只挂到 test 源集
sourceSets.test.java.srcDir(tasks.named("xjc", XjcTask).flatMap { it.outputJavaDir })

隐藏坑:你在 IDEA 里点了 Rebuild Project 之后,这些生成源码可能被清掉,表现为突然一堆找不到符号——重新执行一次预编译命令即可恢复。

如果你还想把编译好的 jar 装进本地 Maven 仓库、方便业务工程引用:

# 官方全套构建(时间长)
./gradlew build
# 只编译跳过测试和检查(推荐初学者)
./gradlew build -x test -x check
# publishToMavenLocal 的缩写,-PskipDocs 跳过 javadoc 和 zip 分发
./gradlew pTML -PskipDocs

单模块迭代可以更省:

# 只编译并测试 spring-webmvc,-a 跳过其他模块的重建,快很多
./gradlew -a :spring-webmvc:test

Gradle 的增量构建很好用,不要动不动 clean。

3.6 IDEA 导入:三处设置 + 一个排除

File → Open(或 New → Project from Existing Sources)
→ 选中 spring-framework 根目录的 build.gradle → Open as Project / Trust Project

选 build.gradle,不要只选目录,让 IDEA 识别为 Gradle 项目而非普通目录。

导入弹窗提示时直接排除 spring-aspects 模块。如果错过了,事后补:File → Project Structure → Modules → 选中 spring-aspects → 点 "-" 移除。

为什么要排除? 该模块含 .aj 文件,依赖 AspectJ 编译器(AJDT)处理的类型,IDEA 默认不认识(JetBrains 已知 issue IDEA-64446),导入必红。而且它不影响你读 IoC/AOP 主线——Spring 自己的 AOP 核心在 spring-aop,不在 spring-aspects。

然后检查这几处设置:

设置项
位置
建议值
Project SDK
File → Project Structure → Project
JDK 25(或 17)
Gradle 来源
Settings → Build Tools → Gradle
Use Gradle from: 'gradle-wrapper.properties'(关键!别用本地 Gradle)
Gradle JVM
同上
与 Project SDK 一致
Gradle user home
同上
指向短路径、无中文无空格的缓存目录
Build and run using / Run tests using
同上
改成 IntelliJ IDEA(调试时断点更稳,强烈建议)
Annotation Processing
Settings → Build → Compiler
✅ 开启,部分模块依赖注解处理器
VM Options
Help → Edit Custom VM Options-Xmx4096m -Dfile.encoding=UTF-8

关于 Gradle JVM 的版本,实际有两种可行姿势,我都验证过:

  • 姿势一(简单直接):Project SDK 和 Gradle JVM 都用 JDK 25。Wrapper 锁定的 Gradle 9.5.1 完全支持;
  • 姿势二(更稳):Gradle JVM 用 JDK 17,JAVA_HOME 指向 17,让 Gradle toolchain 在需要时自动下载 JDK 25(构建 Javadoc 等场景会用到)。如果你拿 25 跑测试遇到模块系统相关的奇怪问题,切回这个姿势。

另外,源码里自带 .sdkmanrc 文件(钉了 java=25),用 SDKMAN 的同学一句 sdk env 就能把终端切到对应 JDK。

首次同步会下载依赖,耐心等。如果卡住,先在命令行跑 ./gradlew tasks 验证构建本身是否健康,再回 IDE 排查——这一步能快速区分是"网络问题"还是"IDE 问题"。

导入成功的验证方式很简单:找到 spring-context 模块下的 AbstractApplicationContext,能正常索引、跳转,说明导入成功。


四、建一个自己的调试模块:这一步决定你能不能坚持读下去

不要在 Spring 的测试类里读源码——测试用例太散、上下文太重。建一个最小 Demo 模块,自己 new 容器,想停哪停哪。

① 根目录新建 my-debug/,写 my-debug.gradle:

plugins { id 'java-library' }

dependencies {
    api(project(":spring-context"))   // 传递依赖 beans + core + expression
    api(project(":spring-aop"))
    testImplementation platform('org.junit:junit-bom:6.0')
    testImplementation 'org.junit.jupiter:junit-jupiter'
}

② settings.gradle 里注册:

include 'my-debug'

③ 写一个最小可断点的启动类:

package com.example;

import org.springframework.context.annotation.*;

@Configuration
@ComponentScan("com.example")
publicclassDemoApp{

publicstaticvoidmain(String[] args){
// 断点打在这一行,F7 单步进去就是整个 Spring 宇宙
var ctx = new AnnotationConfigApplicationContext(DemoApp.class);

        UserService service = ctx.getBean(UserService.class);
        System.out.println(service.hello("Spring 7"));

        ctx.close();
    }
}

@Component
classUserService{
public String hello(String name){ return"Hello, " + name; }
}

④ 右键 Run / Debug。 第一次会触发全量索引,等进度条走完,之后秒开。

跑起来后控制台能打印出 Bean 结果,就说明环境彻底通了。你甚至可以顺手看下 BeanFactory 的实现类:

System.out.println("BeanFactory 实现:" + ctx.getBeanFactory().getClass().getSimpleName());
// 输出:DefaultListableBeanFactory

进阶验证:用 7.0 新特性 BeanRegistrar 一石三鸟

Spring 7 的 BeanRegistrar 编程式注册 Bean 非常适合做"进阶验证"——它同时验证三件事:① JDK 版本正确;② 构建产物正确(能加载 spring-context);③ 你能断点单步进 BeanRegistry 的实现,这正是读源码的起点。

// 一个方法搞定"按配置批量注册 Bean"
publicclassLibraryRegistrarimplementsBeanRegistrar{

@Override
publicvoidregister(BeanRegistry registry, Environment env){
        String[] branches = env.getProperty("library.branches", String[].class, newString[0]);
for (String branch : branches) {   // library.branches=north,south
            registry.registerBean(
                branch + "Desk",           // northDesk / southDesk
                HelpDesk.class,
spec -> spec.supplier(ctx -> newHelpDesk(branch))
            )
;
        }
    }
}

@Configuration(proxyBeanMethods = false)
@Import(LibraryRegistrar.class)   // 必须用 @Import 激活 Registrar
classLibraryConfig
{ }
publicclassDebugSpring{
publicstaticvoidmain(String[] args){
try (var context = new AnnotationConfigApplicationContext(LibraryConfig.class)) {
// 断点打在这行,F7 进入
            HelpDesk desk = context.getBean("northDesk", HelpDesk.class);
            System.out.println(desk);
        }
    }
}

技术亮点:BeanRegistrar 能用 if/for 做条件 + 批量注册,还支持 spec.prototype().lazyInit().supplier(...) 链式配置,比写 BeanDefinitionRegistryPostProcessor 干净十倍,是入门 BeanDefinition 注册的最短路径。注意两点:必须用 @Import 引入(@Bean/@Component 不触发);它替代的是部分 @Conditional + @Configuration 的场景。

不想编译整个仓库?还有个轻量姿势

如果你只想在自己项目里断进 Spring 源码,不想维护整个源码仓库的编译:

  • 方案 A:composite build。在自己项目的 settings.gradle 加 includeBuild("../spring-framework"),直接以源码代替 jar 运行,断点无缝生效;
  • 方案 B:BOM + sources jar。用 Spring BOM 拉依赖,attach sources jar,在自己的 Demo 里照样能断进去。

五、模块地图:别一头扎进 9000 个文件

Spring Framework 有 约 9000 个 Java 源文件,绝对不能从第一个文件开始读。好消息是:Spring 的模块依赖严格分层,底层不依赖上层,这是它保持无循环依赖的工程纪律。

先看目录结构,知道去哪找东西:

spring-framework/
├── build.gradle                 # 根构建脚本(仓库、全局约定插件)
├── settings.gradle              # 模块清单 + 插件仓库
├── gradle.properties            # 版本号、JVM 参数
├── import-into-idea.md          # 你的官方说明书
├── buildSrc/                    # 自定义 Gradle 插件(编译约定、发布逻辑)
├── spring-core/                 # 最底层:工具类、Resource、类型系统、注解解析
├── spring-beans/                # BeanDefinition、BeanFactory、属性编辑器
├── spring-context/              # ApplicationContext、事件、国际化、@Import
├── spring-aop/                  # ProxyFactory、Advisor、CglibAopProxy
├── spring-expression/           # SpEL
├── spring-jdbc/                 # JdbcTemplate、DataSourceTransactionManager
├── spring-tx/                   # 事务抽象(PlatformTransactionManager)
├── spring-web / spring-webmvc/  # MVC 主线:DispatcherServlet、HandlerMapping
├── spring-webflux/              # 响应式
├── spring-test/                 # TestContext、@SpringJUnitConfig
└── spring-oxm / spring-jms ...  # 外围集成

核心依赖链记牢这张图:

阅读顺序建议:spring-core → spring-beans → spring-context → spring-aop,这四层吃透了,再看 Web 和 Data 就是水到渠成。

为什么是这个顺序? 因为 spring-beans 里的 BeanFactory 是整个 IoC 容器的心脏,但它依赖 spring-core 的 Resource 和 ClassUtils;spring-context 的 ApplicationContext 是 BeanFactory 的增强版,加上了事件、国际化和注解驱动;spring-aop 又建立在 Bean 的后置处理器机制之上。每一层都是前一层能力的自然扩展,顺着读不会迷路。

记忆口诀:core 是地基,beans 造 Bean,context 管全家,其余都是接在上面的插件。

铁律:读源码从 spring-core 往上走,千万别从 spring-webmvc 往下扎。前者是骨架,后者是皮肤。

顺带回答一个面试追问——模块间依赖怎么看? 看 settings.gradle 里的 include 列表,加上各模块 build.gradle 中的 api project(':spring-core') 之类声明,配合 IDEA 的 Gradle 视图,一目了然。


六、阅读方法论:一个问题,一个断点,一条调用链

Spring 上百万行代码,漫无目的地读 = 自杀式学习。干读源码等于白读,给你一套可直接照抄的方法。

6.1 三层漏斗法(这篇的灵魂)

6.2 断点驱动法(最推荐)

核心心法:"一个问题,一个断点,一条调用链"。不要"读"源码,要"查"源码。

举个例子,想搞明白"@Autowired 是在什么时候完成注入的":在 DefaultListableBeanFactory#doResolveDependency 和 AutowiredAnnotationBeanPostProcessor#postProcessProperties 上打断点,一路 F7 跟进去,调用链自然就出来了。

这个方法的优势三个字:有锚点。你不是漫无目的地翻文件,而是从"已知的入口"顺着调用链往下走。断点命中的那一刻,变量窗口里的数据比任何文档都直观。调试时重点盯三样东西:

  • 调用栈(Call Stack / Frames):看这个方法是从哪一层被调起来的,理解模块协作关系,比读代码快 10 倍;
  • 关键变量:beanName、beanDefinition、candidate,直接告诉你容器当前在处理谁;
  • 条件断点:Bean 太多时,在断点上加 beanName.equals("userService") 或 beanName.contains("Controller"),只看你关心的那个,避免被几百个内部 Bean 淹没。

再补两个神器:

  • Evaluate Expression(Alt+F8):在断点处直接执行表达式,实时观察 beanDefinitionMap、singletonObjects 的内容;
  • Call Hierarchy(Ctrl+Alt+H):看调用层级,比肉眼跳转高效十倍;IDEA 里还可以右键类名 → Diagrams → Show Diagram 一键生成类继承图。

6.3 其他三个方法,组合使用

  • 接口抽象法:Spring 大量使用策略模式,先看顶层接口定义契约,再看核心实现类。比如学 BeanFactory,先记接口的 5 个核心方法,再看 DefaultListableBeanFactory 的具体实现;
  • 测试驱动法:Spring 自己的测试类就是最佳教材,比如搜 AnnotationConfigApplicationContextTests,运行、断点、观察调用栈。从测试进去,往往比从 main 进去更轻;
  • git 考古法:git blame 看某行代码为什么这么写;git log --follow <file> 看文件演进;git log -p -S "getBean" 看某个能力是怎么长出来的——比静态读快十倍。

6.4 断点地图:只盯这几个落点

想搞懂的问题
断点位置
能看到什么
容器是怎么启动的?
AbstractApplicationContext#refresh()总调度器
,整条主线的目录
Bean 是怎么被创建的?
AbstractAutowireCapableBeanFactory#doCreateBean
实例化 → 属性填充 → 初始化全链路
构造器推断与实例化
AbstractAutowireCapableBeanFactory#createBeanInstance
实例化策略
单例怎么批量实例化?
DefaultListableBeanFactory#preInstantiateSingletons
循环 BeanDefinition 的主流程
取 Bean / 循环依赖
AbstractBeanFactory#doGetBean
、DefaultSingletonBeanRegistry#getSingleton
单例缓存、三级缓存、FactoryBean、作用域
注解怎么变成 BeanDefinition?
AnnotatedBeanDefinitionReader
、AnnotationConfigApplicationContext 构造链
配置类解析入口
AOP 代理怎么生成的?
AopProxyFactory
 → CglibAopProxy
代理对象"变"出来的过程
@Transactional
 怎么生效?
TransactionInterceptor#invoke()
事务的真正入口
HTTP 请求怎么找到方法?
DispatcherServlet#doDispatch()
HandlerMapping → Adapter 全过程
表达式怎么解析?
SpelExpressionParser#parseExpression()
SpEL 解析执行

WebFlux 方向的同学记得开 Async Stack Trace,否则响应式链路的堆栈是断的。

6.5 阅读纪律与执行节奏

四条硬纪律:

  1. 一次只追一个问题。比如今天就搞清"循环依赖怎么破的",别的分支一律跳过;
  2. 边读边写,不动笔等于没读。笔记固定三栏:问题 → 关键类/方法 → 我的结论(一句话)。画不出时序图 = 没读懂;
  3. 改一行代码验证猜想。把 allowCircularReferences 改成 false 看报错,比看十遍代码记得牢;
  4. 允许跳过。refresh() 前 3 步是铺垫,第 9 步 onRefresh() 在父类里是空方法,别在这耗时间;遇到 *Utils / *Helper 只看方法签名和注释,不看实现,除非报错指向它。

别踩的雷:

  • 🚫 别从 main 开始逐行读——Spring 调用链太深,会读到怀疑人生;
  • 🚫 别陷入 *Tests、*.aj(AspectJ 文件)——测试和切面声明不是主线;
  • ✅ 遇到不认识的类先看 javadoc,Spring 的 javadoc 写得极其详尽。

一份可直接抄的执行节奏:

阶段
做什么
产出
Day 1
搭环境 + 跑通 Demo + 在 refresh() 打断点看 12 步
一张手画的调用顺序图
Day 2-3
跟完 Bean 定义解析 → 注册 → 实例化 → 初始化全链路
一篇带堆栈的笔记
Day 4-5
跟完 AOP:@EnableAspectJAutoProxy → Advisor 收集 → 代理创建
一个自己写的代理 Demo
Day 6+
事务、MVC 分发、扩展点(BFPP / BPP)
每个扩展点一个"我能用它干什么"的例子

这个系列后面会逐篇拆解 refresh() 十二步、三级缓存和 AOP 代理,关注我,别迷路,下一篇更新时第一时间看到。

6.6 先混个脸熟:核心调用链

这条链是 Spring IoC 的"主动脉",后面会一步步拆,这里先建立整体印象:

入口怎么找?从 new AnnotationConfigApplicationContext(...) 一路追:构造器里注册配置类(AnnotatedBeanDefinitionReader#register),然后调用 refresh()——一切从这里开始。Spring Boot 场景则是 SpringApplication.run → refreshContext → refresh(),殊途同归。


七、refresh() 十二步:先拿下这张总地图

虽然这是下一篇的主题,但准备篇必须让你先认识它——面试 90% 的容器问题都能挂在这条主线上。

下面是 7.0.8 的真实源码(精简注释版):

// org.springframework.context.support.AbstractApplicationContext (7.0.8)
@Override
publicvoidrefresh()throws BeansException, IllegalStateException {
this.startupShutdownLock.lock();          // 7.x:由 synchronized 演进为 ReentrantLock
try {
this.startupShutdownThread = Thread.currentThread();
        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

// 1. 刷新前预处理:设置启动时间、active 标志、清理缓存
        prepareRefresh();

// 2. 告诉子类刷新内部 BeanFactory(返回 DefaultListableBeanFactory)
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// 3. 预处理 BeanFactory:塞入 ClassLoader、标准后置处理器
        prepareBeanFactory(beanFactory);

try {
// 4. 允许子类在 BeanFactory 就绪后做后处理(父类空实现,扩展钩子)
            postProcessBeanFactory(beanFactory);

            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
// 5. 执行 BeanFactoryPostProcessor —— 解析配置类、扫描 Bean、注册 BeanDefinition ★
            invokeBeanFactoryPostProcessors(beanFactory);
// 6. 注册 BeanPostProcessor —— AOP、@Autowired 的幕后推手 ★
            registerBeanPostProcessors(beanFactory);
            beanPostProcess.end();

// 7. 初始化国际化资源 MessageSource
            initMessageSource();
// 8. 初始化事件广播器
            initApplicationEventMulticaster();
// 9. 子类扩展钩子(Spring MVC / Boot 在这里创建 Web 容器)
            onRefresh();
// 10. 注册事件监听器
            registerListeners();
// 11. 实例化所有非懒加载单例 Bean ★★ 单例 Bean 真正诞生的地方
            finishBeanFactoryInitialization(beanFactory);
// 12. 收尾:发布 ContextRefreshedEvent、启动 Lifecycle Bean
            finishRefresh();
        }
catch (RuntimeException | Error ex) {
// 失败即回滚:停掉已启动的 Lifecycle Bean、销毁已创建单例、重置 active 标志
if (this.lifecycleProcessor != null && this.lifecycleProcessor.isRunning()) {
this.lifecycleProcessor.stop();
            }
            destroyBeans();
            cancelRefresh(ex);
throw ex;
        }
finally {
            contextRefresh.end();
        }
    }
finally {
this.startupShutdownThread = null;
this.startupShutdownLock.unlock();
    }
}

最关键的三步,用一个盖房子的比喻记住它:

  • ⑤ invokeBeanFactoryPostProcessors = 收图纸:.class → BeanDefinition,只注册不 new。配置类解析、@ComponentScan、@Import 都在这;
  • ⑥ registerBeanPostProcessors = 装钩子:按 PriorityOrdered > Ordered > 普通 排序注册,AOP 代理创建器和 @Autowired 注入器都在这埋下;
  • ⑪ finishBeanFactoryInitialization = 盖房子:非懒加载单例全部实例化,循环依赖、三级缓存、AOP 代理的"偷梁换柱"都发生在这。

前 3 步是铺垫,第 9 步父类是空实现,别在这耗时间。

一句话总结:refresh() 不是创建单例 Bean 的方法,它是"把容器从 0 准备到可用"的编排方法。单例 Bean 的大批量实例化只发生在第 11 步,但所有准备工作(BeanDefinition、后置处理器)都在前面完成。

两个可以拿去面试聊的细节:

细节一:锁的演进。 老版本是 synchronized (this.startupShutdownMonitor),7.x 已经换成了可重入锁 private final Lock startupShutdownLock = new ReentrantLock(),并发控制更精细,还支持 tryLock 超时判断容器是否正在刷新。很多网上教程贴的还是老版代码,对照时留意。

细节二:模板方法思想。refresh() 固定了容器启动的主流程,但 postProcessBeanFactory()、onRefresh() 这些钩子留给子类扩展——主流程固定,细节交给子类。这个设计模式在面试里非常加分。

为什么从 refresh() 入手而不是从 getBean() 入手? 因为 refresh() 是容器生命周期的编年史,getBean 只是其中一环;先看全景再看局部,认知负担最小。

跑起来后你会在调用栈里看到 refresh() → obtainFreshBeanFactory() → invokeBeanFactoryPostProcessors() → finishBeanFactoryInitialization() 的完整链条——这就是容器启动的骨架。给个可直接跑的调试测试类(注意 7.0 已移除 javax.annotation 支持,@PostConstruct 要用 jakarta.annotation 包):

// 放在 spring-context 的 test 目录下即可运行
publicclassBeanLifecycleDebugTest{
@org.junit.jupiter.api.Test
voiddebugRefresh()
{
// 断点打在 AbstractApplicationContext#refresh() 的第一行
var ctx = new org.springframework.context.annotation
                .AnnotationConfigApplicationContext(Config.class);
        System.out.println(ctx.getBean(MyBean.class));
    }
staticclassConfig{
@org.springframework.context.annotation.Bean
        MyBean myBean()
{
returnnew MyBean();
        }
    }
staticclassMyBean{
@jakarta.annotation.PostConstruct   // 7.0 已移除 javax.annotation 支持
voidinit(){ System.out.println("MyBean init"); }
    }
}

八、踩坑速查表:九成失败是"版本没对齐 + 没预编译"

把 8 份素材里的坑合并去重,整理成这张表,建议收藏:

#
症状
根本原因
解决方案
1
Gradle 发行包 / 依赖下载龟速甚至失败
官方源在国外
init.gradle
 注入阿里云镜像;发行包改腾讯云镜像;必要时 --refresh-dependencies 清缓存重试;手动下载放 ~/.gradle/wrapper/dists
2
导入后满屏红、跳不到定义
RepackJar / XJC 产物构建期才生成,IDE 索引缺失
先 ./gradlew :spring-oxm:compileTestJava 和 :spring-core:compileTestJava 再导入;完成后 File → Invalidate Caches
3
找不到 org.springframework.objenesis.* / javapoet 类
同上,重打包产物未生成
同上,预编译 spring-core
4
spring-oxm
 测试类一堆找不到符号
JAXB/XJC 生成源码缺失
./gradlew :spring-oxm:compileTestJava
;Rebuild Project 后记得重新执行
5
spring-aspects
 编译失败、满屏红
AspectJ 编译期织入,IDEA 认不出(IDEA-64446)
导入时排除该模块,或装 AspectJ Support 插件;不影响主线阅读
6
Unsupported class file major version
 / major version 69
Gradle/JDK 版本不匹配;8.x 跑不了 JDK 25
Project SDK 与 Gradle JVM 都切到 17+(推荐 25);Gradle 用 Wrapper 锁定的 9.5.1,严禁 JDK 11 及以下
7
构建报 toolchain 找不到 JDK 25
构建工具链需要 25
JAVA_HOME
 指向 17/25,让 Gradle 自动下载 JDK 25 toolchain
8
找不到 jakarta.* 类 / javax.* 失效
7.0 彻底移除 javax.*,Jakarta EE 11 是硬基线
全量换 jakarta.*;检查依赖是否为 7.0.8 版本
9
spring-jcl
 解析失败
模块已删除
改用 Commons Logging 1.3.0,老文章相关操作直接跳过
10
改源码编译不过、@Nullable 报错
NullAway 在校验空安全注解一致性
这是 7.0 的 JSpecify 校验机制,按提示补齐注解
11
编译巨慢、OOM、Daemon 卡死
全量编译 + 内存不足
org.gradle.jvmargs=-Xmx4g
;开 parallel/caching/daemon;只编需要的模块;源码放 SSD、纯英文无空格短路径;首次同步关杀毒实时扫描
12
IDEA 索引卡死、内存飙升
模块太多、堆不够
调大 IDEA 堆内存(-Xmx4g);排除无关模块,只导核心模块
13
测试用例大面积失败
环境依赖型失败(JMX、数据库、定时任务)
读源码无需跑全量测试,构建加 -x test;单元测试一律用 ./gradlew :模块:test --tests xxx 跑,IDEA 内运行并非全兼容
14
断点跳来跳去、行号对不上、跳进反编译 class
Gradle 编译与调试不匹配 / 源码与产物不一致
Build and run using
 改成 IntelliJ IDEA;先 ./gradlew :spring-context:classes 编译一次;确认用的是本项目模块而非 External Libraries
15
中文注释乱码
编码不一致
IDEA 设置中所有 File Encodings 统一改为 UTF-8
16
各种诡异路径错误
源码放在中文/带空格路径下
放到纯英文、无空格的短路径,如 D:/code/spring-framework
17
7.0.8 的新 API 网上搜不到资料
版本太新,二手博客还是 5.x
只信三处
:源码 Javadoc、spring-framework/docs、GitHub Issues/PR;老博客当思路参考,别抄代码

排坑总原则:九成的失败都是"版本没对齐 + 没预编译"。 先怀疑这两件事,再怀疑人生。编译问题按 JDK 版本 → 网络仓库 → 内存参数 的顺序排查,几乎不会跑偏。


九、面试快问快答:背下来就是加分项

Q1:为什么读 Spring 源码要自己编译,直接看 GitHub 不行吗?编译后才能打断点、改代码、立刻看效果,这是理解 IoC/AOP 运行机制最高效的方式;而且本地可编译的源码,是排查框架级生产问题最强的调试工具。

Q2:为什么 Spring 用 Gradle 不用 Maven?多模块构建(20+ 子模块)、自定义构建逻辑(buildSrc 里的约定插件、RepackJar 重打包)、构建缓存与增量编译效率更高。Maven 靠插件,Gradle 靠代码,灵活性差一个量级。

Q3:为什么强调用 Wrapper 而不是本地安装 Gradle?Spring 这种多模块大项目对 Gradle 版本很敏感,全局版本一旦和 gradle-wrapper.properties 声明的不一致,就会出现各种依赖解析和增量编译的诡异问题。Wrapper 能 100% 对齐,这也是工程化最佳实践。

Q4:为什么导入前一定要先编译 spring-oxm / spring-core?两个原因:一是 spring-oxm 依赖 XJC 从 XSD 构建期生成的 JAXB 类型;二是 spring-core/spring-oxm 有 RepackJar 任务,会把 Relocate 后的依赖打进 jar。这两类产物在 IDE 首次导入时都不存在,不预编译就解析不到。

Q5:refresh() 里哪几步最关键?第 5 步 invokeBeanFactoryPostProcessors(解析配置类、扫描注册 BeanDefinition)、第 6 步 registerBeanPostProcessors(注册后置处理器,AOP 和 @Autowired 靠它)、第 11 步 finishBeanFactoryInitialization(单例 Bean 真正诞生)。前 3 步是铺垫,第 9 步父类是空实现。

Q6:7.x 的 refresh() 相比老版本有什么变化?startupShutdownMonitor 的同步从 synchronized 演进成了 ReentrantLock(startupShutdownLock),并发控制更精细,支持 tryLock 超时判断容器是否正在刷新。

Q7:Spring 7 相对 6 最大的变化是什么?基线层面:JDK 17 保底 + 拥抱 25、Jakarta EE 11、JSpecify 空安全、Jackson 3 过渡;能力层面:程序化 Bean 注册(BeanRegistrar)、核心韧性(@Retryable 默认重试 3 次、间隔 1 秒,注解名与 Spring Retry 一致,只改 import 就能迁移)、API 版本治理、JmsClient/RestTestClient、移除 spring-jcl。

Q8:RestTemplate 还能用吗?7.0 仍可用但已宣布弃用路线(7.1 打 @Deprecated,8.0 移除),新代码应使用 RestClient 或 HTTP 接口客户端,可逐个客户端迁移。

Q9:如何确认读的是 7.0.8 的行为,而不是 5.x/6.x 的记忆?用 git log --follow <file> 看这个文件的最近提交,结合 release notes 里的 Breaking Changes 对照。

Q10:你是怎么验证自己真读懂了的?三个标准:能画出调用链、能关掉某个开关复现报错、能用对应的扩展点实现一个自己的小功能(比如写一个 BeanPostProcessor 给所有 Bean 加代理)。

30 秒回答模板(可以直接背):

我会先锁定 Spring Framework 7.0.8 版本,用源码自带的 Gradle Wrapper 构建,JDK 17+、本地推荐 25。然后先预编译 spring-core、spring-oxm,导入时排除 spring-aspects。阅读时我不从工具类看起,而是从一个最小 AnnotationConfigApplicationContext 用例入手,断点 AbstractApplicationContext#refresh(),沿着容器初始化、BeanDefinition 注册、Bean 实例化这条主线读。这样能保证阅读有入口、有主线、有反馈。

这段话一出来,面试官基本就知道:你不是"假装看过源码",你是真的知道怎么读。


十、命令速查表 + 一页纸自查清单

命令速查表

# 拉取指定版本(浅克隆)
git clone --branch v7.0.8 --depth 1 https://github.com/spring-projects/spring-framework.git

# 查看 wrapper 锁定的 Gradle 版本
./gradlew --version
cat gradle/wrapper/gradle-wrapper.properties

# 预编译(导入 IDEA 前必做)
./gradlew :spring-oxm:compileTestJava
./gradlew :spring-core:compileTestJava

# 跳过测试编译整个工程
./gradlew build -x test -x check

# 只编译核心三模块
./gradlew :spring-core:compileJava :spring-beans:compileJava :spring-context:compileJava -x test -x javadoc

# 单模块快速迭代
./gradlew -a :spring-webmvc:test

# 装进本地 Maven 仓库(本地迭代姿势)
./gradlew pTML -PskipDocs

一页纸自查清单

[ ] JDK 17+ 安装完成,java -version 输出正确
[ ] git clone 并 checkout v7.0.8(不是 main,不是 ZIP)
[ ] ./gradlew --version 能看到 Gradle 9.x + JVM 17/25
[ ] ./gradlew :spring-oxm:compileTestJava  BUILD SUCCESSFUL
[ ] IDEA 导入 build.gradle,Project SDK = 17/25
[ ] Gradle 来源选 gradle-wrapper.properties,Build and run using 选 IntelliJ IDEA
[ ] spring-aspects 已从 Modules 排除
[ ] 镜像已配置,依赖不再超时
[ ] my-debug 模块能 Debug 启动
[ ] 断点在 refresh() 命中,能看到 12 个步骤
[ ] 笔记模板建好,第一条链路已记录

全勾上,恭喜你,环境篇结束——你已经超过 80% 只收藏不行动的人了。


十一、写在最后

准备篇只需要记住五句话:

  1. 版本先锁死:Spring Framework 7.0.8,JDK 17 起步、25 推荐;
  2. 构建用 Wrapper:不要自己乱装 Gradle;
  3. 导入先预编译:spring-oxm / spring-core,排除 spring-aspects;
  4. 阅读靠用例:最小 Demo + 断点 refresh(),一个问题一个断点一条调用链;
  5. 入口抓主干:core → beans → context → aop,refresh() 是你的第一站。

读 Spring 源码最难的不是代码本身,而是从"打开 IDE"到"第一个断点命中"这段路。今天你把这段路铺平了,后面就是纯收益。第一次成功编译后,后续迭代会顺滑很多,建议养成定期同步、关注 build.gradle 与 gradle-wrapper.properties 变化的习惯。

下一篇预告:我们正式钻进 refresh() 的 12 步主干,重点攻克三件事——invokeBeanFactoryPostProcessors 里配置类是怎么被解析的、三级缓存解决循环依赖的真实发生时刻(附一个故意造出循环依赖的 Demo)、AOP 代理到底在哪一步"偷梁换柱"。想第一时间看到,点个关注不迷路。

如果这篇帮你把环境跑通了,点赞、在看、转发三连支持一下,你的每个互动都是我更新的动力。

最后留个互动问题:你搭 Spring 源码环境时遇到过最离谱的报错是什么?或者你最想先拆 refresh() 的哪一步?评论区聊聊,我帮你逐行定位。

参考来源:Spring Framework 7.0 Release Notes、官方 Build from Source Wiki 与 import-into-idea.md、v7.0.8 gradle-wrapper.properties、Spring Framework 7.0 GA 公告、Spring Boot 4.0 GA 公告

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料