Spring 核心原理与实战:IoC 容器、Bean 生命周期、循环依赖与 AOP 事务

本文聚焦 Spring Framework 内核(容器与 AOP),是框架”地基”层。三处边界先说清楚:① @Transactional 背后的数据库 MVCC、锁、隔离级别实现见《MySQL 事务与锁机制》,本文只讲 Spring 如何声明式编排事务;② Spring Boot 的自动装配与手写 Starter 见《SpringBoot 自定义 Starter》,本文讲被装配出来的容器本身;③ JDK 动态代理的语言层字节码原理见《Java 从入门到精通·反射注解代理篇》,本文讲 Spring 如何在容器层用代理实现 AOP。读前请知悉,避免重复阅读。

一、从一个 new 说起:为什么需要 IoC

早期写法里,对象之间的依赖关系是硬编码的:

1
2
3
4
5
6
7
8
9
10
11
public class OrderService {
// 自己 new 依赖:订单服务被死死绑死在 MySQL 实现上
private UserRepository repo = new MysqlUserRepository();
private PaymentGateway pay = new AliPayGateway();

public Order createOrder(...) {
User user = repo.findById(...);
pay.charge(...);
// ...
}
}

这种写法有三个结构性问题:

  1. 强耦合。想换成 PostgresUserRepository 或微信支付,得改 OrderService 源码并重新编译。
  2. 难以测试。单元测试想注入一个假的 PaymentGateway,没有入口,只能连真实支付。
  3. 对象生命周期各自为政。谁创建、何时销毁、单例还是多例,散落在业务代码各处。

控制反转(Inversion of Control) 把”对象创建与依赖组装”的权力从业务代码手里交给一个外部容器:

1
2
以前:OrderService 自己 new 依赖       →  主动控制
现在:容器创建好依赖,塞给 OrderService → 控制权反转给容器

依赖注入(DI, Dependency Injection) 是 IoC 最常见的实现方式——容器在创建对象时,把它依赖的对象通过构造器 / Setter / 字段”注入”进去。IoC 是思想,DI 是落地手段,二者常被混称,但严格说:IoC 是”谁控制创建”的回答,DI 是”如何传递依赖”的做法。

带来的收益是实打实的:解耦(面向接口编程)、可测试(注入 Mock)、生命周期统一管理(单例/作用域/回调)、横切逻辑有了统一入口(这正是 AOP 的落脚点)。

记住一句话:不要去找依赖,让依赖来找你。你只声明”我需要什么”(@Autowired),容器负责”给你什么”。

二、容器全景:BeanFactory 与 ApplicationContext

很多人把”Spring 容器”当成一个东西,其实它有两层:

  • BeanFactory:最底层的 IoC 容器,只提供最基础的 Bean 管理能力——getBean()、实例化、依赖解析、生命周期。它是个”懒加载”的工厂,默认用到某个 Bean 才创建它。
  • ApplicationContext:继承自 BeanFactory,在其之上扩展了事件发布、国际化、资源加载、AOP 集成、Web 环境支持等企业级能力。它在启动时就实例化所有单例 Bean(除非懒加载)。

日常开发接触的几乎都是 ApplicationContext,BeanFactory 更多是框架内部角色。

对比维度 BeanFactory ApplicationContext
Bean 实例化时机 懒加载,用到才建 启动预建单例
事件发布 / 监听 ❌ ✅ ApplicationEventPublisher
国际化 MessageSource ❌ ✅
资源加载 基础 统一 ResourceLoader
AOP 自动集成 需手动 自动代理创建
常见实现 DefaultListableBeanFactory ClassPathXmlApplicationContext、AnnotationConfigApplicationContext、GenericWebApplicationContext

常见实现的选用:

1
2
3
4
5
// 纯注解方式(Spring Boot 内部即用此类)
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);

// 从容器里取 Bean——你很少手写,框架帮你注入
OrderService orderService = ctx.getBean(OrderService.class);

一张容器启动的主线(理解它,后面所有知识点都能挂上去):

1
2
3
4
5
6
7
8
9
10
11
12
读取配置(XML/注解/Java Config)
↓
解析成 BeanDefinition 并注册到 BeanDefinitionRegistry
↓
BeanFactoryPostProcessor 加工 BeanDefinition(如占位符替换)
↓
实例化所有非懒加载单例 Bean
├─ 实例化 → 属性填充(DI) → Aware 回调
├─ BeanPostProcessor.before → 初始化 → BeanPostProcessor.after(这里生成 AOP 代理)
└─ 放入单例缓存池
↓
发布 ContextRefreshedEvent,容器就绪

三、BeanDefinition:Bean 的”设计图纸”

一个关键认知:Spring 并不是扫描到 @Component 就直接 new 对象。它先把类信息解析成一份”图纸”——BeanDefinition,注册进容器;等真正需要(或启动预建)时,才按图纸把对象造出来。

BeanDefinition 里记录的核心元数据:

属性 含义
beanClassName Bean 的全限定类名
scope singleton / prototype / request…
lazyInit 是否懒加载
dependsOn 依赖的其他 Bean(强制先初始化)
constructorArgumentValues 构造参数
propertyValues 属性值(setter 注入的来源)
initMethodName / destroyMethodName 生命周期回调方法
factoryBeanName / factoryMethodName 工厂方法创建时的归属

注册 BeanDefinition 的几种方式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 1) 注解扫描:@Component / @Service / @Repository / @Controller
@Component
public class OrderService { }

// 2) @Bean 方法
@Configuration
class AppConfig {
@Bean
public PaymentGateway paymentGateway() { return new WeChatPayGateway(); }
}

// 3) 编程式注册
((AnnotationConfigApplicationContext) ctx)
.registerBeanDefinition("myBean", new RootBeanDefinition(Foo.class));

为什么要有一层”图纸”?因为它让容器获得了在实例化前修改定义的能力。BeanFactoryPostProcessor 就是干这个的——Spring 的占位符解析 ${jdbc.url}、MyBatis 的 Mapper 扫描注册,都是在 BeanDefinition 阶段动的手脚。

BeanFactoryPostProcessor 改的是 BeanDefinition(图纸);BeanPostProcessor 改的是 Bean 实例(成品/半成品)。一字之差,作用阶段天壤之别,面试高频。

四、Bean 的完整生命周期(核心)

这是 Spring 最值得吃透的一条主线。一个单例 Bean 从诞生到销毁,完整经过:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
① 实例化 (createBeanInstance)         —— 调用构造器,对象诞生(此时属性都是默认值)
↓
② 属性填充 (populateBean) —— DI:注入依赖的 Bean
↓
③ Aware 回调 —— 感知容器:BeanNameAware / BeanFactoryAware / ApplicationContextAware
↓
④ BeanPostProcessor.before —— postProcessBeforeInitialization(前置增强)
↓
⑤ 初始化 (initializeBean 的初始化动作) —— @PostConstruct → InitializingBean.afterPropertiesSet() → init-method
↓
⑥ BeanPostProcessor.after —— postProcessAfterInitialization(后置增强,★AOP 代理在这里生成)
↓
⑦ 使用阶段 —— Bean 已进入单例池,可被注入、被调用
↓
⑧ 销毁 —— @PreDestroy → DisposableBean.destroy() → destroy-method

分阶段细看几个关键节点。

③ Aware 回调——让 Bean “感知”自己所处的容器环境:

1
2
3
4
5
6
7
8
9
10
11
@Component
public class MyBean implements BeanNameAware, ApplicationContextAware {
private String beanName;
private ApplicationContext ctx;

@Override
public void setBeanName(String name) { this.beanName = name; }

@Override
public void setApplicationContext(ApplicationContext ac) { this.ctx = ac; }
}

④/⑥ BeanPostProcessor——Spring 最核心的扩展点,可以在初始化前后对 Bean 做任何加工,甚至返回一个代理对象替换原对象:

1
2
3
4
5
6
7
8
9
10
11
12
13
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String name) {
// 前置处理,比如打日志、注入自定义注解标记的资源
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String name) {
// ★ AOP 代理就是某个 BeanPostProcessor 在这里把 bean 替换成代理的
return bean;
}
}

⑤ 初始化——三种方式可以并存,执行顺序固定:

1
2
3
4
5
6
7
8
9
10
@Component
public class InitDemo implements InitializingBean {
@PostConstruct // 1. JSR-250 注解(最先)
public void postConstruct() { }

@Override // 2. Spring 接口回调
public void afterPropertiesSet() { }

public void customInit() { } // 3. XML/@Bean 指定的 init-method(最后)
}

用一段代码把顺序串起来验证:

1
2
3
4
5
6
7
8
9
10
@Component
public class LifeCycleBean implements BeanNameAware, InitializingBean, DisposableBean {
public LifeCycleBean() { System.out.println("① 实例化"); }
public void setXxx(...) { System.out.println("② 属性填充"); }
public void setBeanName(String n) { System.out.println("③ Aware: " + n); }
@PostConstruct public void pc() { System.out.println("⑤ @PostConstruct"); }
public void afterPropertiesSet() { System.out.println("⑤ InitializingBean"); }
@PreDestroy public void pd() { System.out.println("⑧ @PreDestroy"); }
public void destroy() { System.out.println("⑧ DisposableBean"); }
}

@PostConstruct / @PreDestroy 是 JSR-250 标准注解,不依赖 Spring API,优先推荐;InitializingBean / DisposableBean 是 Spring 接口,会引入耦合;init-method / destroy-method 是配置式,适合第三方类。三种可共存,但别在同一个 Bean 里混用来做同一件事。

五、依赖注入:@Autowired 是怎么找到 Bean 的

三种注入方式的取舍:

方式 示例 评价
构造器注入 OrderService(Repo r){...} ✅ 推荐:依赖不可变、必然非空、便于测试
Setter 注入 @Autowired void setRepo(Repo r) 可选依赖、可重配场景
字段注入 @Autowired private Repo r; 写法最简,但无法 final、掩盖强依赖、脱离容器不可用
1
2
3
4
5
6
7
8
9
10
11
@Service
public class OrderService {
private final UserRepository repo;
private final PaymentGateway pay;

// Spring 4.3+ 单构造器可省略 @Autowired;多构造器必须用 @Autowired 指定
public OrderService(UserRepository repo, PaymentGateway pay) {
this.repo = repo;
this.pay = pay;
}
}

@Autowired 的解析流程(背后是 AutowiredAnnotationBeanPostProcessor 在属性填充阶段干活):

1
2
3
4
5
6
7
① 找到标注 @Autowired 的字段/方法/构造器,构造 DependencyDescriptor
② 按类型(byType)从容器找候选 Bean
③ 候选多个时消歧:
- 有 @Primary 的优先
- 有 @Qualifier("xxx") 按名字匹配
- 都不满足 → 按字段名/参数名兜底匹配
④ 仍唯一 → 注入;仍多个或零个 → 抛异常(required=true 时)

集合注入是个实用特性——按类型把所有实现收集进来,配合策略模式非常好用:

1
2
3
4
5
6
// 容器里所有 PaymentGateway 实现都会被注入,key 是 Bean 名
@Autowired
private Map<String, PaymentGateway> gatewayMap;

@Autowired
private List<PaymentGateway> gatewayList;

@Autowired vs @Resource 的区别也常被问到:

维度 @Autowired @Resource
来源 Spring 自带 JSR-250 标准(javax/jakarta)
默认装配 byType byName
支持 @Primary ✅ ❌
可指定名称 配合 @Qualifier 直接 name 属性

推荐构造器注入 + @Autowired(或 Spring 4.3 单构造器省略注解)。字段注入虽然最常见,但它是”隐藏的强依赖”,且不能用 final 保证不可变——新代码建议逐步迁移到构造器注入。

六、循环依赖与三级缓存(面试深水区)

6.1 什么是循环依赖

1
2
3
4
5
6
7
8
@Component
public class A {
@Autowired private B b;
}
@Component
public class B {
@Autowired private A a;
}

A 创建时需要 B,B 创建时又需要 A——如果容器傻乎乎地递归创建,就会无限套娃直到栈溢出。Spring 用三级缓存打破了死循环。

6.2 三级缓存是什么

单例 Bean 的缓存定义在 DefaultSingletonBeanRegistry 里:

1
2
3
4
5
6
7
8
// 一级:成品缓存,完全初始化好的单例 Bean
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

// 二级:早期暴露对象,已实例化但还没完成属性填充/初始化("半成品")
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

// 三级:单例工厂,存放 ObjectFactory,能按需生成早期引用(★代理的钩子就在这)
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

获取 Bean 时的查找顺序(getSingleton):一级 → 二级 → 三级。三级命中时,调用 ObjectFactory.getObject() 拿到早期引用,放进二级、并从三级移除(这叫”三级提升为二级”)。

6.3 完整时序:A、B 如何互相注入

1
2
3
4
5
6
7
8
① 创建 A:实例化 A(构造器),把 A 的 ObjectFactory 放入【三级缓存】
② 给 A 属性填充,发现需要 B → 去容器拿 B
③ 创建 B:实例化 B,把 B 的 ObjectFactory 放入【三级缓存】
④ 给 B 属性填充,发现需要 A → 去容器拿 A
⑤ 查缓存:一级无、二级无、三级有 A 的工厂 → 调用工厂拿到 A 的早期引用
(放进二级缓存,并从三级移除),注入给 B
⑥ B 完成属性填充、初始化 → B 作为成品放入【一级缓存】
⑦ 回到 A,拿到成品 B 注入 → A 完成初始化 → A 放入【一级缓存】,从二/三级清除

循环的链条在”⑤ 从三级拿到 A 的早期引用”处被斩断——B 拿到的是一个尚未完全初始化但已经实例化的 A 引用,够用了。

6.4 为什么必须是三级,两级不行吗

这是最容易被问倒的一问。先说结论:在没有 AOP 的场景下,两级缓存确实够用;三级缓存是为了正确处理”循环依赖 + AOP 代理”的组合。

关键在于三级缓存里放的不是裸对象,而是一个 ObjectFactory:

1
2
// AbstractAutowireCapableBeanFactory.addSingletonFactory
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

getEarlyBeanReference() 是这个工厂的核心——它会在需要早期引用时判断这个 Bean 是否该被代理:

  • 如果 Bean 需要 AOP 增强(比如有 @Transactional、@Async),工厂返回的是代理对象;
  • 否则返回原始对象。

想想如果只有两级:实例化后就得立刻决定”要不要把对象放进二级缓存”。可此时 AOP 代理还没生成(代理是在生命周期第 ⑥ 步 BeanPostProcessor.after 才生成的),你只能把原始对象提前暴露出去。结果就是:B 拿到的是原始 A,而容器里最终的 A 是代理对象——同一个 Bean 出现了两个不同的对象,注入到 B 的那个没被代理,事务/异步注解全部失效。

三级缓存用工厂把”决定权”延迟到了真正需要早期引用的那一刻,到那时才能正确判断并生成代理引用,保证 B 拿到的和容器最终暴露的是同一个(代理)对象。

一句话记住:一级存成品、二级存早期引用解决循环、三级存工厂解决”循环依赖中的 AOP 代理”。三级缓存本质是用一个延迟计算的钩子,把”要不要代理”的决策推迟到早期引用被索取时。

6.5 哪些循环依赖 Spring 解决不了

三级缓存不是万能的,以下场景无解:

  1. 构造器注入的循环依赖。A 的构造器需要 B,B 的构造器需要 A。实例化阶段就卡住了,对象还没造出来,根本来不及放进三级缓存。报错 BeanCurrentlyInCreationException。解法:改用字段/Setter 注入,或重构消除循环。
  2. prototype 作用域的循环依赖。多例 Bean 不进单例缓存,Spring 不做缓存,无法打断循环。
  3. 依赖自身且通过构造器、@Async 代理与循环依赖叠加时的一些边界情况,也可能出问题。

另外,Spring Boot 2.6+ 默认禁止循环依赖(spring.main.allow-circular-references=false),目的就是逼你从设计上消除循环而不是依赖框架兜底。真要临时放开:

1
2
3
spring:
main:
allow-circular-references: true

循环依赖能跑通不代表设计合理。它往往意味着职责边界不清或抽取不够彻底。生产代码应优先通过重构(抽取公共层、事件解耦、接口回调)消除循环,而不是依赖三级缓存或配置开关。

七、Bean 的作用域与懒加载

作用域 说明 适用场景
singleton(默认) 每个容器一个实例 无状态 Service / DAO
prototype 每次注入/获取都新建 有状态对象、非线程安全对象
request 每个 HTTP 请求一个(Web) 请求上下文数据
session 每个会话一个(Web) 用户会话状态
application 整个 Web 应用一个 全局共享状态
1
2
3
4
5
6
7
@Component
@Scope("prototype")
public class TaskContext { /* 每次获取都是新对象 */ }

@Component
@Lazy // 启动时不创建,第一次用到才创建
public class HeavyBean { }

两个高频坑:

  • 单例 Bean 的线程安全。Spring 单例不等于线程安全。无状态 Bean(只有方法、无实例字段)天然安全;一旦单例 Bean 有可变的实例字段(如 private int count),多线程并发就会出问题,要自己保证线程安全或改用 ThreadLocal。
  • prototype 的销毁回调不生效。容器对 prototype Bean 只负责创建和初始化,不管理其销毁生命周期——destroy-method / DisposableBean 不会自动触发,需要你自己清理资源。

八、Spring AOP:把横切逻辑从业务里抽出来

8.1 为什么需要 AOP

日志、事务、权限校验、缓存、接口耗时统计这类逻辑,横跨多个模块,传统写法会散落在每个方法里:

1
2
3
4
5
6
7
8
9
public Order createOrder(...) {
log.info("开始创建订单"); // 横切
checkPermission(); // 横切
try {
// 真正的业务
} finally {
log.info("创建订单结束, 耗时 {}", cost); // 横切
}
}

AOP(面向切面编程)把这些横切逻辑抽成一个”切面”,声明式地织入到目标方法,业务代码只保留业务。

8.2 AOP 术语表(必须分清)

术语 含义
Aspect(切面) 横切逻辑的封装 = 通知 + 切点
Join Point(连接点) 程序执行中可被织入的点(Spring 里就是方法调用)
Pointcut(切点) 匹配哪些连接点的”表达式”
Advice(通知) 切点处要执行的动作(5 种类型)
Target(目标对象) 被增强的原对象
Proxy(代理对象) 织入增强后暴露给外部的对象
Weaving(织入) 把增强应用到目标生成代理的过程

8.3 五种通知类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@Aspect
@Component
public class LogAspect {
// 切点:匹配 service 包下所有类的所有方法
@Pointcut("execution(* com.example.service..*.*(..))")
public void serviceMethods() {}

@Before("serviceMethods()") // 方法执行前
public void before(JoinPoint jp) { }

@After("serviceMethods()") // 方法执行后(无论成功/异常)
public void after(JoinPoint jp) { }

@AfterReturning(value = "serviceMethods()", returning = "ret") // 正常返回后
public void afterReturning(JoinPoint jp, Object ret) { }

@AfterThrowing(value = "serviceMethods()", throwing = "ex") // 抛异常后
public void afterThrowing(JoinPoint jp, Throwable ex) { }

@Around("serviceMethods()") // 环绕:功能最强,能控制目标是否执行
public Object around(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
try {
return pjp.proceed(); // 不调用则目标方法不执行
} finally {
log.info("{} 耗时 {}ms", pjp.getSignature(), System.currentTimeMillis() - start);
}
}
}

@Around 是唯一能决定目标方法是否执行、修改返回值、吞掉异常的通知,事务、缓存等底层增强都用它实现。使用时务必记得 proceed(),否则目标方法被”吃掉”。

8.4 切点表达式

execution 是最常用的匹配语法:

1
2
3
4
5
6
execution( 修饰符  返回类型  包名.类名.方法名(参数)  异常 )
execution(* com.example.service..*.*(..))
│ │ │ └─ (..) 任意参数
│ │ └──── * 任意方法
│ └───────────────────────── .. 当前包及子包
└──────────────────────────── * 任意返回类型

其他常用指示符:within(按类匹配)、@annotation(匹配标注某注解的方法,做自定义注解增强很方便)、bean(按 Bean 名匹配)、args(按参数类型匹配)。

启用 AspectJ 自动代理:

1
2
3
@Configuration
@EnableAspectJAutoProxy // 关键:注册 AnnotationAwareAspectJAutoProxyCreator
public class AopConfig { }

九、AOP 的底层:代理是怎么生成的

9.1 两种代理机制

维度 JDK 动态代理 CGLIB 代理
实现方式 基于接口,生成实现同一接口的代理类 基于继承,生成目标类的子类
前提 目标类必须实现接口 无需接口
final 类/方法 不涉及 final 类/方法无法代理(不能继承/覆写)
底层 Proxy.newProxyInstance + InvocationHandler 字节码增强(ASM)
Spring Boot 2.0+ — 默认使用 CGLIB(proxyTargetClass=true)
1
2
3
4
// 强制使用 CGLIB
@EnableAspectJAutoProxy(proxyTargetClass = true)
// 或配置
// spring.aop.proxy-target-class=true

Spring Boot 2.0 之后默认统一用 CGLIB,即使Bean 实现了接口——所以别再依赖”实现类没接口也能代理”这种旧假设。CGLIB 通过生成子类工作,因此 final 类、final/static/private 方法无法被增强,这是很多”注解莫名其妙失效”的元凶。

9.2 代理在生命周期中的位置

回顾第四节的生命周期第 ⑥ 步:BeanPostProcessor.postProcessAfterInitialization。负责 AOP 的幕后角色是 AnnotationAwareAspectJAutoProxyCreator——它本身就是一个 BeanPostProcessor:

1
2
3
4
5
6
7
8
9
Bean 完成初始化
↓
AnnotationAwareAspectJAutoProxyCreator.postProcessAfterInitialization()
↓
判断该 Bean 是否匹配某个切点(Pointcut)
├─ 不匹配 → 原样返回
└─ 匹配 → 创建代理(JDK/CGLIB),把代理对象返回,替换掉原 Bean
↓
容器里最终存放、对外注入的是【代理对象】

这也解释了第六节的三级缓存:循环依赖中,”要不要代理”的决定就藏在这个 BeanPostProcessor 的逻辑里,必须延迟到索取早期引用时才能正确执行。

9.3 一个经典陷阱:内部方法调用导致 AOP 失效

1
2
3
4
5
6
7
8
9
@Service
public class OrderService {
public void createOrder() {
this.checkStock(); // ❌ 内部调用,走的是 this(原对象),不经过代理 → @Transactional 失效
}

@Transactional
public void checkStock() { /* ... */ }
}

原因:AOP 增强的是代理对象,而 this 指向的是目标对象本身。只有通过代理对象调用方法,才会触发拦截链。解法:拆到另一个 Bean、通过代理对象调用(AopContext.currentProxy())、或注入自身(配合 @Lazy 避免循环依赖)。

“同类内部方法调用 → AOP 增强失效”是事务、缓存(@Cacheable)、异步(@Async)、重试(@Retryable)等所有基于 AOP 的注解共同的坑。记住:注解能生效的前提是调用经过代理对象。

十、声明式事务:@Transactional 原理

10.1 事务传播行为

传播行为决定”多个事务方法互相调用时,事务如何边界”——这是 Spring 事务最核心也最常被问的概念:

传播行为 含义 典型场景
REQUIRED(默认) 有事务就加入,没有就新建 绝大多数业务方法
SUPPORTS 有事务就加入,没有就非事务执行 查询方法
MANDATORY 必须在事务中,否则抛异常 强制要求上下文事务
REQUIRES_NEW 新建事务,挂起当前事务 独立记录日志(不受外层回滚影响)
NOT_SUPPORTED 非事务执行,挂起当前事务 不希望被事务包裹
NEVER 不能在事务中,否则抛异常 严格禁止事务
NESTED 在当前事务内嵌事务(保存点) 内层回滚不影响外层(依赖保存点支持)

最经典的对比:REQUIRED 与 REQUIRES_NEW。方法 A 调用方法 B,若 A 回滚:

  • B 是 REQUIRED:B 加入 A 的事务,A 回滚 → B 一起回滚。
  • B 是 REQUIRES_NEW:B 开了独立事务,A 回滚 → B 已提交的不受影响。
1
2
3
4
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void writeAuditLog(...) {
// 审计日志独立提交,主业务回滚也要留下痕迹
}

10.2 隔离级别

isolation 属性映射到数据库的隔离级别:

1
2
@Transactional(isolation = Isolation.READ_COMMITTED)
public void doSomething() { }
级别 脏读 不可重复读 幻读
READ_UNCOMMITTED ✅ ✅ ✅
READ_COMMITTED ❌ ✅ ✅
REPEATABLE_READ(MySQL 默认) ❌ ❌ ✅(MySQL 靠 next-key lock 基本解决)
SERIALIZABLE ❌ ❌ ❌

这些隔离级别背后的 MVCC、undo log、间隙锁实现,见《MySQL 事务与锁机制》,本文不展开。

10.3 事务的 8 种失效场景(重点)

@Transactional 加了却不回滚,是生产事故高发区。逐一排查:

  1. 作用在非 public 方法上。Spring AOP 默认只代理 public 方法(JDK 代理基于接口,接口方法本就 public)。
  2. 同类内部方法调用。见 9.3 节,绕过代理,注解失效。
  3. 异常被 catch 吞掉。方法里 try{...}catch(Exception e){} 吃掉了异常,事务拦截器看不到异常,自然不回滚。
  4. 默认只回滚 RuntimeException 和 Error。抛出受检异常(如 IOException)不回滚,要显式指定 @Transactional(rollbackFor = Exception.class)。
  5. 数据库引擎不支持事务。MySQL 的 MyISAM 不支持事务,必须是 InnoDB。
  6. Bean 没被 Spring 管理。自己 new 出来的对象,不经过容器,注解形同虚设。
  7. 传播行为设置不当。如设成 NOT_SUPPORTED / NEVER,本就不在事务里。
  8. 多线程调用。事务信息存在 ThreadLocal(TransactionSynchronizationManager)里,子线程不共享父线程的事务上下文。
1
2
3
4
5
6
7
8
9
10
// 正确姿势:捕获后想回滚,要么重新抛出,要么手动标记回滚
@Transactional(rollbackFor = Exception.class)
public void correct() {
try {
doBusiness();
} catch (Exception e) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
// 或 throw e;
}
}

排查事务失效的固定套路:① 方法是不是 public?② 调用有没有经过代理(是不是内部调用)?③ 异常有没有被吞?④ 是不是受检异常没配 rollbackFor?⑤ 引擎是不是 InnoDB?按此顺序基本能定位 90% 的问题。

十一、生产避坑清单

  1. 优先构造器注入,依赖用 final 声明,避免字段注入隐藏强依赖。
  2. 单例 Bean 别持有可变实例字段;需要状态用 ThreadLocal 或改 prototype。
  3. 理解三级缓存但别依赖它——循环依赖应通过重构消除,Spring Boot 2.6+ 已默认禁止。
  4. AOP 增强前提是调用经过代理:内部调用、private/final 方法、final 类都会让增强失效。
  5. @Transactional 一律显式写 rollbackFor = Exception.class,避免受检异常不回滚。
  6. 事务方法里别吞异常、别做耗时远程调用(长事务占连接、加锁),把网络 IO 移出事务边界。
  7. @Async、@Cacheable、@Transactional 共用时留意执行顺序与代理:多个 advisor 的 order 会影响增强嵌套关系。
  8. BeanFactoryPostProcessor 改图纸,BeanPostProcessor 改实例——别在错误的阶段做错误的事。
  9. prototype Bean 的销毁不会被容器回调,资源清理要自己负责。
  10. @PostConstruct 里别做太重的事,它在 Bean 初始化早期执行,此时部分依赖可能还没就绪。
  11. 谨慎使用 @Lazy:滥用会把启动期问题推迟到运行期暴露,还可能掩盖初始化顺序问题。
  12. AOP 切面逻辑要轻量、无副作用,切面里抛异常会直接影响业务主流程。

十二、小结

Spring 的两块内核其实是两条相互咬合的主线:

  • IoC 容器解决”对象从哪来、依赖怎么装”——BeanDefinition 是图纸,生命周期是流水线,三级缓存是循环依赖的解锁器,DI 让业务面向接口。
  • AOP解决”横切逻辑放哪”——通过 BeanPostProcessor 在生命周期的初始化后环节生成代理,把日志、事务、缓存等能力无侵入织入;声明式事务正是 AOP 最成功的应用。

把”Bean 生命周期”这条主线吃透,你会发现:循环依赖、AOP 代理时机、事务失效、@Autowired 解析,全都挂在同一条链路上。理解链路,比背结论更有价值。

相关阅读:容器之上的自动装配见《SpringBoot 自定义 Starter》;数据库事务底层见《MySQL 事务与锁机制》;语言层代理原理见《Java 从入门到精通·反射注解代理篇》。