编辑“︁Bean生命周期（Spring框架）”︁

{{DISPLAYTITLE:Bean生命周期（Spring框架）}}

== 概述 ==
'''Bean生命周期'''是Spring框架中描述一个Bean从创建到销毁的完整过程的核心概念。理解Bean生命周期对于掌握Spring的依赖注入（DI）、AOP以及容器管理机制至关重要。Spring通过回调接口和注解提供了多个扩展点，允许开发者在Bean生命周期的不同阶段插入自定义逻辑。

== 生命周期阶段 ==
Spring Bean的生命周期可分为以下主要阶段（以基于XML的配置为例）：

<mermaid>
graph TD
    A[实例化] --> B[属性赋值]
    B --> C[BeanNameAware.setBeanName]
    C --> D[BeanFactoryAware.setBeanFactory]
    D --> E[ApplicationContextAware.setApplicationContext]
    E --> F[BeanPostProcessor.postProcessBeforeInitialization]
    F --> G[@PostConstruct]
    G --> H[InitializingBean.afterPropertiesSet]
    H --> I[init-method]
    I --> J[BeanPostProcessor.postProcessAfterInitialization]
    J --> K[使用阶段]
    K --> L[@PreDestroy]
    L --> M[DisposableBean.destroy]
    M --> N[destroy-method]
</mermaid>

=== 详细阶段说明 ===
==== 1. 实例化 ====
通过构造器或工厂方法创建Bean实例：
<syntaxhighlight lang="java">
// 等价于 <bean class="com.example.MyBean"/>
public class MyBean {
    public MyBean() {
        System.out.println("1. 实例化");
    }
}
</syntaxhighlight>

==== 2. 属性赋值 ====
Spring通过依赖注入设置属性值：
<syntaxhighlight lang="xml">
<bean class="com.example.MyBean">
    <property name="message" value="Hello"/>
</bean>
</syntaxhighlight>

==== 3. Aware接口回调 ====
若Bean实现了Aware接口，会依次触发：
<syntaxhighlight lang="java">
public class MyBean implements BeanNameAware {
    @Override
    public void setBeanName(String name) {
        System.out.println("3. BeanNameAware: " + name);
    }
}
</syntaxhighlight>

==== 4. 初始化前处理 ====
{{注意|BeanPostProcessor是全局处理器，会作用到所有Bean}}
<syntaxhighlight lang="java">
public class MyPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String name) {
        System.out.println("4. BeforeInit: " + name);
        return bean;
    }
}
</syntaxhighlight>

==== 5. 初始化阶段 ====
按顺序执行三种初始化方式：
* '''@PostConstruct'''注解方法
* '''InitializingBean'''接口的<code>afterPropertiesSet()</code>
* XML中定义的<code>init-method</code>

<syntaxhighlight lang="java">
public class MyBean {
    @PostConstruct
    public void postConstruct() {
        System.out.println("5.1 @PostConstruct");
    }

    public void customInit() {
        System.out.println("5.3 init-method");
    }
}
</syntaxhighlight>

==== 6. 初始化后处理 ====
<syntaxhighlight lang="java">
public class MyPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String name) {
        System.out.println("6. AfterInit: " + name);
        return bean;
    }
}
</syntaxhighlight>

==== 7. 销毁阶段 ====
容器关闭时执行销毁操作，顺序与初始化相反：
* '''@PreDestroy'''注解方法
* '''DisposableBean'''接口的<code>destroy()</code>
* XML中定义的<code>destroy-method</code>

== 完整示例 ==
=== 配置类 ===
<syntaxhighlight lang="java">
@Configuration
public class AppConfig {
    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    public LifecycleBean lifecycleBean() {
        return new LifecycleBean();
    }

    @Bean
    public static MyPostProcessor postProcessor() {
        return new MyPostProcessor();
    }
}
</syntaxhighlight>

=== 执行结果 ===
<pre>
1. 实例化
2. 属性赋值
3. BeanNameAware: lifecycleBean
4. BeforeInit: lifecycleBean
5.1 @PostConstruct
5.2 afterPropertiesSet
5.3 init-method
6. AfterInit: lifecycleBean
... [使用阶段] ...
@PreDestroy
DisposableBean.destroy
customDestroy
</pre>

== 生命周期扩展机制 ==
=== 通过接口 ===
{| class="wikitable"
|-
! 接口 !! 方法 !! 说明
|-
| <code>BeanPostProcessor</code> || <code>postProcessBefore/AfterInitialization</code> || 全局处理器
|-
| <code>InstantiationAwareBeanPostProcessor</code> || <code>postProcessBeforeInstantiation</code> || 实例化前干预
|}

=== 通过注解 ===
* <code>@PostConstruct</code> / <code>@PreDestroy</code> (JSR-250)
* <code>@Bean(initMethod/destroyMethod)</code>

== 实际应用场景 ==
'''案例：数据库连接池初始化'''
1. <code>@PostConstruct</code>中建立初始连接
2. <code>@PreDestroy</code>中关闭所有连接

<syntaxhighlight lang="java">
public class ConnectionPool {
    @PostConstruct
    public void init() {
        // 创建10个初始连接
    }

    @PreDestroy
    public void cleanup() {
        // 关闭所有连接
    }
}
</syntaxhighlight>

== 常见问题 ==
{{问答
|问题 = 为什么建议使用注解而非接口实现生命周期回调？
|答案 = 注解方式（如@PostConstruct）减少了代码与Spring API的耦合，且符合JSR标准，便于移植到其他DI容器。
}}

{{问答
|问题 = BeanPostProcessor的执行顺序如何控制？
|答案 = 实现<code>Ordered</code>接口或使用<code>@Order</code>注解，数值越小优先级越高。
}}

== 数学表示 ==
生命周期阶段可形式化为有序集合：
<math>
L = \\{Instantiation, Population, AwareCallbacks, PreInit, Init, PostInit, Usage, PreDestroy, Destruction\\}
</math>

[[Category:计算机科学]]
[[Category:面试技巧]]
[[Category:Spring框架]]