Skip to content

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 的实例差别。

java
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,顺便验证同类内部调用。

java
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 的依赖改成双方都用构造器注入,再启动。

bash
# 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 的自动配置与模块化——这些配方怎么被条件化地替你写好,拆成模块之后出问题又该从哪个入口查起。