bean 的生命周期和扩展

原理总结

源码非常多，这里简单先记录一下。反射调用构造方法后

  1. 遍历所有属性，如果加了 @Autowired 就注入
  2. 如果类实现了 InitializingBean 就调用 afterPropertiesSet 方法
  3. 如果实现了 xxxAware 接口，调用对应的回调
  4. ......

生命周期整体流程

收集bean定义（123）、实例化（4）、初始化（56789）、使用（10）、销毁（11）

  1. 配置元数据读取：读取 XML、Java Config 或注解配置
  2. BeanDefinition 收集与注册：解析配置为 BeanDefinition 并注册到 BeanFactory
  3. BeanFactoryPostProcessor 执行：对 BeanDefinition 进行修改
  4. Bean 实例化：通过构造函数或工厂方法创建实例
  5. 属性填充（依赖注入）：设置属性和依赖
  6. Aware 接口回调
  7. BeanPostProcessor 前置处理
  8. 初始化方法调用：三种方式
  9. BeanPostProcessor 后置处理
  10. Bean 使用阶段
  11. 销毁阶段：调用销毁方法，对应初始化也有三种方式

完整生命周期流程图

flowchart LR %% 初始化阶段 A([容器启动]) --> B[加载配置元数据] B --> C[解析XML或JavaConfig并注册BeanDefinition] C --> D[执行BeanFactoryPostProcessor修改BeanDefinition] D --> E{懒加载?} E -->|否| F[根据BeanDefinition实例化Bean] F --> G[填充bean的属性（DI）] G --> H[处理Aware感知回调接口] H --> I[执行BeanPostProcessor.before] %% 初始化方法 I --> J1[调用@PostConstruct指定的初始化方法] J1 --> J2[调用InitializingBean接口的初始化方法（afterPropertiesSet）] J2 --> J3[调用init-method指定的初始化方法] %% 后置处理 J3 --> K[执行BeanPostProcessor.after] K --> L([Bean就绪]) %% 销毁阶段 M([容器关闭]) --> N1[调用@PreDestroy指定的销毁方法] N1 --> N2[调用DisposableBean接口的销毁方法（destroy）] N2 --> N3[调用destroy-method指定的销毁方法] %% 延迟初始化分支 E -->|是| Z[使用时初始化] Z --> F %% 样式定义 classDef green fill:#9f9,stroke:#090; classDef pink fill:#f9f,stroke:#c0c; classDef red fill:#f99,stroke:#c00; class A,L,M green class F,G,H,I,K pink class N1,N2,N3 red

关键扩展点总结

扩展点 类型 执行时机 应用
BeanFactoryPostProcessor 接口 BeanDefinition 加载后，实例化前 修改 BeanDefinition
BeanPostProcessor 接口 实例化后，初始化前后 修改 Bean
@PostConstruct 注解 初始化阶段(最先) 自定义初始化逻辑
InitializingBean 接口 初始化阶段 自定义初始化逻辑
init-method XML/Java配置 初始化阶段(最后) 自定义初始化逻辑
@PreDestroy 注解 销毁阶段(最先) 自定义销毁逻辑
DisposableBean 接口 销毁阶段 自定义销毁逻辑
destroy-method XML/Java配置 销毁阶段(最后) 自定义销毁逻辑

生命周期详细步骤

1. 【收集bean定义阶段】BeanDefinition 收集与注册

// 示例：通过注解收集 BeanDefinition
@Component
public class MyBean {
    //...
}
  • 通过类路径扫描(@ComponentScan)或手动注册
  • 每个 Bean 对应一个 BeanDefinition 对象
  • 存储在 DefaultListableBeanFactory 的 beanDefinitionMap 中

2. 【收集bean定义阶段】BeanFactoryPostProcessor 执行

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 可以修改或添加 BeanDefinition
    }
}

3. 【实例化阶段】Bean 实例化

  1. 实例化策略：

    • 通过反射调用构造函数
    • 或通过工厂方法(CGLIB 动态代理等)

  2. 解决循环依赖：

    • 三级缓存机制
    • 提前暴露 ObjectFactory

4. 【初始化阶段】属性填充（依赖注入）

@Component
public class MyBean {
    @Autowired
    private AnotherBean anotherBean;
    
    @Value("${some.property}")
    private String someProperty;
}

5. 【初始化阶段】Aware 接口回调

@Component
public class MyAwareBean implements BeanNameAware, ApplicationContextAware {
    @Override
    public void setBeanName(String name) {
        // 获取 Bean 名称
    }
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        // 获取 ApplicationContext
    }
}

常用 Aware 接口：

  • BeanNameAware: 获取 Bean 名称
  • BeanClassLoaderAware: 获取类加载器
  • BeanFactoryAware: 获取 BeanFactory
  • ApplicationContextAware: 获取 ApplicationContext
  • EnvironmentAware: 获取 Environment
  • ResourceLoaderAware: 获取 ResourceLoader

6. 【初始化阶段】BeanPostProcessor 前置处理

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
      	if (bean instanceof User) { // 对 User 类型的 bean 进行扩展（增强、替换、修改属性等）
            
        }
        return bean;
    }
}
  • 可以对 Bean 进行包装或增强
  • 典型应用：@PostConstruct 处理、AOP 代理创建

7. 【初始化阶段】初始化方法调用

有三种初始化方式，执行顺序如下：

  1. @PostConstruct 注解标注的方法

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

  2. InitializingBean 接口的 afterPropertiesSet() 方法

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

  3. @Bean 注册的 bean 可以通过 initMethod 指定初始化方法

    public class MyBean {
    public void customInit() {
        // 初始化逻辑
    }
}

@Configuration
public class AppConfig {
    @Bean(initMethod = "customInit") // 指定初始化方法
    public MyBean myBean() { // 注册 MyBean 类型的 bean
        return new MyBean();
    }
}

8. 【初始化阶段】BeanPostProcessor 后置处理

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof User) { // 对 User 类型的 bean 进行扩展（增强、替换、修改属性等）
            
        }
        return bean;
    }
}

9. 【使用阶段】

  • Bean 完全初始化完成
  • 可被其他 Bean 依赖或通过 ApplicationContext 获取

10. 【销毁阶段】销毁方法调用

同初始化一样，也有三种方式。三种方式的执行顺序如下：

  1. @PreDestroy 注解方法

    @Component
public class MyBean {
    @PreDestroy
    public void preDestroy() {
        // 销毁逻辑
    }
}

  2. DisposableBean.destroy()

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

  3. 自定义 destroy-method

    public class MyBean {
    public void customDestroy() {
        // 销毁逻辑
    }
}

// 配置类中
@Bean(destroyMethod = "customDestroy")
public MyBean myBean() {
    return new MyBean();
}
posted @ 2024-10-25 13:00  CyrusHuang  阅读(24)  评论(0)    收藏  举报