Bean生命周期

Bean生命周期（基于 AbstractAutowireCapableBeanFactory）

本文根据deepseek回复整合。仅用来协助理解spring流程。
代码基于 spring-beans:6.2.8，为了便于理解做了代码修改

一、生命周期(略)

二、代码解析

入口方法：doCreateBean

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {
        
    // 1. 实例化 Bean（创建对象实例）
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
    Object bean = instanceWrapper.getWrappedInstance();
    
    // 2. 处理循环依赖：提前暴露 ObjectFactory
    if (mbd.isSingleton()) {
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // 3. 属性填充（依赖注入）
    populateBean(beanName, mbd, instanceWrapper);
    
    // 4. 初始化 Bean（包含后置处理器的前置/后置处理）
    exposedObject = initializeBean(beanName, exposedObject, mbd);
    
    // 5. 注册销毁回调
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
    
    return exposedObject;

三、详细步骤

步骤 1：实例化 Bean - createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // 1.1 使用 Supplier 方式创建（@Bean 的 supplier 属性）
    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName, mbd);
    }
    
    // 1.2 使用工厂方法创建（@Bean 的 factory-method 或 FactoryBean）
    if (mbd.getFactoryMethodName() != null) {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }
    
    // 1.3 推断构造函数：@Autowired(required=true) 或参数最多的构造函数
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }
    
    // 1.4 默认无参构造器实例化
    return instantiateBean(beanName, mbd);
}

步骤 2：处理循环依赖 - 三级缓存

AbstractAutowireCapableBeanFactory.doCreateBean() 方法

// 实例化完成后立即暴露 ObjectFactory
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
    // 将 ObjectFactory 放入三级缓存
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}


// getEarlyBeanReference 会调用 SmartInstantiationAwareBeanPostProcessor
// 这里就是 AOP 代理创建的关键点
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
        exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
    }
    return exposedObject;
}

步骤 3：属性填充 - populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    
    // 3.1 调用 InstantiationAwareBeanPostProcessor 的 postProcessAfterInstantiation
    //     返回 false 可跳过属性填充（常用于创建不需要注入的代理对象）
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
            if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                return; // 跳过后续属性填充
            }
        }
    }
    
    // 3.2 根据 autowire 模式（byName/byType）进行自动注入
    int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);  // 按名称匹配
        }
        if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);  // 按类型匹配
        }
        pvs = newPvs;
    }
    
    // 3.3 调用 BeanPostProcessor 处理 @Autowired 等注解注入
    //     注意：AutowiredAnnotationBeanPostProcessor 在这里工作
    if (hasInstantiationAwareBeanPostProcessors()) {
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
            PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
            // 注入 @Value、@Autowired 等
        }
    }
}

步骤 4：初始化 Bean - initializeBean

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    
    // 4.1 执行 Aware 方法注入
    invokeAwareMethods(beanName, bean);
    
    // 4.2 初始化前置处理（BeanPostProcessor.before）
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    
    // 4.3 执行初始化方法
    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    } 
    catch (Throwable ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex);
    }
    
    // 4.4 初始化后置处理（BeanPostProcessor.after）- AOP 代理创建处
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    
    return wrappedBean;
}

4.1 Aware 方法注入

(这段代码方便理解，不粘贴源代码了)

private void invokeAwareMethods(String beanName, Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

4.2 初始化前置处理

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) {
    Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessBeforeInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

4.3 执行初始化方法

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
        throws Throwable {
    
    // 4.3.1 执行 InitializingBean 接口方法
    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.hasAnyExternallyManagedInitMethod("afterPropertiesSet"))) {
        ((InitializingBean) bean).afterPropertiesSet();
    }

    // 4.3.2 执行自定义 init-method（@Bean(initMethod="xxx") 或 XML 配置）
    if (mbd != null && bean.getClass() != NullBean.class) {
        String[] initMethodNames = mbd.getInitMethodNames();
        if (initMethodNames != null) {
            for (String initMethodName : initMethodNames) {
                if (StringUtils.hasLength(initMethodName) &&
                        !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                        !mbd.hasAnyExternallyManagedInitMethod(initMethodName)) {
                    invokeCustomInitMethod(beanName, bean, mbd, initMethodName);
                }
            }
        }
    }

4.4 初始化后置处理（AOP 代理创建）

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) {
    Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

步骤 5：注册销毁回调

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
        if (mbd.isSingleton()) {
            // 注册到 disposableBeans Map 中
            registerDisposableBean(beanName, new DisposableBeanAdapter(
                    bean, beanName, mbd, getBeanPostProcessorCache().destructionAware));
        }
    }
}

// DisposableBeanAdapter 会在容器关闭时调用
public void destroy() {
    // 调用 @PreDestroy 方法（这个在哪，没注意到）
    // 调用 DisposableBean.destroy() 方法  
    // 调用自定义 destroy-method
}

四、完整生命周期代码示例

@Component
public class LifecycleDemoBean implements BeanNameAware, BeanFactoryAware, 
                                          InitializingBean, DisposableBean {
    
    private String name;
    
    public LifecycleDemoBean() {
        System.out.println("1. 实例化：构造器调用");
    }
    
    @Autowired
    public void setName(String name) {
        System.out.println("2. 属性填充：@Autowired 注入");
        this.name = name;
    }
    
    @PostConstruct
    public void postConstruct() {
        System.out.println("3. 初始化前：@PostConstruct 调用");
    }
    
    @Override
    public void setBeanName(String name) {
        System.out.println("4. Aware 注入：BeanNameAware.setBeanName - " + name);
    }
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        System.out.println("5. Aware 注入：BeanFactoryAware.setBeanFactory");
    }
    
    @Override
    public void afterPropertiesSet() {
        System.out.println("6. 初始化：InitializingBean.afterPropertiesSet");
    }
    
    @Bean(initMethod = "customInitMethod")
    public void customInitMethod() {
        System.out.println("7. 初始化：自定义 init-method 调用");
    }
    
    @PreDestroy
    public void preDestroy() {
        System.out.println("8. 销毁前：@PreDestroy 调用");
    }
    
    @Override
    public void destroy() {
        System.out.println("9. 销毁：DisposableBean.destroy");
    }
    
    // 假设有 AOP 切面
    public void businessMethod() {
        System.out.println("执行业务方法");
    }
}

// 输出顺序：
// 1. 实例化：构造器调用
// 2. 属性填充：@Autowired 注入
// 3. 初始化前：@PostConstruct 调用
// 4. Aware 注入：BeanNameAware.setBeanName
// 5. Aware 注入：BeanFactoryAware.setBeanFactory
// 6. 初始化：InitializingBean.afterPropertiesSet
// 7. 初始化：自定义 init-method 调用
// (这里会创建 AOP 代理，如果适用)
// --- 容器关闭时 ---
// 8. 销毁前：@PreDestroy 调用
// 9. 销毁：DisposableBean.destroy

五、所有 BeanPostProcessor 的执行时机

处理器类型	方法	调用时机
`InstantiationAwareBeanPostProcessor`	`postProcessBeforeInstantiation`	实例化前
`SmartInstantiationAwareBeanPostProcessor`	`determineCandidateConstructors`	选择构造器时
`InstantiationAwareBeanPostProcessor`	`postProcessAfterInstantiation`	实例化后、填充前
`InstantiationAwareBeanPostProcessor`	`postProcessProperties`	属性填充时
`BeanPostProcessor`	`postProcessBeforeInitialization`	初始化前（Aware之后）
`BeanPostProcessor`	`postProcessAfterInitialization`	初始化后（AOP代理）
`DestructionAwareBeanPostProcessor`	`postProcessBeforeDestruction`	销毁前

六、调试技巧

// 1. 在 AbstractAutowireCapableBeanFactory 的 doCreateBean 方法打条件断点
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // 条件：beanName.equals("yourBeanName")
}

// 2. 启用调试日志
logging.level.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory=DEBUG

// 3. 实现 BeanPostProcessor 并打印日志
@Component
public class LifecycleLogger implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("Before init: " + beanName + " - " + bean.getClass());
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("After init: " + beanName + " - " + bean.getClass());
        return bean;
    }
}

核心理解：整个生命周期中，最重要的扩展点是各种 BeanPostProcessor，它们实现了 Spring 几乎所有的注解支持和 AOP 功能。

weimingwm86

Bean生命周期

Bean生命周期

一、生命周期(略)

二、代码解析

三、详细步骤

步骤 1：实例化 Bean - createBeanInstance

步骤 2：处理循环依赖 - 三级缓存

步骤 3：属性填充 - populateBean

步骤 4：初始化 Bean - initializeBean

步骤 5：注册销毁回调

四、完整生命周期代码示例

五、所有 BeanPostProcessor 的执行时机

六、调试技巧

tag

公告