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

Spring 核心原理与实战:IoC 容器、Bean 生命周期、循环依赖与 AOP 事务
神经蛙本文聚焦 Spring Framework 内核(容器与 AOP),是框架”地基”层。三处边界先说清楚:① @Transactional 背后的数据库 MVCC、锁、隔离级别实现见《MySQL 事务与锁机制》,本文只讲 Spring 如何声明式编排事务;② Spring Boot 的自动装配与手写 Starter 见《SpringBoot 自定义 Starter》,本文讲被装配出来的容器本身;③ JDK 动态代理的语言层字节码原理见《Java 从入门到精通·反射注解代理篇》,本文讲 Spring 如何在容器层用代理实现 AOP。读前请知悉,避免重复阅读。
一、从一个 new 说起:为什么需要 IoC
早期写法里,对象之间的依赖关系是硬编码的:
1 | public class OrderService { |
这种写法有三个结构性问题:
- 强耦合。想换成
PostgresUserRepository或微信支付,得改OrderService源码并重新编译。 - 难以测试。单元测试想注入一个假的
PaymentGateway,没有入口,只能连真实支付。 - 对象生命周期各自为政。谁创建、何时销毁、单例还是多例,散落在业务代码各处。
控制反转(Inversion of Control) 把”对象创建与依赖组装”的权力从业务代码手里交给一个外部容器:
1 | 以前:OrderService 自己 new 依赖 → 主动控制 |
依赖注入(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 | // 纯注解方式(Spring Boot 内部即用此类) |
一张容器启动的主线(理解它,后面所有知识点都能挂上去):
1 | 读取配置(XML/注解/Java Config) |
三、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 | // 1) 注解扫描:@Component / @Service / @Repository / @Controller |
为什么要有一层”图纸”?因为它让容器获得了在实例化前修改定义的能力。BeanFactoryPostProcessor 就是干这个的——Spring 的占位符解析 ${jdbc.url}、MyBatis 的 Mapper 扫描注册,都是在 BeanDefinition 阶段动的手脚。
BeanFactoryPostProcessor 改的是 BeanDefinition(图纸);BeanPostProcessor 改的是 Bean 实例(成品/半成品)。一字之差,作用阶段天壤之别,面试高频。
四、Bean 的完整生命周期(核心)
这是 Spring 最值得吃透的一条主线。一个单例 Bean 从诞生到销毁,完整经过:
1 | ① 实例化 (createBeanInstance) —— 调用构造器,对象诞生(此时属性都是默认值) |
分阶段细看几个关键节点。
③ Aware 回调——让 Bean “感知”自己所处的容器环境:
1 |
|
④/⑥ BeanPostProcessor——Spring 最核心的扩展点,可以在初始化前后对 Bean 做任何加工,甚至返回一个代理对象替换原对象:
1 |
|
⑤ 初始化——三种方式可以并存,执行顺序固定:
1 |
|
用一段代码把顺序串起来验证:
1 |
|
@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 |
|
@Autowired 的解析流程(背后是 AutowiredAnnotationBeanPostProcessor 在属性填充阶段干活):
1 | ① 找到标注 @Autowired 的字段/方法/构造器,构造 DependencyDescriptor |
集合注入是个实用特性——按类型把所有实现收集进来,配合策略模式非常好用:
1 | // 容器里所有 PaymentGateway 实现都会被注入,key 是 Bean 名 |
@Autowired vs @Resource 的区别也常被问到:
| 维度 | @Autowired | @Resource |
|---|---|---|
| 来源 | Spring 自带 | JSR-250 标准(javax/jakarta) |
| 默认装配 | byType | byName |
| 支持 @Primary | ✅ | ❌ |
| 可指定名称 | 配合 @Qualifier |
直接 name 属性 |
推荐构造器注入 + @Autowired(或 Spring 4.3 单构造器省略注解)。字段注入虽然最常见,但它是”隐藏的强依赖”,且不能用 final 保证不可变——新代码建议逐步迁移到构造器注入。
六、循环依赖与三级缓存(面试深水区)
6.1 什么是循环依赖
1 |
|
A 创建时需要 B,B 创建时又需要 A——如果容器傻乎乎地递归创建,就会无限套娃直到栈溢出。Spring 用三级缓存打破了死循环。
6.2 三级缓存是什么
单例 Bean 的缓存定义在 DefaultSingletonBeanRegistry 里:
1 | // 一级:成品缓存,完全初始化好的单例 Bean |
获取 Bean 时的查找顺序(getSingleton):一级 → 二级 → 三级。三级命中时,调用 ObjectFactory.getObject() 拿到早期引用,放进二级、并从三级移除(这叫”三级提升为二级”)。
6.3 完整时序:A、B 如何互相注入
1 | ① 创建 A:实例化 A(构造器),把 A 的 ObjectFactory 放入【三级缓存】 |
循环的链条在”⑤ 从三级拿到 A 的早期引用”处被斩断——B 拿到的是一个尚未完全初始化但已经实例化的 A 引用,够用了。
6.4 为什么必须是三级,两级不行吗
这是最容易被问倒的一问。先说结论:在没有 AOP 的场景下,两级缓存确实够用;三级缓存是为了正确处理”循环依赖 + AOP 代理”的组合。
关键在于三级缓存里放的不是裸对象,而是一个 ObjectFactory:
1 | // AbstractAutowireCapableBeanFactory.addSingletonFactory |
getEarlyBeanReference() 是这个工厂的核心——它会在需要早期引用时判断这个 Bean 是否该被代理:
- 如果 Bean 需要 AOP 增强(比如有
@Transactional、@Async),工厂返回的是代理对象; - 否则返回原始对象。
想想如果只有两级:实例化后就得立刻决定”要不要把对象放进二级缓存”。可此时 AOP 代理还没生成(代理是在生命周期第 ⑥ 步 BeanPostProcessor.after 才生成的),你只能把原始对象提前暴露出去。结果就是:B 拿到的是原始 A,而容器里最终的 A 是代理对象——同一个 Bean 出现了两个不同的对象,注入到 B 的那个没被代理,事务/异步注解全部失效。
三级缓存用工厂把”决定权”延迟到了真正需要早期引用的那一刻,到那时才能正确判断并生成代理引用,保证 B 拿到的和容器最终暴露的是同一个(代理)对象。
一句话记住:一级存成品、二级存早期引用解决循环、三级存工厂解决”循环依赖中的 AOP 代理”。三级缓存本质是用一个延迟计算的钩子,把”要不要代理”的决策推迟到早期引用被索取时。
6.5 哪些循环依赖 Spring 解决不了
三级缓存不是万能的,以下场景无解:
- 构造器注入的循环依赖。A 的构造器需要 B,B 的构造器需要 A。实例化阶段就卡住了,对象还没造出来,根本来不及放进三级缓存。报错
BeanCurrentlyInCreationException。解法:改用字段/Setter 注入,或重构消除循环。 prototype作用域的循环依赖。多例 Bean 不进单例缓存,Spring 不做缓存,无法打断循环。- 依赖自身且通过构造器、
@Async代理与循环依赖叠加时的一些边界情况,也可能出问题。
另外,Spring Boot 2.6+ 默认禁止循环依赖(spring.main.allow-circular-references=false),目的就是逼你从设计上消除循环而不是依赖框架兜底。真要临时放开:
1 | spring: |
循环依赖能跑通不代表设计合理。它往往意味着职责边界不清或抽取不够彻底。生产代码应优先通过重构(抽取公共层、事件解耦、接口回调)消除循环,而不是依赖三级缓存或配置开关。
七、Bean 的作用域与懒加载
| 作用域 | 说明 | 适用场景 |
|---|---|---|
singleton(默认) |
每个容器一个实例 | 无状态 Service / DAO |
prototype |
每次注入/获取都新建 | 有状态对象、非线程安全对象 |
request |
每个 HTTP 请求一个(Web) | 请求上下文数据 |
session |
每个会话一个(Web) | 用户会话状态 |
application |
整个 Web 应用一个 | 全局共享状态 |
1 |
|
两个高频坑:
- 单例 Bean 的线程安全。Spring 单例不等于线程安全。无状态 Bean(只有方法、无实例字段)天然安全;一旦单例 Bean 有可变的实例字段(如
private int count),多线程并发就会出问题,要自己保证线程安全或改用ThreadLocal。 prototype的销毁回调不生效。容器对 prototype Bean 只负责创建和初始化,不管理其销毁生命周期——destroy-method/DisposableBean不会自动触发,需要你自己清理资源。
八、Spring AOP:把横切逻辑从业务里抽出来
8.1 为什么需要 AOP
日志、事务、权限校验、缓存、接口耗时统计这类逻辑,横跨多个模块,传统写法会散落在每个方法里:
1 | public Order createOrder(...) { |
AOP(面向切面编程)把这些横切逻辑抽成一个”切面”,声明式地织入到目标方法,业务代码只保留业务。
8.2 AOP 术语表(必须分清)
| 术语 | 含义 |
|---|---|
| Aspect(切面) | 横切逻辑的封装 = 通知 + 切点 |
| Join Point(连接点) | 程序执行中可被织入的点(Spring 里就是方法调用) |
| Pointcut(切点) | 匹配哪些连接点的”表达式” |
| Advice(通知) | 切点处要执行的动作(5 种类型) |
| Target(目标对象) | 被增强的原对象 |
| Proxy(代理对象) | 织入增强后暴露给外部的对象 |
| Weaving(织入) | 把增强应用到目标生成代理的过程 |
8.3 五种通知类型
1 |
|
@Around 是唯一能决定目标方法是否执行、修改返回值、吞掉异常的通知,事务、缓存等底层增强都用它实现。使用时务必记得 proceed(),否则目标方法被”吃掉”。
8.4 切点表达式
execution 是最常用的匹配语法:
1 | execution( 修饰符 返回类型 包名.类名.方法名(参数) 异常 ) |
其他常用指示符:within(按类匹配)、@annotation(匹配标注某注解的方法,做自定义注解增强很方便)、bean(按 Bean 名匹配)、args(按参数类型匹配)。
启用 AspectJ 自动代理:
1 |
|
九、AOP 的底层:代理是怎么生成的
9.1 两种代理机制
| 维度 | JDK 动态代理 | CGLIB 代理 |
|---|---|---|
| 实现方式 | 基于接口,生成实现同一接口的代理类 | 基于继承,生成目标类的子类 |
| 前提 | 目标类必须实现接口 | 无需接口 |
final 类/方法 |
不涉及 | final 类/方法无法代理(不能继承/覆写) |
| 底层 | Proxy.newProxyInstance + InvocationHandler |
字节码增强(ASM) |
| Spring Boot 2.0+ | — | 默认使用 CGLIB(proxyTargetClass=true) |
1 | // 强制使用 CGLIB |
Spring Boot 2.0 之后默认统一用 CGLIB,即使Bean 实现了接口——所以别再依赖”实现类没接口也能代理”这种旧假设。CGLIB 通过生成子类工作,因此 final 类、final/static/private 方法无法被增强,这是很多”注解莫名其妙失效”的元凶。
9.2 代理在生命周期中的位置
回顾第四节的生命周期第 ⑥ 步:BeanPostProcessor.postProcessAfterInitialization。负责 AOP 的幕后角色是 AnnotationAwareAspectJAutoProxyCreator——它本身就是一个 BeanPostProcessor:
1 | Bean 完成初始化 |
这也解释了第六节的三级缓存:循环依赖中,”要不要代理”的决定就藏在这个 BeanPostProcessor 的逻辑里,必须延迟到索取早期引用时才能正确执行。
9.3 一个经典陷阱:内部方法调用导致 AOP 失效
1 |
|
原因: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 |
|
10.2 隔离级别
isolation 属性映射到数据库的隔离级别:
1 |
|
| 级别 | 脏读 | 不可重复读 | 幻读 |
|---|---|---|---|
READ_UNCOMMITTED |
✅ | ✅ | ✅ |
READ_COMMITTED |
❌ | ✅ | ✅ |
REPEATABLE_READ(MySQL 默认) |
❌ | ❌ | ✅(MySQL 靠 next-key lock 基本解决) |
SERIALIZABLE |
❌ | ❌ | ❌ |
这些隔离级别背后的 MVCC、undo log、间隙锁实现,见《MySQL 事务与锁机制》,本文不展开。
10.3 事务的 8 种失效场景(重点)
@Transactional 加了却不回滚,是生产事故高发区。逐一排查:
- 作用在非
public方法上。Spring AOP 默认只代理 public 方法(JDK 代理基于接口,接口方法本就 public)。 - 同类内部方法调用。见 9.3 节,绕过代理,注解失效。
- 异常被
catch吞掉。方法里try{...}catch(Exception e){}吃掉了异常,事务拦截器看不到异常,自然不回滚。 - 默认只回滚
RuntimeException和Error。抛出受检异常(如IOException)不回滚,要显式指定@Transactional(rollbackFor = Exception.class)。 - 数据库引擎不支持事务。MySQL 的 MyISAM 不支持事务,必须是 InnoDB。
- Bean 没被 Spring 管理。自己
new出来的对象,不经过容器,注解形同虚设。 - 传播行为设置不当。如设成
NOT_SUPPORTED/NEVER,本就不在事务里。 - 多线程调用。事务信息存在
ThreadLocal(TransactionSynchronizationManager)里,子线程不共享父线程的事务上下文。
1 | // 正确姿势:捕获后想回滚,要么重新抛出,要么手动标记回滚 |
排查事务失效的固定套路:① 方法是不是 public?② 调用有没有经过代理(是不是内部调用)?③ 异常有没有被吞?④ 是不是受检异常没配 rollbackFor?⑤ 引擎是不是 InnoDB?按此顺序基本能定位 90% 的问题。
十一、生产避坑清单
- 优先构造器注入,依赖用
final声明,避免字段注入隐藏强依赖。 - 单例 Bean 别持有可变实例字段;需要状态用
ThreadLocal或改prototype。 - 理解三级缓存但别依赖它——循环依赖应通过重构消除,Spring Boot 2.6+ 已默认禁止。
- AOP 增强前提是调用经过代理:内部调用、private/final 方法、final 类都会让增强失效。
@Transactional一律显式写rollbackFor = Exception.class,避免受检异常不回滚。- 事务方法里别吞异常、别做耗时远程调用(长事务占连接、加锁),把网络 IO 移出事务边界。
@Async、@Cacheable、@Transactional共用时留意执行顺序与代理:多个 advisor 的 order 会影响增强嵌套关系。BeanFactoryPostProcessor改图纸,BeanPostProcessor改实例——别在错误的阶段做错误的事。prototypeBean 的销毁不会被容器回调,资源清理要自己负责。@PostConstruct里别做太重的事,它在 Bean 初始化早期执行,此时部分依赖可能还没就绪。- 谨慎使用
@Lazy:滥用会把启动期问题推迟到运行期暴露,还可能掩盖初始化顺序问题。 - AOP 切面逻辑要轻量、无副作用,切面里抛异常会直接影响业务主流程。
十二、小结
Spring 的两块内核其实是两条相互咬合的主线:
- IoC 容器解决”对象从哪来、依赖怎么装”——
BeanDefinition是图纸,生命周期是流水线,三级缓存是循环依赖的解锁器,DI 让业务面向接口。 - AOP解决”横切逻辑放哪”——通过
BeanPostProcessor在生命周期的初始化后环节生成代理,把日志、事务、缓存等能力无侵入织入;声明式事务正是 AOP 最成功的应用。
把”Bean 生命周期”这条主线吃透,你会发现:循环依赖、AOP 代理时机、事务失效、@Autowired 解析,全都挂在同一条链路上。理解链路,比背结论更有价值。
相关阅读:容器之上的自动装配见《SpringBoot 自定义 Starter》;数据库事务底层见《MySQL 事务与锁机制》;语言层代理原理见《Java 从入门到精通·反射注解代理篇》。
















