Spring 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️⃣自定义销毁方法

1. 销毁前置处理
   • DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()
2. 销毁方法执行（按顺序）
   • 调用 @PreDestroy 注解方法
   • 执行 DisposableBean.destroy()
   • 执行自定义 destroy-method（XML 或 @Bean(destroyMethod)）
3. 资源释放
   • 断开数据库连接
   • 停止线程池
   • 释放文件句柄等资源

3.注意事项

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 回调@Overridepublic void setBeanName(String name) {System.out.println("🔖 3.1 Aware 接口: setBeanName() → Bean ID: " + name);}// 2.2 BeanFactoryAware 回调@Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println("🏭 3.2 Aware 接口: setBeanFactory() → BeanFactory 已注入");}// 2.3 ApplicationContextAware 回调@Overridepublic 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 方法@PostConstructpublic void postConstructInit() {System.out.println("🔧 4.1 初始化: 执行 @PostConstruct 方法");}// 2.6 InitializingBean 接口@Overridepublic void afterPropertiesSet() {System.out.println("🔧 5.2 初始化: 执行 InitializingBean.afterPropertiesSet()");}// 3. 业务方法public void displayProduct() {System.out.println("🛒 6. 使用阶段: 当前产品 → " + productName);}// 4.1 @PreDestroy 方法@PreDestroypublic void preDestroy() {System.out.println("♻️ 7.1 销毁阶段: 执行 @PreDestroy 方法");}// 4.2 DisposableBean 接口@Overridepublic 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 {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if (bean instanceof ProductService) {System.out.println("⚙️ 4. 初始化前: BeanPostProcessor.postProcessBeforeInitialization()");}return bean;}@Overridepublic 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;}@Beanpublic 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(); // 触发销毁阶段}
}

输出结果展示

============ 启动 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()

生命周期阶段详解：

1. 实例化阶段
   • 调用构造函数创建 Bean 实例
2. 依赖注入
   • 通过 setter 或字段注入属性值
3. Aware 接口回调（按顺序）
   • BeanNameAware → BeanFactoryAware → ApplicationContextAware
4. 初始化前处理
   • BeanPostProcessor.postProcessBeforeInitialization()
5. 初始化阶段（按顺序）
   • @PostConstruct 方法 → 自定义 init-method → InitializingBean.afterPropertiesSet()
6. 初始化后处理
   • BeanPostProcessor.postProcessAfterInitialization()（如 AOP 代理在此生成）
7. 使用阶段
   • Bean 完全初始化，可被应用程序使用
8. 销毁阶段（容器关闭时）
   • @PreDestroy → DisposableBean.destroy() → 自定义 destroy-method

关键点说明：

1. 执行顺序：初始化方法按 @PostConstruct → InitializingBean → init-method 顺序执行
2. 扩展点：BeanPostProcessor 可干预初始化过程（如 AOP、事务代理）
3. 销毁顺序：与初始化顺序相反（栈结构）
4. 作用域影响：原型(prototype) Bean 不执行销毁方法ß