ARTICLE · 1392630
读懂 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 版本速查表
| 7.0.8 | ||
| 最低 17,推荐 25 | ||
| 11 | javax.*jakarta.*,Tomcat 11 / Jetty 12.1 | |
| 用源码自带 Wrapper,锁定 9.5.1 | gradle-wrapper.properties 为准,不要自己装 | |
这里有个关键认知,面试很加分:
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 注册 | BeanRegistrarBeanRegistry | if/for 条件批量注册,比 BeanDefinitionRegistryPostProcessor 干净十倍 |
| 核心韧性能力 | org.springframework.core.retry@Retryable、@ConcurrencyLimit | |
| API 版本治理 | @ApiVersion | |
| 声明式 HTTP 客户端 | @HttpExchange | |
| JmsClient / RestTestClient | org.springframework.jms.JmsClient | JdbcClient / RestClient 的流式 API |
| JSpecify 空安全 | org.springframework.lang 注解 | @Nullable 一致性 |
移除 spring-jcl | ||
| SpEL 操作数上限 10,000 | spring.expression.maxOperations | |
| JDK 25 新特性影子 |
还有一个阅读时会真实遇到的坑,先埋个伏笔:
技术亮点 · 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? 三个原因:
源码里有基于 Git 信息的构建逻辑,ZIP 解压缺 .git目录会导致构建元数据异常;git log/git blame是读源码的"时光机",能看到关键代码为什么这么写;想对比 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。
然后检查这几处设置:
File → Project Structure → Project | ||
Settings → Build Tools → Gradle | ||
Settings → Build → Compiler | ||
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() | 总调度器 | |
AbstractAutowireCapableBeanFactory#doCreateBean | ||
AbstractAutowireCapableBeanFactory#createBeanInstance | ||
DefaultListableBeanFactory#preInstantiateSingletons | ||
AbstractBeanFactory#doGetBeanDefaultSingletonBeanRegistry#getSingleton | ||
AnnotatedBeanDefinitionReaderAnnotationConfigApplicationContext 构造链 | ||
AopProxyFactoryCglibAopProxy | ||
@Transactional | TransactionInterceptor#invoke() | |
DispatcherServlet#doDispatch() | ||
SpelExpressionParser#parseExpression() |
WebFlux 方向的同学记得开 Async Stack Trace,否则响应式链路的堆栈是断的。
6.5 阅读纪律与执行节奏
四条硬纪律:
一次只追一个问题。比如今天就搞清"循环依赖怎么破的",别的分支一律跳过; 边读边写,不动笔等于没读。笔记固定三栏: 问题 → 关键类/方法 → 我的结论(一句话)。画不出时序图 = 没读懂;改一行代码验证猜想。把 allowCircularReferences改成false看报错,比看十遍代码记得牢;允许跳过。 refresh()前 3 步是铺垫,第 9 步onRefresh()在父类里是空方法,别在这耗时间;遇到*Utils/*Helper只看方法签名和注释,不看实现,除非报错指向它。
别踩的雷:
🚫 别从 main开始逐行读——Spring 调用链太深,会读到怀疑人生;🚫 别陷入 *Tests、*.aj(AspectJ 文件)——测试和切面声明不是主线;✅ 遇到不认识的类先看 javadoc,Spring 的 javadoc 写得极其详尽。
一份可直接抄的执行节奏:
refresh() 打断点看 12 步 | ||
@EnableAspectJAutoProxy → Advisor 收集 → 代理创建 | ||
这个系列后面会逐篇拆解
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 份素材里的坑合并去重,整理成这张表,建议收藏:
init.gradle--refresh-dependencies 清缓存重试;手动下载放 ~/.gradle/wrapper/dists | |||
./gradlew :spring-oxm:compileTestJava 和 :spring-core:compileTestJava 再导入;完成后 File → Invalidate Caches | |||
org.springframework.objenesis.* / javapoet 类 | spring-core | ||
spring-oxm | ./gradlew :spring-oxm:compileTestJava | ||
spring-aspects | |||
Unsupported class file major versionmajor version 69 | |||
JAVA_HOME | |||
jakarta.* 类 / javax.* 失效 | javax.*,Jakarta EE 11 是硬基线 | jakarta.*;检查依赖是否为 7.0.8 版本 | |
spring-jcl | |||
@Nullable 报错 | |||
org.gradle.jvmargs=-Xmx4gparallel/caching/daemon;只编需要的模块;源码放 SSD、纯英文无空格短路径;首次同步关杀毒实时扫描 | |||
-Xmx4g);排除无关模块,只导核心模块 | |||
-x test;单元测试一律用 ./gradlew :模块:test --tests xxx 跑,IDEA 内运行并非全兼容 | |||
Build and run using./gradlew :spring-context:classes 编译一次;确认用的是本项目模块而非 External Libraries | |||
D:/code/spring-framework | |||
只信三处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% 只收藏不行动的人了。
十一、写在最后
准备篇只需要记住五句话:
版本先锁死:Spring Framework 7.0.8,JDK 17 起步、25 推荐; 构建用 Wrapper:不要自己乱装 Gradle; 导入先预编译: spring-oxm/spring-core,排除spring-aspects;阅读靠用例:最小 Demo + 断点 refresh(),一个问题一个断点一条调用链;入口抓主干: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.8gradle-wrapper.properties、Spring Framework 7.0 GA 公告、Spring Boot 4.0 GA 公告















































































