一、Bean 生命周期总览
Spring Bean 的生命周期可以概括为以下几个核心阶段：
- 实例化 (Instantiation)
- 属性填充 (Populate Properties / Dependency Injection)
- 初始化 (Initialization)
- 销毁 (Destruction)
一个更直观的流程图如下：
二、入口：一切从 getBean() 开始
我们代码里通常这样获取 Bean：
java
UserService userService = context.getBean(UserService.class);其真实的源码调用链如下：
java
// AbstractApplicationContext
public <T> T getBean(Class<T> requiredType) {
return getBeanFactory().getBean(requiredType);
}
// DefaultListableBeanFactory
public <T> T getBean(Class<T> requiredType) throws BeansException {
return this.getBean(requiredType, (Object[])null);
}
public <T> T getBean(Class<T> requiredType, @Nullable Object... args) throws BeansException {
Assert.notNull(requiredType, "Required type must not be null");
Object resolved = this.resolveBean(ResolvableType.forRawClass(requiredType), args, false);
if (resolved == null) {
throw new NoSuchBeanDefinitionException(requiredType);
} else {
return resolved;
}
}
private <T> T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
NamedBeanHolder<T> namedBean = this.resolveNamedBean(requiredType, args, nonUniqueAsNull);
// ........省略
}
private <T> NamedBeanHolder<T> resolveNamedBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) throws BeansException {
// ........省略
if (candidateNames.length == 1) {
return this.resolveNamedBean(candidateNames[0], requiredType, args);
}
//.........省略
}
private <T> NamedBeanHolder<T> resolveNamedBean(String beanName, ResolvableType requiredType, @Nullable Object[] args) throws BeansException {
Object bean = this.getBean(beanName, (Class)null, args);
return bean instanceof NullBean ? null : new NamedBeanHolder(beanName, this.adaptBeanInstance(beanName, bean, requiredType.toClass()));
}
// AbstractBeanFactory
public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args) throws BeansException {
return this.doGetBean(name, requiredType, args, false);
}最终走到核心方法：
java
// AbstractBeanFactory
public Object getBean(String name) {
return doGetBean(name, null, null, false);
}三、核心：doGetBean 全流程
java
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType,
@Nullable Object[] args, boolean typeCheckOnly) {
// 1. 标准化 beanName（去掉 & 前缀）
String beanName = transformedBeanName(name);
// 2. 从一级缓存拿
Object sharedInstance = getSingleton(beanName);
// ==========================================
// 【你手动调用时，这里一定不为 null】
// 因为容器启动时已经创建好了
// ==========================================
if (sharedInstance != null && args == null) {
Object beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
// ... 省略父工厂、原型、自定义 scope ...
// ==========================================
// 【只有缓存为空，才会走到这里创建】
// 场景：
// 1. 容器内部第一次创建
// 2. @Lazy 第一次调用
// 3. prototype 每次调用
// ==========================================
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
// ↓↓↓ 真正创建 Bean ↓↓↓
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
Object beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// ... prototype 分支 ...
return adaptBeanInstance(name, beanInstance, requiredType);
}四、createBean 真实入口
java
// 类：AbstractAutowireCapableBeanFactory
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// ... 准备工作、class 加载、方法重写等 ...
// ↓↓↓ 核心：真正创建逻辑在 doCreateBean ↓↓↓
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}下一步：doCreateBean
java
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// ====================== ① 实例化 Bean ======================
// 调用构造方法创建对象，生成 BeanWrapper
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
Object bean = instanceWrapper.getWrappedInstance();
// ====================== ② 填充属性 ======================
// 依赖注入：@Autowired、@Resource 在这里处理
populateBean(beanName, mbd, instanceWrapper);
// ====================== ③ 初始化 Bean ======================
// Aware + BeanPostProcessor 前后置 + 初始化方法
Object exposedObject = initializeBean(beanName, bean, mbd);
return exposedObject;
}下一步：initializeBean
java
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
// 1. 执行各种 Aware 接口
invokeAwareMethods(beanName, bean);
// 2. BeanPostProcessor 前置处理
Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
// 3. 执行初始化方法
// @PostConstruct / afterPropertiesSet / init-method
invokeInitMethods(beanName, wrappedBean, mbd);
// 4. BeanPostProcessor 后置处理（AOP 代理在此生成）
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}五、什么时候才会执行 createBean？
只有以下情况，才会进入 createBean 流程：
java
sharedInstance = getSingleton(beanName, () -> createBean(...));具体场景包括：
- 容器 refresh() 内部
preInstantiateSingletons()：容器启动时，遍历创建所有非懒加载的单例 Bean。 - Bean 上加了
@Lazy：第一次手动getBean()时才创建。 - 作用域是
@Scope("prototype")：每次getBean()都创建。 - Bean 被销毁后，再次获取：需要重新创建。
六、简单总结
- Spring 容器启动时，会自动把所有单例 Bean 创建好。
- 你手动
getBean()只是从一级缓存拿现成对象。 - 真正的创建流程只发生在容器内部第一次实例化。
- 生命周期完整链路：实例化 → 填充 → Aware → 前置 → 初始化 → 后置 → 入池。
核心步骤流程图
是
否
- 获取 BeanName
从一级缓存 singletonObjects 尝试获取
缓存是否存在？
直接从缓存返回成品 Bean
2. 进入单例创建逻辑 getSingleton
3. 执行 createBean
进入真正创建入口
4. doCreateBean 核心三阶段
• createBeanInstance
通过构造器实例化原生对象
• populateBean
依赖注入，填充 @Autowired 属性
• initializeBean
执行初始化逻辑
5. initializeBean 内部精细步骤
• 执行 Aware 接口
BeanNameAware/BeanFactoryAware
• 执行 BeanPostProcessor 前置处理
• 执行初始化方法
@PostConstruct / afterPropertiesSet
• 执行 BeanPostProcessor 后置处理
生成 AOP 代理
6. 创建完成，将成品 Bean 放入一级缓存
7. 后续任何 getBean 均直接从单例池返回
8. 容器关闭时，执行销毁方法
@PreDestroy / destroy