别再死背"三级缓存"了!拿 Spring 7.0.8 源码,把 IoC、AOP、事务、循环依赖四大深水区一次蹚平

版本基线: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 特有的彩蛋,知道的人很少:

  1. 7.0.8 是安全修复版 ,一次性修复了 16 个 CVE(SpEL、SSRF、WebSocket 会话 ID、Multipart 走私等),生产环境的 spring-core 建议尽快对齐。
  2. 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;
}

三个细节值得咂摸:

  1. 初始化钩子有固定顺序 :Aware 接口 → @PostConstruct → InitializingBean.afterPropertiesSet() → init-method,销毁同理。顺序混乱的 Bug 基本都是因为没搞清这条链。
  2. addSingletonFactory 传的是 lambda(ObjectFactory),只有真的发生循环依赖、需要早期引用时才会被调用------这是"延迟创建代理"的伏笔,第七节细讲。
  3. 构造器注入和属性填充分两步,这一步之差,正是循环依赖"能救/不能救"的分水岭。

⚠️ 高频追问点 :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 原理题,按这个结构组织答案,稳拿高分:

  1. 先给结论:"这个技术的本质是......"
  2. 再说核心流程:"核心流程分为 X 步......"
  3. 关键设计点:"最精妙的设计是......(比如三级缓存为什么是三级)"
  4. 常见问题/坑点:"实际使用中要注意......(比如事务失效场景)"
  5. 版本差异(加分项):"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 最赚钱的一个应用,循环依赖是这两条线打结的地方。

四件事串成一条链,任何追问都不怕。

落到行动上,给你三条建议:

  1. 别背代码,背链路。面试要的是你能把结论还原成调用链,不是复读行号。
  2. 带着问题读源码 ,断点打在 doCreateBean 和 getSingleton 上,80% 的疑惑会自己消散。
  3. 工程上主动消灭循环依赖和长事务------机制是兜底,设计才是本事。

八股是别人的答案,源码是你自己的答案。

这是《Spring 7.0.8 源码解读》系列的第 0 篇(准备篇),下一篇我们正式进入 IoC 容器启动篇 :从 AnnotationConfigApplicationContext 一行 new 出发,把 refresh() 十二步逐行拆开,再手写一个 200 行的迷你容器。这个系列会一章一章往源码深处钻,感兴趣的话点个关注,更新不迷路~

最后留个互动问题,很好回答:

你被 @Transactional 坑过吗?是自调用失效、异常不回滚,还是更离谱的场景?评论区聊聊你踩坑的现场,点赞最高的那个,我下一篇就拆它的源码。

觉得有用的话,点赞 + 在看,转发给那个正在背"三级缓存"的同事。👋

相关推荐
H H.21 分钟前
Java企业级开发:从框架到工程化实战
java·开发语言·经验分享·其他·课程设计
wno70421 分钟前
springboot整合FastDFS
java·spring boot·后端
顧棟1 小时前
组件生命周期设计:从硬编码初始化到状态机
java·ide
程序猿DD7 小时前
OctaFuse 2.20.0:MCP 用业务账号直接登录授权,请求日志合并工具调用
后端
特立独行的猫A9 小时前
别再用 nohup 了:让应用在后台常驻的正确姿势与 systemd 服务详解
java·后端·python
一起_java9 小时前
技术文章-基于Dify-Agent的智能问答系统设计与实现
java·spring boot·后端·agent·dify
码事漫谈10 小时前
2027年火的很可能是AI工作台
后端
Flynn Liang11 小时前
I/O 密集型高并发实战:Java 服务 10 维优化,从线程打满到 10 万 QPS
java·spring boot·性能优化·高并发·系统设计·虚拟线程·io密集型
吃我一窝jio12 小时前
Python与Go线程模型深度对比
java·开发语言·python