一句话总结
Spring Bean 生命周期四大阶段：1）实例化（反射创建对象）→ 2）属性填充（依赖注入、@Autowired）→ 3）初始化（Aware 回调 → BeanPostProcessor 前置处理 → InitializingBean → init-method → BeanPostProcessor 后置处理）→ 4）销毁（DisposableBean → destroy-method）。核心扩展点：BeanPostProcessor（影响所有 Bean，AOP 就是通过它实现的）。
初级理解
生命周期概览
# Bean 生命周期简化流程
# 1. 实例化（Instantiation）
# - 通过反射调用构造器创建对象
#
# 2. 属性填充（Populate Properties）
# - 依赖注入（@Autowired、@Value）
#
# 3. 初始化（Initialization）
# - Aware 接口回调（BeanNameAware、ApplicationContextAware）
# - BeanPostProcessor.postProcessBeforeInitialization()
# - @PostConstruct 方法
# - InitializingBean.afterPropertiesSet()
# - init-method
# - BeanPostProcessor.postProcessAfterInitialization()
#
# 4. 使用（In Use）
# - Bean 就绪，可以被使用
#
# 5. 销毁（Destruction）
# - @PreDestroy 方法
# - DisposableBean.destroy()
# - destroy-method
三种初始化方式
# 方式1：@PostConstruct（推荐）
@Component
public class MyBean {
@PostConstruct
public void init() {
System.out.println("初始化");
}
}
# 方式2：InitializingBean 接口
@Component
public class MyBean implements InitializingBean {
@Override
public void afterPropertiesSet() {
System.out.println("初始化");
}
}
# 方式3：@Bean(initMethod = "init")
@Bean(initMethod = "init")
public MyBean myBean() {
return new MyBean();
}
# 执行顺序：
# @PostConstruct → InitializingBean → initMethod
中级深入
BeanPostProcessor — 核心扩展点
# BeanPostProcessor 接口
public interface BeanPostProcessor {
# 初始化前调用
default Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}
# 初始化后调用（AOP 代理在这里生成）
default Object postProcessAfterInitialization(Object bean, String beanName) {
return bean;
}
}
# 重要实现类
# 1. AutowiredAnnotationBeanPostProcessor：处理 @Autowired
# 2. CommonAnnotationBeanPostProcessor：处理 @PostConstruct、@Resource
# 3. AbstractAutoProxyCreator：AOP 代理创建（核心！）
# AOP 代理创建时机
# postProcessAfterInitialization() 中
# 判断是否需要代理 → 需要则创建代理对象 → 返回代理
Aware 接口
# Aware 接口让 Bean 感知容器信息
@Component
public class MyBean implements ApplicationContextAware, BeanNameAware {
@Override
public void setBeanName(String name) {
// 获取 Bean 名称
}
@Override
public void setApplicationContext(ApplicationContext ctx) {
// 获取 ApplicationContext
}
}
# 常用 Aware 接口
# BeanNameAware：获取 Bean 名称
# BeanFactoryAware：获取 BeanFactory
# ApplicationContextAware：获取 ApplicationContext
# EnvironmentAware：获取 Environment
高级拓展
完整生命周期（源码级别）
# AbstractAutowireCapableBeanFactory.doCreateBean()
# 完整流程：
# 1. createBeanInstance() — 实例化
# - 通过反射调用构造器
# 2. applyMergedBeanDefinitionPostProcessors() — 合并 BeanDefinition
# - 处理 @Autowired、@Value 等注解元数据
# 3. addSingletonFactory() — 放入三级缓存
# - 解决循环依赖
# 4. populateBean() — 属性填充
# - InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
# - InstantiationAwareBeanPostProcessor.postProcessProperties()
# - 依赖注入（@Autowired）
# 5. initializeBean() — 初始化
# - invokeAwareMethods()（BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）
# - applyBeanPostProcessorsBeforeInitialization()
# - invokeInitMethods()（@PostConstruct → InitializingBean → initMethod）
# - applyBeanPostProcessorsAfterInitialization()（AOP 代理）
# 6. registerDisposableBeanIfNecessary() — 注册销毁回调
实战场景
场景：自定义 BeanPostProcessor
# 对所有标注 @Log 的 Bean 进行增强
@Component
public class LogBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
Class<?> clazz = bean.getClass();
if (clazz.isAnnotationPresent(Log.class)) {
// 创建代理，添加日志功能
return Proxy.newProxyInstance(
clazz.getClassLoader(),
clazz.getInterfaces(),
(proxy, method, args) -> {
System.out.println("调用方法：" + method.getName());
return method.invoke(bean, args);
}
);
}
return bean;
}
}
面试模拟
面试官：Spring Bean 的生命周期是怎样的？
你：四大阶段：实例化（反射创建）→ 属性填充（依赖注入）→ 初始化（Aware 回调 → BeanPostProcessor 前置 → @PostConstruct → InitializingBean → initMethod → BeanPostProcessor 后置，AOP 代理在此生成）→ 销毁（@PreDestroy → DisposableBean → destroyMethod）。
面试官：BeanPostProcessor 有什么作用？
你：它是 Spring 最重要的扩展点，影响所有 Bean。postProcessBeforeInitialization 在初始化前调用，postProcessAfterInitialization 在初始化后调用。AOP 代理就是在 postProcessAfterInitialization 中通过 AbstractAutoProxyCreator 创建的。