Spring 基础:IoC 容器、Bean 生命周期与 AOP
本篇要点:能说清一个对象从被扫描进容器到被销毁之间发生了什么,并用一个不依赖 Boot 的最小工程,把生命周期顺序、代理类型、循环依赖的失败现场各看一遍。前置:你会写 Java 类、用过 Maven,知道注解是贴在类或方法上的元数据。
为什么需要它
2024 年秋天我接手一个跑了五年的订单服务。OrderService 的构造器里有六行 new:new OrderMapper()、new RedisClient("10.20.3.11", 6379)、new SmsClient(),还有三个。这几个类在别的 Service 里又被 new 了一遍。
那次的需求很小:给下单链路加一行耗时日志。我数了一下,要在 7 个 Service、23 个方法里各复制一遍 System.currentTimeMillis(),再各写一遍 finally。第二天压测要换掉短信客户端,我把 SmsClient 的构造器改了个签名,编译报了 19 个错。
三个问题一次露出来:依赖写死在代码里,改一处要改一片;对象无法从外部替换,压测和单元测试只能真发短信;同一个类被 new 出七个实例,连接池参数改了只有一处生效,另外六处还是默认值。
容器解决的就是这三件事。它把「谁来 new」和「依赖从哪来」从业务代码里拿出来,交给一个统一的装配者。代价是你得知道它按什么顺序装配、什么时候递给你代理、什么情况下装不起来。
版本基线:这一章用 Spring Framework 7.0.x。截至 2026 年 11 月,Boot 4.1 依赖的是 7.0.10 及以上。为了看清装配过程,这一章不引入 Boot——Boot 会把这段过程收进 SpringApplication.run 一次调用里。
核心概念
容器与依赖注入:控制权交给谁
IoC(Inversion of Control,控制反转)指对象的创建与依赖装配的发起权,从业务代码挪到容器;DI(Dependency Injection,依赖注入)是它最常见的实现方式:你只声明需要什么,容器把依赖递进来。
类比:自己装修是 new,你得买水泥、约水电、盯工期;拎包入住是注入,你说「我要一个两居室」,家具从哪来、什么时候搬进去,不由你管。
反例比定义管用。方法体里写 new OrderService() 的代码,看上去用了 Spring,其实那个对象不在容器里:它没有代理、没有事务、没有切面。《事务管理:传播行为、隔离级别与失效场景》讲事务失效,第一个案例就是这个。
容器里每个对象都有一份配方,叫 BeanDefinition(Bean 定义):类名、作用域、构造参数、初始化方法、是否懒加载。配方进容器的路只有三条——组件扫描(@ComponentScan 扫 @Component 及其派生注解)、@Bean 方法、@Import 或自动配置类。
作用域:单例是默认值,不是定义
| 作用域 | 实例数量 | 典型用途 | 容易踩的地方 |
|---|---|---|---|
| singleton | 容器内一个 | 无状态服务、DAO、配置 | 放可变字段就是共享状态 |
| prototype | 每次获取新建 | 有状态、短生命周期对象 | 注入到单例里只发生一次 |
| request | 每个 HTTP 请求一个 | 请求级上下文 | 只在 Web 环境可用,需作用域代理 |
| session | 每个会话一个 | 登录态 | 集群下要做会话共享 |
| application | 每个 ServletContext 一个 | 全局缓存 | 与 singleton 容易混为一谈 |
反例:在单例 Service 里注入一个 prototype 的 OrderNoGenerator,你以为每次调用拿到新对象,其实拿到的是同一个——注入只发生在容器创建那个单例的那一次。要每次新的,注入 ObjectProvider<OrderNoGenerator>,自己调 getObject()。
还有一条容易忘:容器不管理 prototype 实例的销毁,@PreDestroy 在它身上不会执行。
生命周期回调:一条固定的链
Bean 从配方到可用要经过一串固定站点,如图 1-1 所示。这个顺序不是约定,是 AbstractAutowireCapableBeanFactory.doCreateBean 里写死的。
图 1-1 一个单例 Bean 从定义到销毁的十二个站点
三个位置值得单独记住。第 4 和第 8 站是 BeanPostProcessor 的两个钩子,把 Bean 包一层;第 8 站之后拿到的才是代理,不再是原始对象。第 5、6、7 站都是初始化,@PostConstruct 最先,init-method 最后,空指针最常见的来源是把「依赖别的 Bean 已就绪」的逻辑放在这一段。第 10 到 12 站只在容器正常关闭时执行,kill -9 一个都不跑。
代理与 AOP:横切逻辑放在方法外面
AOP(Aspect-Oriented Programming,面向切面编程)把日志、事务、缓存这类每个方法都要写一遍的横切关注点抽出来,由代理在方法调用前后插入。Spring AOP 用运行时织入(weaving):容器启动时生成代理对象,调用先被代理截住,再转给原始对象。
只有两种代理。JDK 动态代理(JDK dynamic proxy)要求目标类实现接口,代理实现同一个接口,所以只能看到接口上声明的方法;CGLIB 生成目标类的子类,没有接口也能代理,但 final 类、final 方法、private 方法都盖不住。
Spring Boot 默认 spring.aop.proxy-target-class=true,也就是优先 CGLIB。这个默认值解释了一个常见困惑:同一个切面,在 Boot 项目里生效,搬到纯 Spring 工具类工程里没生效,差别往往只是代理类型。
循环依赖与三级缓存:能救的只有一小半
A 依赖 B、B 依赖 A,先造谁都不对。Spring 的办法是提前暴露:A 实例化完、还没注入属性时,先把「怎么造出 A」的工厂放进三级缓存;B 需要 A 时从工厂取早期引用,B 就能先完成。
三个缓存各管一段,如图 1-2 所示。一级 singletonObjects 放完整可用的单例;二级 earlySingletonObjects 放提前暴露、还没注入完的早期引用;三级 singletonFactories 放 ObjectFactory 工厂。
三级放工厂而不是放对象,是因为 A 可能要被 AOP 增强。工厂被调用时才决定返回原始对象还是代理——如果直接放原始对象,B 注入到的就是一个没有事务、没有切面的 A。
图 1-2 三级缓存在 setter 循环依赖里的流转顺序
**它救不了的情况要说清楚。**prototype 作用域不缓存,循环直接失败;构造器注入的循环也失败,因为对象还没造出来,没有东西可以提前暴露。另外 Boot 从 2.6 起把 spring.main.allow-circular-references 默认设为 false,setter 循环在 Boot 里同样启动失败。这个默认值是好事:循环依赖说明两个类的职责切分有问题,加一行配置绕过去,只是把问题推到运行时。
动手实践
建一个普通 Maven 工程(不是 Boot),四个依赖:spring-context、spring-aop、aspectjweaver、jakarta.annotation-api,版本统一 7.0.x。
第一步:看清生命周期顺序与作用域差别
代码 1-1 用一个 BeanPostProcessor 把两个钩子打出来,顺便对比单例与 prototype 的实例差别。
package com.example.core;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
public class LifecycleDemo {
public static void main(String[] args) {
try (var ctx = new AnnotationConfigApplicationContext(Config.class)) {
var client = ctx.getBean(SmsClient.class);
System.out.println("调用 send -> " + client.send("13800000000"));
System.out.println("prototype " + ctx.getBean(OrderNoGenerator.class).hashCode()
+ " / " + ctx.getBean(OrderNoGenerator.class).hashCode());
System.out.println("singleton " + ctx.getBean(SmsClient.class).hashCode()
+ " / " + ctx.getBean(SmsClient.class).hashCode());
}
}
@Configuration
static class Config {
// static 方法:让这个后置处理器尽早注册,避免「is not eligible for getting processed」警告
@Bean
static BeanPostProcessor traceBpp() {
return new BeanPostProcessor() {
@Override
public Object postProcessBeforeInitialization(Object bean, String name) {
// 只观察示例里的两个 Bean,配置类自己也会被后置处理器扫到,打出来只是噪音
if (name.startsWith("sms")) {
System.out.println("4 BPP-before " + name);
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String name) {
if (name.startsWith("sms")) {
System.out.println("8 BPP-after " + name
+ " -> " + bean.getClass().getSimpleName());
}
return bean;
}
};
}
@Bean(initMethod = "openChannel", destroyMethod = "closeChannel")
SmsClient smsClient() {
return new SmsClient();
}
@Bean
@Scope("prototype")
OrderNoGenerator orderNoGenerator() {
return new OrderNoGenerator();
}
@Bean
SmsProperties smsProperties() {
return new SmsProperties("mqxu");
}
}
record SmsProperties(String sign) {
}
static class SmsClient implements InitializingBean, DisposableBean {
private SmsProperties props;
SmsClient() {
System.out.println("1 构造器");
}
@Autowired
void setProps(SmsProperties props) {
this.props = props;
System.out.println("2 setter 注入 sign=" + props.sign());
}
@PostConstruct
void init() {
System.out.println("5 @PostConstruct");
}
@Override
public void afterPropertiesSet() {
System.out.println("6 afterPropertiesSet");
}
void openChannel() {
System.out.println("7 init-method openChannel");
}
String send(String phone) {
return "sent by " + props.sign() + " to " + phone;
}
@PreDestroy
void shutdown() {
System.out.println("10 @PreDestroy");
}
@Override
public void destroy() {
System.out.println("11 DisposableBean.destroy");
}
void closeChannel() {
System.out.println("12 destroy-method closeChannel");
}
}
static class OrderNoGenerator {
OrderNoGenerator() {
System.out.println(" prototype 新建一个");
}
}
}运行结果(mvn -q compile exec:java -Dexec.mainClass=com.example.core.LifecycleDemo):
1 构造器
4 BPP-before smsProperties
8 BPP-after smsProperties -> SmsProperties
2 setter 注入 sign=mqxu
4 BPP-before smsClient
5 @PostConstruct
6 afterPropertiesSet
7 init-method openChannel
8 BPP-after smsClient -> SmsClient
调用 send -> sent by mqxu to 13800000000
prototype 新建一个
prototype 新建一个
prototype 1067 / 2093
singleton 3312 / 3312
10 @PreDestroy
11 DisposableBean.destroy
12 destroy-method closeChannel注意两件事。smsProperties 的 4 和 8 出现在 1 构造器 之后,因为属性注入发生在这时,被依赖的 Bean 才顺带创建。第 3 站(Aware 回调)没有打印,因为这个示例没实现 BeanNameAware 之类的接口。最后两行哈希值一样,说明单例是同一份;prototype 两次不一样,而且销毁阶段只跑了单例的。
第二步:看两种代理,以及 this 调用为什么绕过去
代码 1-2 用两个配置类跑同一个切面,一个走 JDK 代理,一个强制 CGLIB,顺便验证同类内部调用。
package com.example.core;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.aop.support.AopUtils;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
public class ProxyDemo {
public static void main(String[] args) {
report("默认(proxyTargetClass=false)", JdkConfig.class);
report("proxyTargetClass=true", CglibConfig.class);
}
static void report(String label, Class<?> config) {
try (var ctx = new AnnotationConfigApplicationContext(config)) {
System.out.println(label);
print(" paymentGateway", ctx.getBean(PaymentGateway.class));
print(" orderService ", ctx.getBean(OrderService.class));
System.out.println(" 调用 placeInner(SO2),它内部用 this 调 place");
ctx.getBean(OrderService.class).placeInner("SO2");
}
}
static void print(String label, Object bean) {
System.out.println(label + " jdk=" + AopUtils.isJdkDynamicProxy(bean)
+ " cglib=" + AopUtils.isCglibProxy(bean));
}
@Configuration
@EnableAspectJAutoProxy
static class JdkConfig extends BeanDefs {
}
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
static class CglibConfig extends BeanDefs {
}
static abstract class BeanDefs {
@Bean
PaymentGateway paymentGateway() {
return new PaymentGatewayImpl();
}
@Bean
OrderService orderService() {
return new OrderService();
}
@Bean
TimingAspect timingAspect() {
return new TimingAspect();
}
}
interface PaymentGateway {
String pay(String orderNo);
}
static class PaymentGatewayImpl implements PaymentGateway {
@Timed
@Override
public String pay(String orderNo) {
return "paid:" + orderNo;
}
}
static class OrderService {
@Timed
public String place(String orderNo) {
return "created:" + orderNo;
}
@Timed
public String placeInner(String orderNo) {
return place(orderNo); // this 调用,不经过代理
}
}
@Aspect
static class TimingAspect {
@Around("@annotation(timed)")
public Object around(ProceedingJoinPoint pjp, Timed timed) throws Throwable {
System.out.println(" [切面] 进入 " + pjp.getSignature().getName());
try {
return pjp.proceed();
} finally {
System.out.println(" [切面] 退出 " + pjp.getSignature().getName());
}
}
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Timed {
}
}运行结果:
默认(proxyTargetClass=false)
paymentGateway jdk=true cglib=false
orderService jdk=false cglib=true
调用 placeInner(SO2),它内部用 this 调 place
[切面] 进入 placeInner
[切面] 退出 placeInner
proxyTargetClass=true
paymentGateway jdk=false cglib=true
orderService jdk=false cglib=true
调用 placeInner(SO2),它内部用 this 调 place
[切面] 进入 placeInner
[切面] 退出 placeInner两个结论。PaymentGateway 有接口,默认走 JDK 代理,加 proxyTargetClass=true 才换成 CGLIB。placeInner 里调 place,切面只打印了一对进出——内层调用走的是 this,也就是原始对象,代理没有参与。这类失效不报错,日志里只是少了一行,靠日志数对不上才发现。
第三步:让循环依赖失败一次
把 OrderService 与 InventoryService 的依赖改成双方都用构造器注入,再启动。
# CircularDemo:OrderService 构造器要 InventoryService,InventoryService 构造器要 OrderService
mvn -q compile exec:java -Dexec.mainClass=com.example.core.CircularDemo预期输出(节选,堆栈省略):
Exception in thread "main" org.springframework.beans.factory.BeanCurrentlyInCreationException:
Error creating bean with name 'orderService': Requested bean is currently in creation:
Is there an unresolvable circular reference?把两边都改成 setter 注入,这个纯 Spring 工程能起来。同样的代码搬进 Boot 4,spring.main.allow-circular-references 默认 false,启动直接失败,报错是同一句。写这段的目的不是让你记住怎么打开开关,而是让你在自己项目里第一次遇到这个异常时,能立刻判断它属于构造器循环还是 setter 循环——两者的改法不同。
常见误解
很多人以为「容器里的对象都是单例」。实际上默认作用域是 singleton,但 prototype 每次都是新实例,而且它被注入到单例里时只发生一次;容器也不调用 prototype 的 @PreDestroy。判断一个 Bean 的作用域,看的是它被谁、在什么时机取的,不是看它有没有加 @Component。
很多人以为「@PostConstruct 里调用自己带 @Transactional 的方法是安全的」。实际上那时依赖还没注入完只是次要原因,主因是 this 调用不经过代理,事务注解根本不参与。任何同类内部调用都会被代理漏掉,这条在《事务管理:传播行为、隔离级别与失效场景》还会出现一次。
很多人以为「Spring 解决了循环依赖」。实际上它只解决单例、setter 或字段注入这一种。构造器循环、prototype 循环都起不来,Boot 默认还额外关掉了 setter 这条路。遇到循环依赖先拆类,别先加配置。
小结
- 容器管三件事:谁来 new、依赖从哪来、什么时候销毁。BeanDefinition 是配方,注册来源只有组件扫描、
@Bean、@Import三条。 - 默认作用域是 singleton;prototype 注入进单例只发生一次,容器也不管它的销毁。
- 生命周期是一条固定的链:构造 → 注入 → Aware → BPP before →
@PostConstruct→afterPropertiesSet→ init-method → BPP after → 使用 →@PreDestroy→destroy→ destroy-method。代理要等第 8 站之后才存在。 - Spring AOP 是运行时代理。private、final、
this调用三类边界踩中都不报错,只是不生效。 - 三级缓存里放的是工厂,因为要在被调用时才决定返回原始对象还是代理;它只覆盖单例 setter 循环。
相关主题
手写这些 @Configuration 和 @Bean 很快撑不住:一个三十个依赖的服务,配置类能写到四百行,换个项目还得重写一遍。《Spring Boot 4 起步:自动配置、起步依赖与模块化》讲 Spring Boot 4 的自动配置与模块化——这些配方怎么被条件化地替你写好,拆成模块之后出问题又该从哪个入口查起。