版本基线:Spring Framework 7.0.8 (Spring Boot 4.x 底座)|JDK 17+
适合人群:会写 CRUD、但一被追问"为什么"就卡壳的同学
面试官一句"为什么是三级缓存,二级行不行",多少人在说出"三级缓存"四个字后就瞬间哑火。这篇文章以 Spring 7.0.8 源码为基线,用图解 + 源码 + 踩坑实录,把 IoC、AOP、事务、循环依赖四大深水区一次讲透。背了很多八股却扛不住追问的,往下看。
一、真实面试现场:"用过"和"懂"之间,隔着一条源码的河
先还原几个我亲历过的名场面:
面试官 :同一个 Service 里,方法 A 调用标了
@Transactional的方法 B,事务生效吗? 你:......应该生效吧?面试官 :那代理对象是什么时候生成的?在 Bean 生命周期的哪一步? 你(内心):完了,八股文没背到这一页。
还有一个更经典的:
面试官 :说说循环依赖怎么解决的? 你 :用三级缓存。 面试官 :哪三级?为什么两级不行? 你 :......为了循环依赖? 面试官:......行,我们聊下一个吧。🙂
看出问题了吗?背八股只能答"是什么",源码功底才能讲清"为什么"。 面试官真正想听的,从来不是结论,而是你能不能把结论还原成一条调用链。
二、为什么值得花时间读源码?收益是立刻兑现的
别扯"提升内功"这种虚的,读源码给你的,是四样马上能用的东西:
| 收益 | 具体表现 |
|---|---|
| 面试话语权 | 从"三级缓存"升级到"为什么必须三级 + 什么情况三级也救不了",直接和背题党拉开一档 |
| 排障能力 | 事务失效、AOP 不生效、BeanCurrentlyInCreationException,懂源码五分钟定位根因,不用靠重启玄学 |
| 设计直觉 | Spring 是设计模式的活教材:模板方法(refresh())、策略模式(AopProxy)、工厂模式(ObjectFactory)、责任链(拦截器链)、观察者(事件机制)......看懂了,你写框架级代码就不虚 |
| 一通百通 | Spring Boot、Spring Cloud、Spring Security 全家桶,底层全是这套机制。主干通了,学任何生态组件都事半功倍 |
再看一张扎心的段位表:
| 深度层级 | 面试官心理 | 你的段位 |
|---|---|---|
| 只会背"控制反转" | 套话 | 初级 |
| 说得出 Bean 生命周期 | 还行 | 中级 |
| 讲得清三级缓存为什么是"三级" | 有点东西 | 高级 |
能画出 refresh() 十二步 + 扩展点埋点位置 |
稳了,来聊聊薪资 | 资深 |
还有一个很多人忽略的事实:八股会过期,源码思想不会。 从 Spring 5.x 到 7.0.8,容器启动流程、三级缓存、AOP 代理机制这些核心骨架几乎没变。网上 90% 的博客讲的是 5.x,但读懂一次,受用五年。
一句话:读源码不是为了炫技,是为了把"会用"升级成"可控",把"玄学问题"变成"工程问题"。
三、开工之前:版本基线与源码地图
3.1 为什么以 7.0.8 为基线
Spring Framework 7.0.8 是 Spring Boot 4.x 的底层框架,2026 年发布,全面拥抱 Jakarta EE 11。它有几个你必须知道的变化,面试时随口说出来,就是"我跟进新版"的铁证:
| 新特性 | 说明 |
|---|---|
| JDK 17 基线,推荐 JDK 25 | 虚拟线程、结构化并发在新版本线上才完整 |
| Jakarta EE 11 | Servlet 6.1 / Validation 3.1 / Persistence 3.2 |
| 全局默认 CGLIB 代理 | 和 Spring Boot 对齐,@Async 等处理器行为统一 |
@Proxyable 注解 |
单个 Bean 级别指定代理策略,可显式退回 JDK 代理 |
BeanRegistrar |
程序化 Bean 注册 API |
| 重试能力内置 | @Retryable / @ConcurrencyLimit 进入框架核心,不用再引 spring-retry |
| JSpecify 空安全 | @Nullable / @NonNull 全面标准化 |
| 原生 API 版本化 | 框架级 REST API Versioning |
| HTTP Interface Client | 自动注册 HTTP 接口客户端 |
| Jackson 3 迁移 | 包名从 com.fasterxml.jackson → tools.jackson(Boot 4.x) |
| AOT / GraalVM 原生镜像成熟 | 启动速度、内存占用大幅优化 |
两个 7.0.8 特有的彩蛋,知道的人很少:
- 7.0.8 是安全修复版 ,一次性修复了 16 个 CVE(SpEL、SSRF、WebSocket 会话 ID、Multipart 走私等),生产环境的
spring-core建议尽快对齐。 - SpEL 操作数默认上限 10,000,超限直接抛异常,防御表达式型 DoS 攻击。需要自定义可以显式指定:
java
// 7.0.8 起:SpEL 默认操作数上限 10,000(防御表达式型 DoS)
SpelParserConfiguration config = new SpelParserConfiguration(
SpelCompilerMode.OFF, null, 50_000); // 自定义 maxOperations
SpelExpressionParser parser = new SpelExpressionParser(config);
另外注意 7.0 移除 的东西:spring-jcl、javax.annotation / javax.inject、Undertow 支持,Jackson 2 已标记弃用------老项目升级时这些都是雷。
3.2 源码模块结构:先抓四个包
Spring Framework 的模块划分长这样:
| 模块 | 作用 | 面试重点 |
|---|---|---|
spring-core |
核心工具类、Resource、类型转换 | Resource、Environment |
spring-beans |
Bean 定义、创建、注入(IoC 实现)⭐ | BeanFactory、DefaultListableBeanFactory |
spring-context |
应用上下文、注解驱动、事件 ⭐ | ApplicationContext、refresh() |
spring-aop |
AOP 核心实现 ⭐ | 动态代理、切面失效 |
spring-expression |
SpEL 表达式 | 条件、缓存表达式 |
spring-tx |
事务管理 ⭐ | @Transactional、事务失效 |
spring-jdbc |
JDBC 封装 | JdbcTemplate、事务同步 |
spring-web / spring-webmvc |
Web 基础与 MVC 框架 | 视岗位而定 |
spring-test |
测试支持 | --- |
读源码时,死死盯住这四个类就够了,它们能串起来,Spring 主干就通了:
text
org.springframework.context.support.AbstractApplicationContext // 容器启动总开关
org.springframework.beans.factory.support.DefaultListableBeanFactory // Bean 注册中心
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator // AOP 代理创建器
org.springframework.transaction.interceptor.TransactionInterceptor // 事务拦截器
3.3 一张图看懂四大深水区的内在关联
这四个主题不是孤立的知识点,而是一根链条上的四个环节:

一句话串联 :IoC 容器启动 → 创建 Bean 时可能遇到循环依赖 → 解决循环依赖要靠三级缓存 → 三级缓存的设计又和 AOP 代理的生成时机紧紧咬合 → 而事务本质是 AOP 的应用。所以循环依赖 + 事务是面试里最容易翻车的组合拳。
面试时能把这条链讲清楚,面试官基本会认可你是真读过源码的。下面逐块拆解。
四、深水区之一:IoC 容器------一切的心脏
4.1 IoC 的本质:图纸、房子、建筑队
初级答法:"控制反转嘛,把对象创建交给 Spring。"
高级答法是这样的:
IoC 的本质,是把"对象的创建、装配、生命周期管理"从业务代码里搬到一个中心化注册表 。你写的
@Component、@Bean,最终都只是往注册表里塞了一条元数据,真正的对象是在refresh()里才被造出来的。
这里有个好用的比喻:BeanDefinition 是图纸,Bean 是房子,BeanFactory 是建筑队。 面试时抛出来,概念一下子就立体了。
顺手把另一个高频问题也解决掉------BeanFactory 和 ApplicationContext 的区别:
| 对比项 | BeanFactory |
ApplicationContext |
|---|---|---|
| 加载策略 | 懒加载,getBean() 才初始化 |
饿加载,启动就初始化所有单例 |
| 功能 | 基础容器 | 扩展了国际化、事件机制、AOP 集成 |
| 定位 | 底层核心 | 上层封装,日常开发实际用的就是它 |
底层核心容器是 DefaultListableBeanFactory,所有 BeanDefinition 的存放地:
java
// org.springframework.beans.factory.support.DefaultListableBeanFactory
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry {
// 存储所有 Bean 的定义元数据
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
// 按注册顺序保存 Bean 名称
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
}
}
✅ 技术亮点 :用
BeanDefinition统一抽象所有 Bean 的元数据,XML、注解、Java Config 三种配置方式最终都输出同一种数据模型------配置与创建彻底解耦。这是 IoC 容器能吃下所有配置格式的根本原因。
4.2 启动总纲:refresh() 的十二步流水线
面试官问"容器启动时做了什么",很多人上来就背"实例化、属性填充、初始化"------但面试官想听的是容器级 的启动流程,也就是 AbstractApplicationContext.refresh():

对应源码(Spring 7.0.8,保留骨架):
java
// AbstractApplicationContext.java
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) { // 并发安全:防止重复刷新
prepareRefresh(); // ①
ConfigurableListableBeanFactory beanFactory =
obtainFreshBeanFactory(); // ②
prepareBeanFactory(beanFactory); // ③
try {
postProcessBeanFactory(beanFactory); // ④ 子类扩展点
invokeBeanFactoryPostProcessors(beanFactory); // ⑤ 🔥 解析配置类
registerBeanPostProcessors(beanFactory); // ⑥ 🔥 注册 BPP
initMessageSource(); // ⑦
initApplicationEventMulticaster(); // ⑧
onRefresh(); // ⑨
registerListeners(); // ⑩
finishBeanFactoryInitialization(beanFactory); // ⑪ 🔥🔥 实例化所有单例
finishRefresh(); // ⑫
} catch (BeansException ex) {
destroyBeans(); // 失败回滚:销毁已创建的 Bean
cancelRefresh(ex);
throw ex;
} finally {
resetCommonCaches(); // 清理公共缓存
}
}
}
十二步不用死记,按"准备 → 工厂 → 后置处理器 → 实例化 → 收尾"五个阶段记。其中三步是深水区:
- 第 ⑤ 步 :
BeanFactoryPostProcessor的主场。ConfigurationClassPostProcessor在这里扫描@ComponentScan、解析@Bean、处理@Import,把所有BeanDefinition注册进容器。MyBatis 的@MapperScan、Spring Boot 的自动装配,全靠这一步入场。 - 第 ⑥ 步 :注册
BeanPostProcessor,包括AutowiredAnnotationBeanPostProcessor和 AOP 的AnnotationAwareAspectJAutoProxyCreator。 - 第 ⑪ 步 :实例化所有非懒加载单例。AOP 代理的创建、循环依赖的解决,全都发生在这一步。
⚠️ 面试加分句 :⑤ 收集图纸,⑥ 装好工具,⑪ 才是真正盖房子。 很多人搞混
@Autowired什么时候生效------它在 ⑥ 注册处理器,在 ⑪ 才真正干活。
这里必须把两个最容易混的扩展点掰开:
| 扩展点 | 操作对象 | 执行时机 | 典型实现 |
|---|---|---|---|
BeanFactoryPostProcessor |
BeanDefinition(还没实例化) | 第 ⑤ 步 | ConfigurationClassPostProcessor、@Configuration 类增强、占位符解析 |
BeanPostProcessor |
Bean 实例(已实例化未初始化) | 第 ⑪ 步每个 Bean 创建时 | @Autowired 注入、AOP 代理创建 |
4.3 Bean 的一生:从裸对象到成品
单个 Bean 的创建链路是 getBean() → doGetBean() → createBean() → doCreateBean(),核心在 doCreateBean():

java
// AbstractAutowireCapableBeanFactory#doCreateBean(Spring 7.0.8 主干)
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// ① 实例化:拿到一个"裸对象"
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
Object bean = instanceWrapper.getWrappedInstance();
// ② 是否允许提前曝光(循环依赖的开关就在这里)
boolean earlySingletonExposure = (mbd.isSingleton()
&& this.allowCircularReferences // Framework 层默认 true
&& isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// ⭐ 放入三级缓存:注意存的是"工厂",不是对象!
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
Object exposedObject = bean;
// ③ 属性填充(这里可能递归去创建 B,从而触发循环依赖)
populateBean(beanName, mbd, instanceWrapper);
// ④ 初始化 + AOP 代理
exposedObject = initializeBean(beanName, exposedObject, mbd);
// ⑤ 兜底校验:如果提前曝光的是代理,这里要对齐
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) { /* 用早期引用替换,保证唯一性 */ }
}
return exposedObject;
}
三个细节值得咂摸:
- 初始化钩子有固定顺序 :Aware 接口 →
@PostConstruct→InitializingBean.afterPropertiesSet()→init-method,销毁同理。顺序混乱的 Bug 基本都是因为没搞清这条链。 addSingletonFactory传的是 lambda(ObjectFactory),只有真的发生循环依赖、需要早期引用时才会被调用------这是"延迟创建代理"的伏笔,第七节细讲。- 构造器注入和属性填充分两步,这一步之差,正是循环依赖"能救/不能救"的分水岭。
⚠️ 高频追问点 :
allowCircularReferences在 Framework 层默认true,但 Spring Boot 从 2.6 起默认设为false(spring.main.allow-circular-references=false)。同一个开关两套默认值,"本地能跑、Boot 里启动失败"的悬案多半源于此。
4.4 三个 "Factory",别再搞混了
| 名字 | 是什么 | 一句话 |
|---|---|---|
BeanFactory |
容器根接口 | 容器的"身份证" |
FactoryBean |
一种特殊的 Bean | 造 Bean 的 Bean ,getObject() 返回真正的产品(&name 拿它自己) |
ObjectFactory |
函数式接口 | 三级缓存里那个"延迟工厂" |
4.5 IoC 技术难点与解决方案
| 技术难点 | 本质原因 | 解决方案 |
|---|---|---|
| BeanDefinition 解析格式不统一 | XML、注解、配置类三种入口 | 统一数据模型,不同解析器输出同一种 BeanDefinition |
| 生命周期钩子顺序混乱 | 回调点太多 | 压缩成四阶段:实例化 → 注入 → 初始化 → 销毁 |
条件装配 @Conditional 判断时机 |
判断必须在实例化前完成 | ConfigurationClassPostProcessor 在第 ⑤ 步提前解析 |
| 初始化顺序问题 | Bean 间隐式依赖复杂 | @DependsOn、ObjectProvider、懒加载 |
| 作用域切换 | Prototype 依赖 Singleton | 每次 getBean() 创建新实例,不走单例缓存 |
| Bean 创建方式多样 | 构造器/工厂方法/FactoryBean | 策略模式 InstantiationStrategy 分派 |
IoC 是地基,接下来登场的 AOP,就是在这个地基上长出来的"替身演员"。
五、深水区之二:AOP------动态代理的"偷梁换柱"
5.1 本质:你 getBean() 拿到的,可能根本不是原始对象
先纠正一个常见误解:Spring AOP 不是编译期织入,也不改字节码(那是 AspectJ 干的)。它干的事只有一件:
在 Bean 初始化完成后,用一个代理对象把原对象"包"起来,放到容器里顶替它。 你
@Autowired拿到的,从来不是new出来的那个对象,而是它的"代理人"。
核心处理器是 AnnotationAwareAspectJAutoProxyCreator------它本质就是一个 BeanPostProcessor,这就是为什么说"AOP 是 IoC 的一个扩展点"。
5.2 代理的诞生地

java
// AbstractAutoProxyCreator.java(Spring 7.0.8)
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// 关键一步:判断是否需要代理,需要就"狸猫换太子"
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// 1. 查找所有匹配的 Advisor(@Aspect 解析出的通知)
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 2. 创建代理对象
Object proxy = createProxy(bean.getClass(), beanName,
specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean; // 没有切面匹配 → 返回原对象
}
注意那个 earlyProxyReferences.remove(cacheKey) != bean 的判断------它防的是"循环依赖场景下代理被创建两次",这个伏笔同样留到第七节收。
5.3 JDK 还是 CGLIB?7.0 起了个大变化
先看决策源码:
java
// DefaultAopProxyFactory#createAopProxy
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (!NativeDetector.inNativeImage()
&& (config.isOptimize() || config.isProxyTargetClass()
|| hasNoUserSuppliedProxyInterfaces(config))) {
Class<?> targetClass = config.getTargetClass();
// 目标类是接口 → 退回 JDK 动态代理
if (targetClass != null && targetClass.isInterface()
&& !Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config); // CGLIB:生成目标类的子类
}
return new JdkDynamicAopProxy(config);
}
两种代理方式的对比,这张表建议直接存手机里:
| 对比项 | JDK 动态代理 | CGLIB |
|---|---|---|
| 原理 | 反射,实现目标类接口 | ASM 字节码生成,继承目标类 |
| 要求 | 目标类必须实现接口 | 可代理普通类,但不能代理 final 类/方法 |
| 性能 | 生成快,调用略快 | 生成慢,执行快 |
| 限制 | 只能拦截接口方法 | 可拦截非 final 的 public/protected 方法 |
| 7.x 地位 | 需显式 @Proxyable(INTERFACES) |
全局默认 ⭐ |
Spring 7.0 的重要变化 :官方 Release Notes 写得很直白------"As of 7.0, global proxy type defaulting to CGLIB --- like in Spring Boot --- is consistently applied to all proxy processors" 。以前 Boot 默认 CGLIB、但原生 Spring 的某些处理器(比如 @Async)行为不统一,7.0 起全站统一默认 CGLIB。
另外,CGLIB 已被 Spring 重写并内嵌到 spring-core(org.springframework.cglib 包),不再需要额外引依赖,字节码生成性能也大幅优化。
想给某个 Bean 单独退回 JDK 代理,用 7.0 的新注解:
java
@Bean
@Proxyable(INTERFACES) // 7.0 新注解:单个 Bean 级别的代理策略
public OrderService orderService() { return new OrderServiceImpl(); }
@Bean
@Proxyable(interfaces = MyService.class) // 甚至能指定用哪些接口
public MyService myService() { return new MyServiceImpl(); }
🧠 面试话术 :"7.0 把代理策略统一了,从'各处不一致'变成'全局默认 CGLIB +
@Proxyable单点退出'。"这一句,胜过背十遍 JDK 和 CGLIB 的区别。
5.4 洋葱模型:拦截器链的递归艺术
代理对象拿到手之后,方法调用是怎么被层层拦截的?核心是 ReflectiveMethodInvocation.proceed() 的递归:
java
// ReflectiveMethodInvocation#proceed(责任链的经典实现)
public Object proceed() throws Throwable {
// 所有拦截器执行完毕,调用目标方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint(); // 反射调用真实方法
}
Object interceptor = this.interceptorsAndDynamicMethodMatchers
.get(++this.currentInterceptorIndex);
// ⭐ 递归调用自己,形成"洋葱模型"
return interceptor.invoke(this);
}
再看 JDK 代理侧的调用入口,逻辑是一样的:
java
// JdkDynamicAopProxy#invoke
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 获取当前方法的拦截器链(通知链)
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
if (chain.isEmpty()) {
// 无通知,直接反射调用目标方法
return AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
// 通过责任链模式依次执行拦截器
MethodInvocation invocation =
new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
return invocation.proceed();
}

洋葱模型:外层事务开启 → 中层日志记录 → 内层权限校验 → 目标方法 → 层层返回 → 外层提交/回滚。事务、缓存、异步、重试,全是插在这同一条链上的。
✅ 技术亮点:责任链模式实现通知链,多个切面可以灵活组合、动态增删;代理创建与 Bean 生命周期无缝结合,业务代码零侵入。
多个切面的执行顺序靠 @Order、Ordered、PriorityOrdered 控制,数值越小优先级越高。通知的大致执行顺序:Before → Around → 目标方法 → After → AfterReturning。
5.5 自调用失效:最经典的坑,没有之一
实际开发中我们经常遇到这种情况------切面明明写了,同类内部一调用就不生效:
java
@Service
public class OrderService {
public void createOrder() {
this.pay(); // ❌ 这里是 this,不是代理!事务不会开启
}
@Transactional
public void pay() { ... }
}

根因 :代理是包装 而非替换 ,this 指向的还是原始对象。this.pay() 走的是目标对象内部的直接调用,压根没经过代理,拦截器链自然不触发。
三种解法,按推荐度排序:
java
// ✅ 方案 A(最推荐):拆到另一个类,让调用天然走代理
@Service
class PayService { @Transactional public void pay() {...} }
// ✅ 方案 B:注入自己(注入的是代理),有点别扭但有效
@Service
class OrderService {
@Autowired OrderService self;
public void createOrder() { self.pay(); }
}
// ⚠️ 方案 C:AopContext 暴露代理,需要配置 exposeProxy=true,有侵入
((OrderService) AopContext.currentProxy()).pay();
| 方案 | 说明 | 推荐程度 |
|---|---|---|
| 拆分方法到不同 Bean | 最干净,顺带解耦 | ⭐⭐⭐⭐⭐ |
| 注入自身代理对象 | 可解决,但略侵入 | ⭐⭐⭐ |
AopContext.currentProxy() |
需开启 exposeProxy |
⭐⭐⭐ |
| 手动从容器 getBean | 破坏结构,不推荐 | ⭐⭐ |
5.6 AOP 技术难点与解决方案
| 技术难点 | 本质原因 | 解决方案 |
|---|---|---|
| 同类自调用失效 | this 指向原始对象,绕过代理 |
拆类 / 注入自身 / AopContext |
| 多切面顺序不可控 | 默认顺序不确定 | @Order / Ordered / PriorityOrdered |
| final / private 方法无法增强 | CGLIB 无法覆写 final;非 public 拦不到 | 改 public 非 final,或换 AspectJ 编译期织入 |
| 循环依赖中代理需提前生成 | 早期引用必须是代理形态 | 三级缓存 ObjectFactory 提前生成代理(见第七节) |
| 动态切入点 | 运行时判断是否匹配 | DynamicMethodMatcher |
| 序列化后代理丢失 | 反序列化还原成原始对象 | 实现 Serializable + AOP 序列化支持 |
| 嵌套代理性能 | 多层代理叠加开销 | ExposingInvocationInterceptor 暴露调用上下文 |
AOP 讲完,它的"头号客户"------事务------就该登场了。开头那道自调用面试题的答案,就藏在下一节。
六、深水区之三:事务------AOP 最赚钱的一个应用
6.1 一句话本质
@Transactional = 一个环绕通知(Around Advice)。 它不是魔法,就是代理拦截:
text
@Transactional = Spring AOP + TransactionInterceptor + PlatformTransactionManager
核心三要素:
| 要素 | 类 | 职责 |
|---|---|---|
| 事务管理器 | PlatformTransactionManager |
真正干活的:开启、提交、回滚 |
| 事务属性 | TransactionDefinition |
传播行为、隔离级别、超时、回滚规则 |
| 事务拦截器 | TransactionInterceptor |
AOP 方法拦截器,织入事务逻辑 |
再加一个运行时状态 TransactionStatus(setRollbackOnly() 就挂在它上面),事务的骨架就齐了。
生效链路一图流:

6.2 事务执行链路:源码证据

java
// TransactionInterceptor#invoke
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Class<?> targetClass = (invocation.getThis() != null
? AopUtils.getTargetClass(invocation.getThis()) : null);
// 核心:以事务方式执行目标方法
return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}
// TransactionAspectSupport#invokeWithinTransaction(主干)
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {
// ① 解析 @Transactional 的属性(传播行为、隔离级别)
TransactionAttributeSource tas = getTransactionAttributeSource();
final TransactionAttribute txAttr = (tas != null
? tas.getTransactionAttribute(method, targetClass) : null);
// ② 确定事务管理器
final TransactionManager tm = determineTransactionManager(txAttr);
PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
// ③ 开启事务(获取连接、关闭自动提交、绑定到线程)
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, "...");
Object retVal;
try {
retVal = invocation.proceedWithInvocation(); // ④ 执行业务方法
} catch (Throwable ex) {
completeTransactionAfterThrowing(txInfo, ex); // ⑤ 异常 → 回滚 or 提交
throw ex;
} finally {
cleanupTransactionInfo(txInfo); // ⑥ 清理 ThreadLocal
}
commitTransactionAfterReturning(txInfo); // ⑦ 正常 → 提交
return retVal;
}
而事务的"底层真相",一句话就能戳破:
DataSourceTransactionManager.doBegin()最终做的就是con.setAutoCommit(false),然后把这条连接绑定到TransactionSynchronizationManager的 ThreadLocal 里,让同一线程的所有 DAO 共享同一条连接。
回到开头那道面试题 :事务生效的前提是"通过代理对象调用"。方法 A 里写 this.methodB(),this 是原始对象,根本没经过 TransactionInterceptor------事务自然失效。✅ 解答完毕。
6.3 事务管理器家族
text
PlatformTransactionManager(接口)
└─ AbstractPlatformTransactionManager(抽象实现)
├─ DataSourceTransactionManager ← 最常用(JDBC / MyBatis)
├─ JpaTransactionManager ← JPA
├─ HibernateTransactionManager ← Hibernate
└─ ResourceLocalTransactionManager ← 非 JTA
总入口 getTransaction() 的分支非常清晰:
java
// AbstractPlatformTransactionManager#getTransaction
public final TransactionStatus getTransaction(TransactionDefinition definition) {
Object transaction = doGetTransaction(); // 1. 获取当前事务对象
if (isExistingTransaction(transaction)) {
return handleExistingTransaction(definition, transaction); // 2. 有事务 → 按传播行为处理
}
return startTransaction(definition, transaction); // 3. 没事务 → 按传播行为新建
}
6.4 传播行为:7 种,但真正要啃透的是 3 个
先看决策树:

核心三兄弟对比(面试必背表):
| 对比维度 | REQUIRED | REQUIRES_NEW | NESTED |
|---|---|---|---|
| 是否开新事务 | 没有才开 | 始终开新事务 | 在已有事务内建 Savepoint |
| 与外层关系 | 共享同一事务 | 完全独立,外层挂起 | 嵌套在外层内 |
| 自己回滚时 | 外层也回滚 | 外层不受影响 | 仅回滚到 Savepoint |
| 外层回滚时 | 自己也回滚 | 自己不受影响 | 自己也回滚 |
| 实现机制 | 同一连接 | 新连接 | JDBC Savepoint |
一句话记忆法:REQUIRED 同生共死、REQUIRES_NEW 各自为政、NESTED 内外有别。
使用场景上:绝大部分业务用 REQUIRED 就够了;日志、审计这类旁路逻辑用 REQUIRES_NEW 保证独立提交;需要"部分回滚"的批量流程才考虑 NESTED。
分支处理的源码很有观赏性:
java
// AbstractPlatformTransactionManager#handleExistingTransaction(精简)
switch (definition.getPropagationBehavior()) {
case PROPAGATION_NEVER:
throw new IllegalTransactionStateException("存在事务,但传播行为是 NEVER");
case PROPAGATION_NOT_SUPPORTED:
Object suspended = suspend(transaction); // 挂起,非事务执行
return prepareTransactionStatus(definition, null, false, ...);
case PROPAGATION_REQUIRES_NEW:
SuspendedResourcesHolder holder = suspend(transaction); // ⭐ 挂起
return startTransaction(definition, transaction, ..., holder); // ⭐ 新连接开新事务
case PROPAGATION_NESTED:
if (useSavepointForNestedTransaction()) {
DefaultTransactionStatus status = prepareTransactionStatus(...);
status.createAndHoldSavepoint(); // ⭐ Savepoint 部分回滚
return status;
}
default: // REQUIRED / SUPPORTS
return prepareTransactionStatus(definition, transaction, false, ...); // 加入
}
🔑 技术亮点 :"挂起(suspend)"不是魔法,本质是把当前连接塞进
SuspendedResourcesHolder保存,再去连接池拿一条新连接 。所以REQUIRES_NEW在循环里滥用会把连接池打爆------1000 条记录就是 1000 次取新连接。
顺带回答一个深水区追问:"为什么 NESTED 会依赖数据库?"------因为它用 JDBC Savepoint 实现部分回滚,得驱动和数据库都支持;而 REQUIRES_NEW 是独立连接独立事务,天然隔离,代价是连接开销。
6.5 ThreadLocal:事务的底层地基
事务状态全部存在 TransactionSynchronizationManager 的 ThreadLocal 里:
java
// TransactionSynchronizationManager 核心字段
private static final ThreadLocal<Map<Object, Object>> resources =
new NamedThreadLocal<>("Transactional resources"); // DataSource → Connection
private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
new NamedThreadLocal<>("Transaction synchronizations"); // 事务同步器
private static final ThreadLocal<String> currentTransactionName =
new NamedThreadLocal<>("Current transaction name");
private static final ThreadLocal<Boolean> currentTransactionActive =
new NamedThreadLocal<>("Current transaction active");
⚠️ 这就解释了一个高频事故 :
@Transactional方法里开新线程、或者方法加了@Async,事务会断------子线程拿不到主线程 ThreadLocal 里的 Connection 。事务边界内不要开线程;确需异步,用事务事件(TransactionSynchronization)或给异步方法单独开事务,跨线程场景可考虑TaskDecorator+TransmittableThreadLocal传递上下文。
6.6 事务失效:一张分类图 + 八大场景
别像报菜名一样乱猜,先给分类框架,才像高手:

| # | 失效场景 | 原因 | 解决方案 |
|---|---|---|---|
| 1 | 同类自调用 | this 调用绕过代理 |
拆类 / 注入自身 / AopContext.currentProxy() |
| 2 | 方法非 public |
Spring AOP 默认只拦截 public | 改 public,或 AspectJ 编译期织入 |
| 3 | final 类/方法 |
CGLIB 无法覆写 | 去掉 final |
| 4 | 异常被 catch 吞掉 | 拦截器感知不到异常 | 手动 throw 或 setRollbackOnly() |
| 5 | 受检异常不回滚 | 默认只回滚 RuntimeException / Error |
rollbackFor = Exception.class |
| 6 | 传播行为配错 | NOT_SUPPORTED / NEVER 挂起或禁用事务 |
检查 propagation 配置 |
| 7 | 类没被 Spring 管理 | 没加 @Service 等注解,没有代理 |
确保类被扫描到 |
| 8 | 数据库引擎不支持 | MyISAM 不支持事务 | 改用 InnoDB |
| 9 | 多线程 / @Async |
事务绑定 ThreadLocal,子线程拿不到连接 | 事务内不开线程,异步单独开事务 |
其中三个坑值得单独展开,都是我或读者在生产上真金白银踩过的。
坑一:受检异常默认不回滚。 源码写得明明白白:
java
// DefaultTransactionAttribute#rollbackOn
public boolean rollbackOn(Throwable ex) {
return (ex instanceof RuntimeException || ex instanceof Error);
}
java
@Transactional
public void pay() throws IOException {
// ❌ 抛 IOException,事务照样提交!
}
// ✅ 正解:
@Transactional(rollbackFor = Exception.class)
坑二:异常被吞,提交时反手一个 UnexpectedRollbackException。 这个坑最阴:
java
@Transactional
public void outer() {
userMapper.insert(user);
try {
orderService.createOrder(order); // 内部抛异常 → 事务已被标记 rollbackOnly
} catch (Exception e) {
log.error("订单失败,先不管它", e); // 以为没事了......
}
} // 提交时 Spring 发现 rollbackOnly=true,整单回滚并抛 UnexpectedRollbackException
根因:子方法抛异常时,Spring 已经把事务标记为 rollbackOnly。你的 catch 只是拦住了业务异常,拦不住事务标记 。解法:改 REQUIRES_NEW 独立事务、改 NESTED 做 Savepoint 部分回滚,或者干脆别 catch、让异常自然传播。
坑三:REQUIRES_NEW 循环调用耗尽连接池。
java
@Transactional
public void processBatch() {
for (Item item : items) {
logService.record(item); // 1000 条 = 1000 次取新连接 💥
}
}
解法:批量化、异步记录,或缩短事务持有时间------把 IO/计算类操作挪到事务外,事务只包住真正要原子提交的那几步。
6.7 7.0 新坑:@Retryable × @Transactional 的顺序
7.0 把重试能力内置进了核心(org.springframework.core.retry 包,注解 @Retryable、@ConcurrencyLimit,用 @EnableResilientMethods 开启):
java
@Configuration
@EnableResilientMethods // 7.0 新:不用再引 spring-retry
class ResilienceConfig {}
@Service
class PayClient {
// 默认:任意异常重试,最多 3 次重试(共 4 次调用),间隔 1s
@Retryable(includes = {SocketTimeoutException.class}, maxRetries = 4,
delay = 100, multiplier = 2, maxDelay = 1000, jitter = 50)
public void charge(Order order) { ... }
}
⚠️ 面试陷阱 :重试如果发生在事务方法内部 ,事务已经回滚了才重试,纯属白忙。 ✅ 正确姿势:重试包在事务外面 (@Retryable 的切面顺序在事务切面之外),或者把远程调用拆成独立 Bean。
记住一句:先决定"要不要重做整件事",再决定"要不要开事务"。
6.8 推荐写法与最佳实践
java
@Transactional(
rollbackFor = Exception.class,
timeout = 30,
isolation = Isolation.READ_COMMITTED
)
public void transfer(Long fromUserId, Long toUserId, BigDecimal amount) {
// 业务逻辑
}
两条铁律:事务注解不要滥用,事务范围越小越好。 长事务(事务里包 RPC、MQ、复杂计算)是连接池杀手,该异步的异步,该拆的拆,必要时用本地消息表做最终一致性。
事务讲透之后,我们把最后一块、也是区分度最高的一块拼图补上------循环依赖。
七、深水区之四:循环依赖------三级缓存的光影魔法
7.1 问题本身
java
@Component
public class AService {
@Resource
private BService bService;
}
@Component
public class BService {
@Resource
private AService aService;
}
A 依赖 B,B 依赖 A。创建 A → 需要 B → 创建 B → 需要 A → A 正在创建中 → 死循环。鸡生蛋蛋生鸡,Spring 用三级缓存解套。
7.2 三级缓存的结构:就是三个 Map,没有魔法
核心类 DefaultSingletonBeanRegistry:
| 层级 | 字段名 | 存的是什么 | 状态 |
|---|---|---|---|
| 一级 | singletonObjects |
成品 Bean | 完整初始化 ✅ |
| 二级 | earlySingletonObjects |
早期引用(半成品,可能已被代理) | 已实例化,未填充属性 🚧 |
| 三级 | singletonFactories |
ObjectFactory 工厂 |
能按需造出早期引用 🏭 |
java
// DefaultSingletonBeanRegistry.java(Spring 7.0.8)
/** 一级缓存:成品 Bean(完整生命周期的对象) */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** 二级缓存:早期 Bean(实例化完成但未完成属性填充/初始化的半成品) */
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
/** 三级缓存:对象工厂(延迟生成早期引用,支持 AOP 代理场景) */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
7.3 A ↔ B 的完整时序(建议背图)

对应的查找逻辑 getSingleton():
java
// DefaultSingletonBeanRegistry#getSingleton(Spring 7.0.8)
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 1. 查一级缓存(成品)
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 2. 查二级缓存(半成品)
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) { // 双重检查锁
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 3. 查三级缓存 → 执行 ObjectFactory 生成早期引用
ObjectFactory<?> singletonFactory =
this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// 升级到二级缓存,三级缓存移除
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}

另外,singletonsCurrentlyInCreation 集合负责死循环防护------构造器环就是被它检测出来并抛出 BeanCurrentlyInCreationException 的。
7.4 灵魂拷问:为什么必须是三级?二级不行吗?
这是整场面试的分水岭。很多文章只说结论,不讲代价。我们用一个具体场景推演。
假设只有二级缓存 ,实例化后直接存原始对象 B@123:
text
步骤1:实例化 B → 原始对象 B@123
步骤2:把 B@123 放入二级缓存
步骤3:B 填充属性,需要 A
步骤4:A 实例化 → 填充属性,从二级缓存拿到 B@123
步骤5:A 初始化完成,持有 B@123
步骤6:B 继续初始化 → 执行 AOP 后置处理 → 生成代理对象 B$Proxy@456
步骤7:B 初始化完成,放入一级缓存 → B$Proxy@456
❌ 问题:A 里持有的是 B@123(原始对象),不是 B$Proxy@456(代理对象)
❌ 后果:事务失效!AOP 增强失效!容器里出现同一个 Bean 的两个身份!
三级缓存的解法 ------存的是 ObjectFactory 而非实例:
text
步骤1:实例化 B → 原始对象 B@123
步骤2:把 ObjectFactory 放入三级缓存
factory = () -> getEarlyBeanReference("b", mbd, B@123)
步骤3:B 填充属性,需要 A;A 填充属性,需要 B
步骤4:查三级缓存 → 执行 factory → 判断是否需要代理 → 生成 B$Proxy@456
放入二级缓存,返回给 A
步骤5:A 持有的是 B$Proxy@456 ✅
步骤6:B 继续初始化,AOP 后置处理时发现已提前代理过 → 复用,不再重复创建
工厂回调的核心代码:
java
// AbstractAutowireCapableBeanFactory#getEarlyBeanReference
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (SmartInstantiationAwareBeanPostProcessor bp :
getBeanPostProcessorCache().smartInstantiationAware) {
exposedObject = bp.getEarlyBeanReference(exposedObject, beanName); // AOP 在这里提前代理
}
}
return exposedObject;
}
// AbstractAutoProxyCreator ------ 用 earlyProxyReferences 保证"只代理一次"
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyProxyReferences.put(cacheKey, bean); // 打标记:我提前代理过了
return wrapIfNecessary(bean, beanName, cacheKey);
}
public Object postProcessAfterInitialization(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// ⭐ 如果之前提前代理过,remove 返回非 null,就不再重复代理
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
return bean;
}
看到没有,第五节 5.2 里那个 earlyProxyReferences.remove() 的判断,伏笔在这里收回------它和三级缓存是一对咬合的齿轮。
面试标准回答(背这段就够了):
🧠 二级缓存能解决普通对象的循环依赖,但解不了 AOP 场景。如果提前暴露原始对象,后续生成的代理对象和早期引用不一致,注入方拿到的 Bean 就丢了 AOP 增强。三级缓存存的是 ObjectFactory,核心价值是延迟生成代理 ------把"何时生成代理"的决定权推迟到真正被需要的那一刻:不需要代理,工厂返回原始对象;需要代理,工厂返回代理对象,并用
earlyProxyReferences保证代理只造一次。这样既解决了循环依赖,又不破坏"AOP 在初始化后织入"的设计原则,还省掉了所有 Bean 提前做代理判断的开销。
✅ 技术亮点:三级缓存设计完美兼容普通 Bean 和 AOP 代理 Bean 的循环依赖;延迟生成代理对象,只有真正发生循环依赖时才提前创建------这是"空间换时间 + 延迟创建"思想的教科书级示范。
7.5 哪些循环依赖,三级缓存也救不了?
| 场景 | 能否解决 | 原因 |
|---|---|---|
| 单例 setter / 字段注入 | ✅ | 可提前暴露早期引用 |
| 构造器注入的环 | ❌ | 对象还没 new 出来,没东西可提前曝光,直接抛 BeanCurrentlyInCreationException |
| prototype 作用域 | ❌ | 多例 Bean 不走单例缓存,每次 getBean() 都新建,无缓存可依 |
@Async 标记的 Bean |
⚠️ 可能报错 | 异步代理的创建时机特殊,非 SmartInstantiationAwareBeanPostProcessor,早期对象和最终代理可能不一致 |
报错长这样,眼熟一下:
text
BeanCurrentlyInCreationException:
Requested bean is currently in creation: Is there an unresolvable circular reference?
还有一个版本提醒 ,很多人栽在这:从 Spring Boot 2.6 起,循环依赖默认就是禁止的 (spring.main.allow-circular-references=false),Spring Framework 7.0.8 / Boot 4.x 延续了这个默认。也就是说------三级缓存是兜底机制,工程上应该靠重构消灭循环依赖,而不是靠开关续命。
7.6 工程解法:按优先级排排坐
面试官最想听的不是"开配置",而是工程判断:
text
🥇 重构依赖方向(抽第三个 Bean / 改事件驱动) ← 唯一"正确"解
🥈 @Lazy 打断创建时序 ← 应急止血
🥉 Setter 注入 ← 老项目兼容
🏅 开 spring.main.allow-circular-references ← 创可贴,别当药吃
java
// 🥈 @Lazy 示例:注入的是代理,首次调用时才解析真实 Bean
@Service
class OrderService {
private final PayService payService;
OrderService(@Lazy PayService payService) { this.payService = payService; }
}
// 🥇 事件解耦示例:依赖方向彻底打断
@Service
class OrderService {
private final ApplicationEventPublisher publisher;
void create() { publisher.publishEvent(new OrderCreatedEvent(id)); }
}
八、技术难点 × 解决方案总表(收藏级)
把四大深水区的坑汇总成一张表,面试前扫一遍:
| # | 技术难点 | 典型现象 | 根因 | 解决方案 |
|---|---|---|---|---|
| 1 | 循环依赖与 AOP 交织 | 注入的是原始对象而非代理 | 早期引用与最终代理不是同一对象 | 三级缓存 ObjectFactory + earlyProxyReferences 去重 |
| 2 | 构造器注入的环 | BeanCurrentlyInCreationException |
实例化前无法曝光引用 | @Lazy / 事件解耦 / 抽第三个 Bean |
| 3 | 事务自调用失效 | this.xxx() 事务不生效 |
绕过代理,拦截器链未触发 | 拆类 / 注入自身代理 / AopContext |
| 4 | 受检异常不回滚 | 抛 checked 异常却提交了 | 默认只回滚 RuntimeException/Error |
rollbackFor = Exception.class |
| 5 | 异常被吞 | 提交时抛 UnexpectedRollbackException |
rollbackOnly 标记已设置 |
REQUIRES_NEW / NESTED / 别 catch |
| 6 | 连接池耗尽 | 线程卡在取连接 | REQUIRES_NEW 循环取新连接 |
批量化 / 异步化 / 缩小事务范围 |
| 7 | 代理方式选择 | 注入时类型不匹配 | JDK 代理只能转成接口类型 | 7.x 默认 CGLIB;@Proxyable 显式指定 |
| 8 | final / private 无法增强 | AOP 完全不生效 | CGLIB 无法覆写;非 public 拦不到 | 改 public 非 final,或 AspectJ 织入 |
| 9 | 异步/多线程事务断裂 | 子线程操作不在事务里 | 事务状态绑在 ThreadLocal | 事务边界内不开线程;用事务事件 |
| 10 | BPP 顺序问题 | 某些增强莫名没生效 | 后置处理器顺序决定覆盖关系 | 实现 Ordered / 用 @Order |
| 11 | 循环引用开关分歧 | 本地能跑,Boot 启动失败 | Framework 默认 true,Boot 2.6+ 默认 false | 用重构治理,别靠开关兜底 |
| 12 | 重试与事务边界 | 重试发生在回滚之后 | 切面顺序错误 | 重试包在事务外层;远程调用拆独立 Bean |
| 13 | 长事务 | 连接长时间不释放 | 事务里包 RPC/MQ/复杂计算 | 缩小事务范围,异步化,本地消息表 |
| 14 | 初始化顺序问题 | Bean 隐式依赖复杂 | 创建顺序不可控 | @DependsOn、ObjectProvider、懒加载 |
九、源码到底该怎么读?避坑指南 + 30 天路线
9.1 先避开这五个坑
| # | 难点 | 解法 |
|---|---|---|
| 1 | 源码百万行,不知从哪看起 | ❌ 别通读!✅ 每次只带一个问题,比如"@Autowired 怎么注入的",从断点 DefaultListableBeanFactory#doResolveDependency 进入 |
| 2 | 编译环境搭不起来(7.0.8 要求 JDK 17+,Gradle 构建) | JDK 直接上 21;git clone 后 ./gradlew :spring-core:compileJava 只编译核心模块,别全量构建 |
| 3 | 网上资料都是 5.x,版本对不上 | 认准本地 7.0.8 源码为唯一标准;核心机制 5→7 稳定,博客思路可参考,行号别信 |
| 4 | 看懂了,三天就忘 | 费曼学习法:看完一讲就画图/写笔记输出,关掉文章自己重画一遍 |
| 5 | 断点一打,跳来跳去迷路 | 只在骨架方法打断点(refresh、doGetBean、doCreateBean),配合调用栈看"我在哪、要去哪" |
9.2 一条主线、两个对象、三个断点、四个问题
一条主线(顺着它钻,80% 的问题会自己撞上来):
text
refresh() → obtainFreshBeanFactory() → invokeBeanFactoryPostProcessors()
→ registerBeanPostProcessors() → finishBeanFactoryInitialization()
→ preInstantiateSingletons() → getBean() → doGetBean()
→ createBean() → doCreateBean()
两个核心对象 :BeanDefinition(图纸)和 BeanFactory(建筑队)。
三个断点:
java
AbstractApplicationContext#refresh
DefaultSingletonBeanRegistry#getSingleton
AbstractAutoProxyCreator#postProcessAfterInitialization
四个问题驱动 :@Component 是怎么被扫描的?@Autowired 是在哪个阶段注入的?@Transactional 是怎么变成代理的?循环依赖时,A 和 B 谁先创建?
9.3 30 天路线图(照着走就行)
| 阶段 | 时间 | 干什么 | 验收标准 |
|---|---|---|---|
| 第 1 周 | D1--D7 | 手写一个迷你 IoC:BeanDefinition + getBean + 三级缓存 |
能讲清 refresh() 12 步 |
| 第 2 周 | D8--D14 | 跟一遍 doCreateBean,断点看 populateBean |
能说出 Bean 的 5 个生命周期节点 |
| 第 3 周 | D15--D21 | 手写 JDK/CGLIB 代理各一个;跟 DefaultAopProxyFactory |
能解释"为什么两级缓存不行" |
| 第 4 周 | D22--D30 | 跟 TransactionInterceptor;复现事务失效场景 |
能徒手列出失效清单并给解药 |
🧑🏫 方法建议 :不要从头到尾读。用一个问题当钩子,顺着调用栈往下钻 3 层就回来。 每读一个流程画一张图,再写个 Demo 验证(比如自调用失效),比看十遍书都管用。
9.4 面试回答模板:五步法
遇到 Spring 原理题,按这个结构组织答案,稳拿高分:
- 先给结论:"这个技术的本质是......"
- 再说核心流程:"核心流程分为 X 步......"
- 关键设计点:"最精妙的设计是......(比如三级缓存为什么是三级)"
- 常见问题/坑点:"实际使用中要注意......(比如事务失效场景)"
- 版本差异(加分项):"Spring 7.0 做了 XX 优化......"
如果面试官让你"用五分钟把四块串一遍",可以这样说:
IoC :容器启动时把配置读成
BeanDefinition,refresh()第 ⑪ 步走"实例化 → 属性填充 → 初始化",扩展点全在BeanPostProcessor里,AOP 也是其中之一。 AOP :AbstractAutoProxyCreator在初始化后生成代理,调用时走拦截器责任链的递归(洋葱模型),事务、缓存、异步都是链上的一环。 事务 :@Transactional本质是TransactionInterceptor拦截,落到doBegin()就是setAutoCommit(false)加 ThreadLocal 绑定连接。传播行为 7 种,重点 REQUIRED(同生共死)、REQUIRES_NEW(各自为政)、NESTED(Savepoint 部分回滚)。最大的坑是自调用失效和rollbackOnly标记。 循环依赖:靠三级缓存暴露早期引用,工厂 lambda 保证 AOP 场景正确;但 Boot 2.6 之后默认禁用,工程上应该重构而不是依赖它。
最后附一份深水区高频追问清单,先自测一下:
| 主题 | 初级问法 | 深水区追问 |
|---|---|---|
| IoC | 什么是控制反转? | BeanFactory vs ApplicationContext?BFPP 和 BPP 的执行时机? |
| 生命周期 | Bean 生命周期说一遍 | @PostConstruct、afterPropertiesSet、init-method 三者顺序?AOP 代理创建发生在哪一步之后? |
| 循环依赖 | 什么是循环依赖? | 三级缓存各自存什么?为什么第三级必须存在?构造器注入为什么解不了?@Async + 循环依赖为什么报错? |
| AOP | JDK 和 CGLIB 区别? | @Transactional 自调用失效原理?拦截器链的顺序怎么排的? |
| 事务 | 传播机制有哪几种? | REQUIRED 嵌套调用如何共用一个连接?只读事务底层做了什么?多线程下事务为什么失效? |
十、写在最后
把全文浓缩成一句话:
🔥 IoC 管"怎么造",AOP 管"怎么包",事务是 AOP 最赚钱的一个应用,循环依赖是这两条线打结的地方。
四件事串成一条链,任何追问都不怕。
落到行动上,给你三条建议:
- 别背代码,背链路。面试要的是你能把结论还原成调用链,不是复读行号。
- 带着问题读源码 ,断点打在
doCreateBean和getSingleton上,80% 的疑惑会自己消散。 - 工程上主动消灭循环依赖和长事务------机制是兜底,设计才是本事。
八股是别人的答案,源码是你自己的答案。
这是《Spring 7.0.8 源码解读》系列的第 0 篇(准备篇),下一篇我们正式进入 IoC 容器启动篇 :从 AnnotationConfigApplicationContext 一行 new 出发,把 refresh() 十二步逐行拆开,再手写一个 200 行的迷你容器。这个系列会一章一章往源码深处钻,感兴趣的话点个关注,更新不迷路~
最后留个互动问题,很好回答:
你被 @Transactional 坑过吗?是自调用失效、异常不回滚,还是更离谱的场景?评论区聊聊你踩坑的现场,点赞最高的那个,我下一篇就拆它的源码。
觉得有用的话,点赞 + 在看,转发给那个正在背"三级缓存"的同事。👋