当前位置：首页 > article >正文

SpringBean生命周期的执行流程

article 2025/2/24 20:48:02

Spring Bean 的生命周期是 Spring 框架中最核心的机制之一，它定义了 Bean 从创建到销毁的完整过程。以下是其执行流程的详细总结（以 Singleton 作用域为例）：

一、Bean 生命周期核心流程

1. Bean 元信息加载

BeanDefinition 加载
通过 ClassPathScanning、XML 配置或 @Bean 注解等方式，将 Bean 的定义信息解析为 BeanDefinition 对象，存储在 BeanFactory 中。
```
// 例如：通过 @Component 注解扫描的类会生成 BeanDefinition
```

2. Bean 实例化阶段

构造器调用
调用 Bean 的构造函数（或工厂方法），创建 Bean 的实例对象。
```
public class MyBean {
    public MyBean() { /* 构造器逻辑 */ }
}
```

BeanPostProcessor 前置处理
调用 BeanPostProcessor.postProcessBeforeInitialization() 方法，允许在 Bean 初始化前修改实例。

// 示例：通过 BeanPostProcessor 修改 Bean 属性
public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        // 修改 Bean 的逻辑
        return bean;
    }
}

3. 依赖注入阶段

属性赋值（Setter/Field 注入）
通过 @Autowired、@Value 或 XML 配置的 <property> 标签，为 Bean 的属性赋值。
```
public class MyBean {
    @Autowired
    private Dependency dependency;
}
```
Aware 接口回调
如果 Bean 实现了 Aware 接口（如 BeanNameAware、ApplicationContextAware），Spring 会调用对应方法注入上下文信息。
```
public class MyBean implements BeanNameAware {
    @Override
    public void setBeanName(String name) {
        // 获取 Bean 的名称
    }
}
```

4. 初始化阶段

@PostConstruct 注解方法
调用标记了 @PostConstruct 注解的方法。

public class MyBean {
    @PostConstruct
    public void init() { /* 初始化逻辑 */ }
}

InitializingBean 接口
如果 Bean 实现了 InitializingBean 接口，调用 afterPropertiesSet() 方法。

public class MyBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() { /* 初始化逻辑 */ }
}

自定义 init-method
调用通过 XML 配置或 @Bean(initMethod = "customInit") 指定的自定义初始化方法。
```
public class MyBean {
    public void customInit() { /* 自定义初始化逻辑 */ }
}
```

BeanPostProcessor 后置处理
调用 BeanPostProcessor.postProcessAfterInitialization() 方法，允许在 Bean 初始化后修改实例（如 AOP 代理的生成）。

public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // 返回可能的代理对象
        return bean;
    }
}

5. Bean 使用阶段

Bean 就绪
此时 Bean 已被 Spring 容器管理，可通过 ApplicationContext.getBean() 获取并使用。

6. 销毁阶段

@PreDestroy 注解方法
调用标记了 @PreDestroy 注解的方法（仅在容器关闭时触发）。
```
public class MyBean {
    @PreDestroy
    public void preDestroy() { /* 销毁前逻辑 */ }
}
```

DisposableBean 接口
如果 Bean 实现了 DisposableBean 接口，调用 destroy() 方法。

public class MyBean implements DisposableBean {
    @Override
    public void destroy() { /* 销毁逻辑 */ }
}

自定义 destroy-method
调用通过 XML 配置或 @Bean(destroyMethod = "customDestroy") 指定的自定义销毁方法。
```
public class MyBean {
    public void customDestroy() { /* 自定义销毁逻辑 */ }
}
```

二、生命周期流程图

plaintext

BeanDefinition 加载 → 实例化（构造器） → BeanPostProcessor 前置处理 → 依赖注入 → Aware 接口回调 → 
@PostConstruct → InitializingBean → init-method → BeanPostProcessor 后置处理 → Bean 就绪 → 
@PreDestroy → DisposableBean → destroy-method

三、关键扩展点

扩展点	说明
`BeanPostProcessor`	在 Bean 初始化前后插入自定义逻辑（如 AOP 代理生成）。
`BeanFactoryPostProcessor`	在 BeanDefinition 加载后、Bean 实例化前修改元数据（如修改属性值）。
`Aware 接口`	获取 Spring 底层资源（如 BeanName、ApplicationContext）。
`@PostConstruct/@PreDestroy`	通过注解定义初始化和销毁逻辑。
`InitializingBean/DisposableBean`	通过接口定义初始化和销毁逻辑。

四、特殊场景

Prototype Bean 的生命周期
- Spring 容器不管理 Prototype Bean 的销毁阶段，需手动处理资源释放。
循环依赖
- 通过三级缓存解决（singletonFactories、earlySingletonObjects、singletonObjects）。
懒加载（Lazy-init）
- 在首次请求时才会触发 Bean 的创建和初始化。