【Spring】Spring Bean 管理：原理与生命周期全解析Spring Bean 管理：原理与生命周期全解析

一、核心管理原理

Spring 通过 IoC 容器（核心接口 BeanFactory）管理 Bean 的生命周期，实现控制反转（IoC） 和依赖注入（DI）：

public interface BeanFactory {
    Object getBean(String name);  // 核心获取Bean方法
    // ... 其他方法
}

典型容器实现：

• AnnotationConfigApplicationContext（注解驱动）
• ClassPathXmlApplicationContext（XML 驱动）

二、Bean 生命周期详解（8 大阶段）

流程图

初始化阶段

调用 Aware 接口

初始化

InitializingBean.afterPropertiesSet

自定义 init 方法

开始

实例化

属性赋值

BeanPostProcessor 前置处理

BeanPostProcessor 后置处理

使用期

销毁

结束

阶段详解与代码示例

1. 实例化（Instantiation）
   • 通过构造器/工厂方法创建对象

// 相当于执行：MyBean obj = new MyBean();

2. 属性赋值（Populate Properties）
   • 依赖注入（通过 @Autowired 或 XML 配置）

public class ServiceA {
    @Autowired  // DI在此阶段完成
    private ServiceB serviceB;
}

3. Aware 接口回调（BeanNameAware 等）
   • 获取容器信息

public class MyBean implements BeanNameAware {
    @Override
    public void setBeanName(String name) {
        System.out.println("Bean名称注入: " + name);
    }
}

4. BeanPostProcessor 前置处理
   • 自定义修改 Bean

public class CustomProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("前置处理: " + beanName);
        return bean;
    }
}

5. 初始化（Initialization）
   • 三选一执行：

// 方式1：InitializingBean 接口
public class MyBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() {
        System.out.println("InitializingBean 初始化");
    }
}

// 方式2：@PostConstruct 注解
public class MyBean {
    @PostConstruct
    public void init() {
        System.out.println("@PostConstruct 初始化");
    }
}

// 方式3：XML配置的 init-method
<bean id="myBean" class="com.MyBean" init-method="customInit"/>

6. BeanPostProcessor 后置处理
   • 生成代理对象的关键阶段（如 AOP）

public class CustomProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("后置处理: " + beanName);
        // AOP在此生成代理对象
        return Proxy.newProxyInstance(...); 
    }
}

7. 使用期（In Use）
   • Bean 处于服务状态

// 业务代码调用
context.getBean(MyService.class).execute();

8. 销毁（Destruction）
   • 容器关闭时触发

// 方式1：DisposableBean 接口
public class MyBean implements DisposableBean {
    @Override
    public void destroy() {
        System.out.println("DisposableBean 销毁");
    }
}

// 方式2：@PreDestroy 注解
public class MyBean {
    @PreDestroy
    public void customDestroy() {
        System.out.println("@PreDestroy 销毁");
    }
}

// 方式3：XML配置的 destroy-method
context.close();  // 触发销毁

三、关键扩展点总结

扩展点	执行时机	典型应用场景
BeanPostProcessor	初始化前后	AOP代理、性能监控
BeanFactoryPostProcessor	Bean定义加载后、实例化前	修改Bean定义（占位符解析）
Aware 接口族	初始化前	获取容器基础设施
生命周期接口	初始化/销毁时	资源初始化和清理

四、容器启动核心流程

// 示例容器启动代码
public class MainApp {
    public static void main(String[] args) {
        // 1. 创建容器（加载Bean定义）
        AnnotationConfigApplicationContext context = 
            new AnnotationConfigApplicationContext(AppConfig.class);
        
        // 2. 获取Bean（触发实例化&初始化）
        MyService service = context.getBean(MyService.class);
        
        // 3. 使用Bean
        service.execute();
        
        // 4. 关闭容器（触发销毁）
        context.close();
    }
}

五、设计模式应用

1. 模板方法模式：AbstractApplicationContext.refresh() 定义容器启动模板
2. 观察者模式：容器事件监听（ApplicationListener）
3. 工厂模式：BeanFactory 隐藏实例创建细节
4. 代理模式：AOP 实现的核心手段

最佳实践：优先使用注解（@PostConstruct, @PreDestroy）而非 Spring 接口，减少框架耦合度。对于复杂初始化逻辑，推荐实现 SmartInitializingSingleton 接口在完全启动后执行。