保姆级整理，说清楚bean的生命周
1.整体流程图
2.各阶段分析
1️⃣定义阶段
1.1 定位资源
- Spring 扫描
@Component、@Service、@Controller等注解的类 - 或解析 XML/Java Config 中的 Bean 定义
1.2定义 BeanDefinition
- 解析类信息（作用域、懒加载、初始化/销毁方法等）
- 将解析结果封装为
BeanDefinition对象 - 存储到
BeanDefinitionRegistry(通常是DefaultListableBeanFactory)
1.3发布到容器
BeanDefinition注册完成，但尚未实例化- 此时可通过
BeanFactory获取 Bean 的定义信息
发布，已经定义的bean到IOC容器中
1.4实例化bean
- 容器通过反射调用构造函数创建原始对象
- 若存在构造器依赖，优先解决循环依赖（三级缓存机制）
1.5完成相关依赖注入
- 处理
@Autowired、@Value、@Resource等注解 - 填充普通属性和集合类型
2️⃣初始化
2.1setName方法
BeanNameAware.setBeanName()
2.2setBeanFactory
BeanFactoryAware.setBeanFactory()
2.3setApplicationContext
ApplicationContextAware.setApplicationContext()
2.4postProcessorBeforeInitislization()前置处理方法
BeanPostProcessor.postProcessBeforeInitialization()- 典型应用：
@PostConstruct注解处理、代理生成（如 AOP）
2.5调用 InitializingBean.afterPropertiesSet()
2.6执行自定义 init-method（XML 或 @Bean(initMethod)）
2.6BeanPostProcessor 后置处理
BeanPostProcessor.postProcessAfterInitialization()- 典型应用：AOP 最终代理、监控增强
2.7postProcessorAfterInitislization()后置处理方法
3️⃣准备使用
- Bean 正式服务于应用程序
- 所有依赖和方法均可正常使用
4️⃣自定义销毁方法
- 销毁前置处理
DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()
- 销毁方法执行 （按顺序）
- 调用
@PreDestroy注解方法 - 执行
DisposableBean.destroy() - 执行自定义
destroy-method（XML 或@Bean(destroyMethod)）
- 调用
- 资源释放
- 断开数据库连接
- 停止线程池
- 释放文件句柄等资源
3.注意事项
java
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
// 1. 定义 Bean 类（演示所有生命周期接口）
class ProductService implements
BeanNameAware,
BeanFactoryAware,
ApplicationContextAware,
InitializingBean,
DisposableBean {
private String productName;
// 1.1 构造器（实例化阶段）
public ProductService() {
System.out.println("🚀 1. 实例化阶段: 调用构造器创建 ProductService 实例");
}
// 1.2 属性注入（依赖注入阶段）
public void setProductName(String productName) {
this.productName = productName;
System.out.println("🔄 2. 依赖注入: setProductName() 注入属性值: " + productName);
}
// 2.1 BeanNameAware 回调
@Override
public void setBeanName(String name) {
System.out.println("🔖 3.1 Aware 接口: setBeanName() → Bean ID: " + name);
}
// 2.2 BeanFactoryAware 回调
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("🏭 3.2 Aware 接口: setBeanFactory() → BeanFactory 已注入");
}
// 2.3 ApplicationContextAware 回调
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("🌐 3.3 Aware 接口: setApplicationContext() → ApplicationContext 已注入");
}
// 2.4 自定义初始化方法 (通过 @Bean 指定)
public void customInit() {
System.out.println("🔧 5.1 初始化: 执行 @Bean 指定的 customInit()");
}
// 2.5 @PostConstruct 方法
@PostConstruct
public void postConstructInit() {
System.out.println("🔧 4.1 初始化: 执行 @PostConstruct 方法");
}
// 2.6 InitializingBean 接口
@Override
public void afterPropertiesSet() {
System.out.println("🔧 5.2 初始化: 执行 InitializingBean.afterPropertiesSet()");
}
// 3. 业务方法
public void displayProduct() {
System.out.println("🛒 6. 使用阶段: 当前产品 → " + productName);
}
// 4.1 @PreDestroy 方法
@PreDestroy
public void preDestroy() {
System.out.println("♻️ 7.1 销毁阶段: 执行 @PreDestroy 方法");
}
// 4.2 DisposableBean 接口
@Override
public void destroy() {
System.out.println("♻️ 7.2 销毁阶段: 执行 DisposableBean.destroy()");
}
// 4.3 自定义销毁方法 (通过 @Bean 指定)
public void customDestroy() {
System.out.println("♻️ 7.3 销毁阶段: 执行 @Bean 指定的 customDestroy()");
}
}
// 2. 自定义 BeanPostProcessor（演示扩展点）
class CustomBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof ProductService) {
System.out.println("⚙️ 4. 初始化前: BeanPostProcessor.postProcessBeforeInitialization()");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof ProductService) {
System.out.println("⚙️ 5.3 初始化后: BeanPostProcessor.postProcessAfterInitialization()");
}
return bean;
}
}
// 3. Spring 配置类
@Configuration
class AppConfig {
@Bean(initMethod = "customInit", destroyMethod = "customDestroy")
public ProductService productService() {
ProductService service = new ProductService();
service.setProductName("iPhone 15"); // 属性注入
return service;
}
@Bean
public CustomBeanPostProcessor customBeanPostProcessor() {
return new CustomBeanPostProcessor();
}
}
// 4. 主应用类
public class BeanLifecycleDemo {
public static void main(String[] args) {
System.out.println("============ 启动 Spring 容器 ============");
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(AppConfig.class);
System.out.println("\n============ 使用阶段 ============");
ProductService productService = context.getBean(ProductService.class);
productService.displayProduct();
System.out.println("\n============ 关闭 Spring 容器 ============");
context.close(); // 触发销毁阶段
}
}输出结果展示
css
============ 启动 Spring 容器 ============
🚀 1. 实例化阶段: 调用构造器创建 ProductService 实例
🔄 2. 依赖注入: setProductName() 注入属性值: iPhone 15
🔖 3.1 Aware 接口: setBeanName() → Bean ID: productService
🏭 3.2 Aware 接口: setBeanFactory() → BeanFactory 已注入
🌐 3.3 Aware 接口: setApplicationContext() → ApplicationContext 已注入
⚙️ 4. 初始化前: BeanPostProcessor.postProcessBeforeInitialization()
🔧 4.1 初始化: 执行 @PostConstruct 方法
🔧 5.1 初始化: 执行 @Bean 指定的 customInit()
🔧 5.2 初始化: 执行 InitializingBean.afterPropertiesSet()
⚙️ 5.3 初始化后: BeanPostProcessor.postProcessAfterInitialization()
============ 使用阶段 ============
🛒 6. 使用阶段: 当前产品 → iPhone 15
============ 关闭 Spring 容器 ============
♻️ 7.1 销毁阶段: 执行 @PreDestroy 方法
♻️ 7.2 销毁阶段: 执行 DisposableBean.destroy()
♻️ 7.3 销毁阶段: 执行 @Bean 指定的 customDestroy()生命周期阶段详解：
- 实例化阶段
- 调用构造函数创建 Bean 实例
- 依赖注入
- 通过 setter 或字段注入属性值
- Aware 接口回调 （按顺序）
BeanNameAware→BeanFactoryAware→ApplicationContextAware
- 初始化前处理
BeanPostProcessor.postProcessBeforeInitialization()
- 初始化阶段 （按顺序）
@PostConstruct方法 → 自定义init-method→InitializingBean.afterPropertiesSet()
- 初始化后处理
BeanPostProcessor.postProcessAfterInitialization()（如 AOP 代理在此生成）
- 使用阶段
- Bean 完全初始化，可被应用程序使用
- 销毁阶段 （容器关闭时）
@PreDestroy→DisposableBean.destroy()→ 自定义destroy-method
关键点说明：
- 执行顺序 ：初始化方法按
@PostConstruct→InitializingBean→init-method顺序执行 - 扩展点 ：
BeanPostProcessor可干预初始化过程（如 AOP、事务代理） - 销毁顺序：与初始化顺序相反（栈结构）
- 作用域影响：原型(prototype) Bean 不执行销毁方法ß