Spring IoC容器深度解析：Bean生命周期与依赖注入原理

最新推荐文章于 2025-10-19 23:56:33 发布

原创最新推荐文章于 2025-10-19 23:56:33 发布 · 1.6k 阅读

28 ·

CC 4.0 BY-SA版权

文章标签：

#Spring #IoC #DI #Bean生命周期 #ApplicationContext #BeanPostProcessor

Java常见面试题专栏收录该内容

6 篇文章

订阅专栏

Spring IoC容器深度解析：Bean生命周期与依赖注入原理

1. Spring IoC容器概述与控制反转理念

Spring IoC（Inversion of Control，控制反转）容器是Spring框架的核心。它通过IoC思想，将对象的创建、依赖关系的管理从程序代码中解耦出来，交由容器统一管理。开发者只需定义对象之间的依赖关系，而具体的实例化和组装工作由IoC容器完成。这种机制极大提升了系统的可维护性、可扩展性和测试性。

IoC的核心理念是“依赖倒置”，即高层模块不依赖于低层模块，而是通过接口进行交互。Spring容器通过读取配置文件或注解，扫描、实例化、配置和组装Bean对象，实现了对象之间的松耦合。IoC不仅仅是对象的简单管理，更包括了生命周期管理、依赖注入（Dependency Injection, DI）、AOP等高级特性。

Spring提供了多种IoC容器实现，最常用的是ApplicationContext，它在BeanFactory基础上扩展了国际化、事件发布、AOP集成等功能。开发者只需将Bean的元数据交给容器，IoC容器便会自动处理对象的生命周期和依赖注入，极大简化了企业级应用的开发流程。

2. ApplicationContext启动流程与源码分析

在Spring应用中，ApplicationContext是最常用的IoC容器接口，其实现如ClassPathXmlApplicationContext、AnnotationConfigApplicationContext等负责加载Bean定义、实例化Bean、依赖注入、生命周期管理等全过程。其启动流程大致如下：

ApplicationContext启动流程

加载配置：读取XML、注解或Java配置，解析为Bean定义。
创建BeanFactory：构建底层的BeanFactory容器。
注册Bean定义：将Bean定义注册到BeanDefinitionMap中。
BeanFactory后置处理：调用BeanFactoryPostProcessor，对BeanFactory进行自定义扩展。
注册BeanPostProcessor：注册所有BeanPostProcessor，以便后续Bean生命周期回调。
预实例化单例Bean：实例化并初始化所有非懒加载的单例Bean。

核心源码分析

以AnnotationConfigApplicationContext为例，其构造函数和refresh()方法是启动的核心：

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    this();
    register(annotatedClasses);
    refresh();
}

public void refresh() throws BeansException, IllegalStateException {
    // 1. 准备容器环境
    prepareRefresh();
    // 2. 获取BeanFactory
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    // 3. 注册BeanFactory的后置处理器
    invokeBeanFactoryPostProcessors(beanFactory);
    // 4. 注册Bean的后置处理器
    registerBeanPostProcessors(beanFactory);
    // 5. 初始化MessageSource等国际化组件
    initMessageSource();
    // 6. 初始化事件广播器
    initApplicationEventMulticaster();
    // 7. 初始化其他特殊Bean
    onRefresh();
    // 8. 注册监听器
    registerListeners();
    // 9. 实例化所有非懒加载单例Bean
    finishBeanFactoryInitialization(beanFactory);
    // 10. 完成刷新
    finishRefresh();
}

其中finishBeanFactoryInitialization(beanFactory)会触发所有单例Bean的实例化和初始化。

流程图

flowchart TD
    A[启动ApplicationContext] --> B[准备容器环境]
    B --> C[创建BeanFactory]
    C --> D[注册Bean定义]
    D --> E[BeanFactoryPostProcessor扩展]
    E --> F[注册BeanPostProcessor]
    F --> G[国际化、事件等初始化]
    G --> H[预实例化单例Bean]
    H --> I[容器可用]

3. Bean完整生命周期：实例化、初始化、销毁

Spring IoC容器为每个Bean管理完整的生命周期，包括实例化、属性填充、初始化、销毁等多个阶段。理解Bean的生命周期，有助于在实际开发中进行个性化扩展和资源管理。

Bean生命周期的主要阶段

实例化（Instantiation）：通过构造函数或工厂方法创建Bean实例。
属性赋值（Populate Properties）：将配置文件或注解中的属性值注入到Bean实例。
BeanNameAware、BeanFactoryAware等回调：感知自身BeanName、所属容器等。
BeanPostProcessor的before回调：所有注册的BeanPostProcessor的postProcessBeforeInitialization方法依次调用。
初始化（InitializingBean/自定义init-method）：执行afterPropertiesSet()或自定义初始化方法。
BeanPostProcessor的after回调：所有BeanPostProcessor的postProcessAfterInitialization方法依次调用。
可用（In Use）：Bean被容器和应用正常使用。
销毁（DisposableBean/自定义destroy-method）：容器关闭时执行销毁方法。

生命周期流程图

flowchart LR
    A[实例化] --> B[属性赋值]
    B --> C[BeanNameAware/BeanFactoryAware]
    C --> D[BeanPostProcessor.before]
    D --> E[初始化方法]
    E --> F[BeanPostProcessor.after]
    F --> G[可用状态]
    G --> H[销毁]

关键源码解析

Spring的AbstractAutowireCapableBeanFactory中的doCreateBean()方法，主导了Bean的完整生命周期：

protected Object doCreateBean(...) {
    // 1. 实例化Bean
    beanInstance = createBeanInstance(...);
    // 2. 依赖注入
    populateBean(...);
    // 3. 初始化
    exposedObject = initializeBean(...);
    return exposedObject;
}

protected Object initializeBean(...) {
    // 1. 执行Aware接口回调
    // 2. BeanPostProcessor.before
    // 3. 执行初始化方法
    // 4. BeanPostProcessor.after
}

生命周期钩子示例

@Component
public class DemoBean implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() {
        System.out.println("Bean初始化完成");
    }
    @Override
    public void destroy() {
        System.out.println("Bean已销毁");
    }
}

实际应用案例

在实际项目中，可以通过实现InitializingBean、DisposableBean或指定init/destroy方法来管理数据库连接、线程池等资源。例如：

@Bean(initMethod="init", destroyMethod="cleanup")
public DataSource dataSource() {
    ...
}

4. 依赖注入实现原理与循环依赖解决

依赖注入（DI）的底层实现

Spring的依赖注入通过反射机制，将Bean的属性或构造器参数赋值。容器在填充属性前，首先解析Bean的依赖关系，然后递归创建依赖Bean。依赖注入有三种方式：

构造器注入
Setter方法注入
字段注入（@Autowired）

DI源码核心

依赖注入主要在populateBean()方法中实现。以字段注入为例：

protected void populateBean(...) {
    // 遍历属性，解析@Autowired等注解
    // 通过反射赋值依赖Bean
}

循环依赖的三种级别

构造器循环依赖：A依赖B，B依赖A，均为构造器注入，Spring无法处理，会抛出异常。
Setter/字段循环依赖：A依赖B，B依赖A，均为Setter或字段注入，Spring通过三级缓存解决。

三级缓存原理

Spring在创建Bean时，借助三级缓存（singletonsCurrentlyInCreation、earlySingletonObjects、singletonFactories）解决循环依赖：

一级缓存（singletonObjects）：存储完全初始化的单例Bean。
二级缓存（earlySingletonObjects）：存储原始未初始化完成的Bean引用。
三级缓存（singletonFactories）：存储Bean工厂对象，可提前暴露代理对象。

核心实现片段：

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

实际示例

@Component
class A {
    @Autowired
    B b;
}
@Component
class B {
    @Autowired
    A a;
}

此时Spring通过三级缓存，保证了A、B的依赖注入能够顺利完成。

5. BeanPostProcessor扩展点与自定义处理器

BeanPostProcessor是Spring IoC容器中最重要的扩展点之一，允许开发者在Bean初始化前后进行自定义逻辑处理。常见用途包括：AOP代理、属性加密解密、自动注入等。

BeanPostProcessor接口

public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

Spring内置实现

AutowiredAnnotationBeanPostProcessor：处理@Autowired注解
CommonAnnotationBeanPostProcessor：处理@Resource等注解
ApplicationContextAwareProcessor：处理Aware接口
AnnotationAwareAspectJAutoProxyCreator：AOP代理实现

自定义BeanPostProcessor示例

@Component
public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("[Before] " + beanName);
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("[After] " + beanName);
        return bean;
    }
}