Spring IOC 源码深挖

2026-11-01

IOC 是 Spring 的根基,掌握「容器体系 + refresh 流程 + Bean 生命周期」三层,就能把 IOC 讲透。本文带你逐层看源码。


一、什么是 IOC / DI

考察点:概念 + 能举例。

  • IOC(控制反转):把「对象创建和依赖管理」的控制权从对象本身交给容器,对象不再自己 new 依赖。
  • DI(依赖注入):IOC 的具体实现方式,容器把依赖「注入」给对象。
// 传统:对象自己创建依赖(强耦合)
public class OrderService {
    private UserService userService = new UserService();
}

// IOC:依赖由容器注入(解耦)
@Service
public class OrderService {
    @Autowired
    private UserService userService; // 容器注入
}

好处:解耦、易测试、易扩展、统一管理生命周期。


二、IOC 容器的体系结构

考察点:BeanFactory → ApplicationContext 的继承关系,能画图。

graph TD
    BF["BeanFactory<br/>getBean 顶层接口"]
    BF --> LB["ListableBeanFactory<br/>可列举 Bean"]
    BF --> HB["HierarchicalBeanFactory<br/>父子容器"]
    BF --> AB["AutowireCapableBeanFactory<br/>自动装配"]
    HB --> CB["ConfigurableBeanFactory"]
    LB --> CLB["ConfigurableListableBeanFactory"]
    AB --> CLB
    CB --> CLB
    CLB --> DLB["DefaultListableBeanFactory<br/>核心实现"]
    style BF fill:#e8f4fd
    style DLB fill:#e6f7e6

两个核心概念:

  1. BeanFactory:最底层的容器,提供 getBean,懒加载。
  2. ApplicationContext:BeanFactory 的增强,提供国际化、事件、资源加载、AOP 等,启动时预加载单例。
// ApplicationContext 继承了多个接口
public interface ApplicationContext extends ListableBeanFactory,
    HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher,
    ResourcePatternResolver { }

面试常问:BeanFactory 是「基础容器」,ApplicationContext 是「高级容器」,实际开发都用后者。


三、BeanDefinition

考察点:Bean 在容器中的「元数据」描述。

Bean 注册到容器时,被包装成 BeanDefinition,记录:

  • Bean 的类名(className)。
  • 作用域(scope:singleton/prototype)。
  • 是否懒加载(lazyInit)。
  • 依赖、构造参数、属性。
  • 初始化/销毁方法。
  • 是否 primary、是否 abstract 等。
// BeanDefinition 的核心属性(简化)
public interface BeanDefinition {
    String getBeanClassName();
    String getScope();          // singleton / prototype
    boolean isLazyInit();
    String getInitMethodName();
    String getDestroyMethodName();
    boolean isPrimary();
    // ...
}

四、Bean 的注册

考察点:BeanDefinitionRegistry。

// 默认注册中心 DefaultListableBeanFactory 实现
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
    // 存入 beanDefinitionMap(ConcurrentHashMap)
    this.beanDefinitionMap.put(beanName, beanDefinition);
    // 记录 Bean 名称列表
    this.beanDefinitionNames.add(beanName);
}
  • 所有 BeanDefinition 存在 beanDefinitionMap 中。
  • 注解扫描(@ComponentScan)最终也是调 registerBeanDefinition 注册。

五、容器启动:refresh() 流程

考察点:refresh 是 Spring 容器启动的核心,12+ 个步骤。

public void refresh() {
    prepareRefresh();                        // 1. 预处理(校验必要属性)
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 2. 获取 BeanFactory
    prepareBeanFactory(beanFactory);         // 3. 设置类加载器、SpEL 等
    postProcessBeanFactory(beanFactory);     // 4. 子类扩展点(模板方法)
    invokeBeanFactoryPostProcessors(beanFactory); // 5. 执行 BeanFactoryPostProcessor ⭐
    registerBeanPostProcessors(beanFactory);      // 6. 注册 BeanPostProcessor ⭐
    initMessageSource();                     // 7. 国际化
    initApplicationEventMulticaster();       // 8. 事件广播器
    onRefresh();                             // 9. 子类扩展(SpringBoot 建 Tomcat)
    registerListeners();                     // 10. 注册监听器
    finishBeanFactoryInitialization(beanFactory); // 11. 实例化所有单例 Bean ⭐
    finishRefresh();                         // 12. 发布刷新完成事件
}
graph TD
    A["prepareRefresh"] --> B["obtainFreshBeanFactory"]
    B --> C["prepareBeanFactory"]
    C --> D["postProcessBeanFactory"]
    D --> E["invokeBeanFactoryPostProcessors<br/>处理@Configuration/@ComponentScan"]
    E --> F["registerBeanPostProcessors"]
    F --> G["initMessageSource / EventMulticaster"]
    G --> H["registerListeners"]
    H --> I["finishBeanFactoryInitialization<br/>实例化所有单例Bean"]
    I --> J["finishRefresh"]
    style E fill:#fff3cd
    style I fill:#e6f7e6

三个最关键步骤:

  1. invokeBeanFactoryPostProcessors:执行 ConfigurationClassPostProcessor,扫描 @ComponentScan、解析 @Configuration、@Import、@Bean。
  2. registerBeanPostProcessors:注册 AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor 等。
  3. finishBeanFactoryInitialization:遍历 beanDefinitionNames,实例化所有非懒加载单例 Bean。

六、Bean 的获取流程

考察点:getBean → doGetBean 的完整链路。

protected <T> T doGetBean(String name, ...) {
    // ① 先从三级缓存拿(可处理循环依赖)
    Object bean = getSingleton(beanName);
    if (bean != null) return (T) bean;

    // ② 合并 BeanDefinition(处理父子定义)
    RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

    // ③ 单例创建(getSingleton 内部调用 createBean)
    if (mbd.isSingleton()) {
        sharedInstance = getSingleton(beanName, () -> createBean(beanName, mbd, args));
    }
    return sharedInstance;
}

三级缓存 getSingleton 详见 Spring循环依赖源码深挖.md。


七、Bean 的创建流程:doCreateBean

考察点:实例化 → 属性填充 → 初始化 三步。

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    // ① 实例化(构造器创建,此时属性都为空)
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
    Object bean = instanceWrapper.getWrappedInstance();

    // ② 提前暴露到三级缓存(处理循环依赖)
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

    // ③ 属性填充(依赖注入)
    populateBean(beanName, mbd, instanceWrapper);

    // ④ 初始化(Aware 回调 + BeanPostProcessor + init 方法)
    Object exposedObject = initializeBean(beanName, exposedObject, mbd);

    return exposedObject;
}
graph LR
    A["① 实例化<br/>createBeanInstance"] --> B["② 加入三级缓存"]
    B --> C["③ 属性填充<br/>populateBean 依赖注入"]
    C --> D["④ 初始化<br/>initializeBean"]
    style A fill:#fff3cd
    style C fill:#e6f7e6
    style D fill:#e8f4fd

八、Bean 生命周期(完整版)

考察点:面试最高频之一,能完整背出。

graph TD
    A["实例化(构造器)"] --> B["属性填充(依赖注入)"]
    B --> C["BeanNameAware"]
    C --> D["BeanFactoryAware"]
    D --> E["ApplicationContextAware"]
    E --> F["BeanPostProcessor.postProcessBeforeInitialization"]
    F --> G["@PostConstruct"]
    G --> H["InitializingBean.afterPropertiesSet"]
    H --> I["init-method"]
    I --> J["BeanPostProcessor.postProcessAfterInitialization<br/>AOP 代理在这里创建"]
    J --> K["使用中"]
    K --> L["@PreDestroy"]
    L --> M["DisposableBean.destroy"]
    M --> N["destroy-method"]
    style F fill:#fff3cd
    style J fill:#e6f7e6
// 生命周期各阶段对应代码
@Component
public class MyBean implements BeanNameAware, BeanFactoryAware,
        ApplicationContextAware, InitializingBean, DisposableBean {

    @Autowired
    private UserService userService;   // ② 属性填充

    public void setBeanName(String name) { }                       // ③ Aware
    public void setBeanFactory(BeanFactory bf) { }                 // ④ Aware
    public void setApplicationContext(ApplicationContext ac) { }   // ⑤ Aware

    @PostConstruct
    public void postConstruct() { }    // ⑦ 初始化

    public void afterPropertiesSet() { }  // ⑧ InitializingBean

    public void initMethod() { }       // ⑨ init-method

    @PreDestroy
    public void preDestroy() { }       // ⑫ 销毁

    public void destroy() { }          // ⑬ DisposableBean
}

九、BeanPostProcessor 的作用

考察点:AOP、@Autowired 都是靠它实现。

BeanPostProcessor 是 Bean 级后处理器,在每个 Bean 初始化前后做增强:

public interface BeanPostProcessor {
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;  // 初始化前
    }
    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;  // 初始化后(AOP 在这里生成代理)
    }
}

典型实现:

  • AutowiredAnnotationBeanPostProcessor:处理 @Autowired、@Value 注入。
  • CommonAnnotationBeanPostProcessor:处理 @PostConstruct、@PreDestroy、@Resource。
  • AnnotationAwareAspectJAutoProxyCreator:创建 AOP 代理。
// 自定义 BeanPostProcessor
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (bean instanceof OrderService) {
            System.out.println("OrderService 初始化前处理");
        }
        return bean;
    }
}

十、BeanFactoryPostProcessor vs BeanPostProcessor

考察点:两个高频混淆的概念。

对比BeanFactoryPostProcessorBeanPostProcessor
作用对象容器级,操作 BeanDefinitionBean 级,操作 Bean 实例
时机Bean 实例化前Bean 初始化前后
典型实现ConfigurationClassPostProcessor(扫描注解)AutowiredAnnotationBeanPostProcessor(注入)
用途修改 Bean 定义、处理占位符依赖注入、AOP 代理

记忆:Factory 在前(改定义),Bean 在后(改实例)。


十一、注解驱动:@ComponentScan 如何工作

考察点:注解扫描的底层。

  1. refresh() 第 5 步执行 ConfigurationClassPostProcessor(一个 BeanFactoryPostProcessor)。
  2. 它识别 @Configuration 类,解析 @ComponentScan。
  3. 扫描包下所有 @Component(含 @Service/@Repository/@Controller)。
  4. 把扫描到的类包装成 BeanDefinition 并注册。
@Configuration
@ComponentScan("com.example")   // 扫描该包下的组件
public class AppConfig {
    @Bean
    public DataSource dataSource() {
        return new DataSource();
    }
}

十二、依赖注入的方式

考察点:三种注入方式的对比。

方式注解特点
构造器注入构造方法参数依赖不可变,推荐,可解决 final 依赖
Setter 注入@Autowired 方法可选依赖,可重新配置
字段注入@Autowired 字段简洁,但不利于测试、隐藏依赖
// 构造器注入(推荐,可加 final)
@Service
public class OrderService {
    private final UserService userService;
    public OrderService(UserService userService) {
        this.userService = userService;
    }
}

十三、面试话术总结

面试官问「讲讲 Spring IOC」,按这个层次答:

  1. 概念:IOC 把对象创建和依赖管理交给容器,DI 是注入方式,好处是解耦。

  2. 容器体系:BeanFactory 是基础容器(getBean、懒加载),ApplicationContext 是其增强(国际化、事件、AOP、预加载单例),核心实现是 DefaultListableBeanFactory。

  3. BeanDefinition:Bean 注册时包装成 BeanDefinition,存类名、作用域、懒加载等元数据。

  4. refresh 流程:容器启动执行 refresh,关键三步是「执行 BeanFactoryPostProcessor 扫描注解 → 注册 BeanPostProcessor → 实例化所有单例 Bean」。

  5. Bean 生命周期:实例化 → 属性填充 → Aware 回调 → BeanPostProcessor 前置 → 初始化(@PostConstruct/afterPropertiesSet/init-method)→ BeanPostProcessor 后置(AOP 代理)→ 使用 → 销毁。

  6. BeanPostProcessor:AOP、@Autowired 都靠它实现,是 Spring 的扩展核心。