Bean生命周期

深入理解Spring Bean的完整生命周期，掌握从实例化、属性注入、初始化到销毁的完整流程，理解各个生命周期钩子的执行时机和作用。

📋 Bean生命周期概览

Spring Bean的生命周期从容器开始创建Bean到销毁Bean的完整过程，包含多个关键步骤和扩展点。

🎯 一、Bean生命周期完整流程

1.1 生命周期流程图

🎯 二、实例化阶段

2.1 实例化流程

Bean的实例化是创建Bean对象的第一个步骤。

createBeanInstance方法：

java

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd,
        @Nullable Object[] args) {
    // 1. 解析Bean的Class
    Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
    // 2. 检查Bean的访问权限
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && 
            !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(...);
    }
    
    // 3. 获取实例提供者
    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }
    
    // 4. 获取工厂方法
    if (mbd.getFactoryMethodName() != null) {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }
    
    // 5. 判断是否需要重新解析构造器（由于参数类型匹配）
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
        if (autowireNecessary) {
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            return instantiateBean(beanName, mbd);
        }
    }
    
    // 6. 自动装配构造器
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(
            beanClass, beanName);
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }
    
    // 7. 使用默认构造器
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, null);
    }
    
    // 8. 使用无参构造器实例化
    return instantiateBean(beanName, mbd);
}

实例化方式：

Supplier方式：通过Supplier接口实例化
工厂方法：通过静态工厂方法或实例工厂方法
构造器注入：通过有参构造器（自动装配）
默认构造器：使用无参构造器

2.2 构造器选择

Spring会根据以下规则选择构造器：

@Autowired注解的构造器：优先选择
参数匹配的构造器：如果只有一个构造器，使用该构造器
参数数量最多的构造器：如果有多个构造器，优先选择参数最多的
默认构造器：如果没有匹配的构造器，使用默认构造器

🎯 三、属性注入阶段

3.1 属性注入流程

属性注入在Bean实例化之后进行，包括依赖注入和属性赋值。

populateBean方法：

java

protected void populateBean(String beanName, RootBeanDefinition mbd,
        @Nullable BeanWrapper bw) {
    // 1. 如果BeanWrapper为空，检查是否有属性值
    if (bw == null) {
        if (mbd.hasPropertyValues()) {
            throw new BeanCreationException(...);
        }
        else {
            return;
        }
    }
    
    // 2. 给InstantiationAwareBeanPostProcessor一个机会修改属性值
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = 
                        (InstantiationAwareBeanPostProcessor) bp;
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, 
                        bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) {
                    if (filteredPds == null) {
                        filteredPds = filterPropertyDescriptorsForDependencyCheck(
                                bw, mbd.allowCaching);
                    }
                    pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, 
                            bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        return;
                    }
                }
                pvs = pvsToUse;
            }
        }
    }
    
    // 3. 检查是否需要依赖检查
    boolean needsDepCheck = (mbd.getDependencyCheck() != 
            AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
    
    // 4. 过滤属性描述符
    PropertyDescriptor[] filteredPds = null;
    if (needsDepCheck) {
        if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, 
                    mbd.allowCaching);
        }
    }
    
    // 5. 应用属性值
    if (pvs != null) {
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

3.2 自动装配

Spring支持以下几种自动装配模式：

byName：按名称自动装配
byType：按类型自动装配
constructor：构造器自动装配
no：不自动装配（默认）

🎯 四、初始化阶段

4.1 初始化流程

初始化阶段是Bean生命周期中最复杂的阶段，包含多个步骤。

initializeBean方法：

java

protected Object initializeBean(String beanName, Object bean,
        @Nullable RootBeanDefinition mbd) {
    // 1. 调用Aware接口方法
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        invokeAwareMethods(beanName, bean);
    }
    
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 2. BeanPostProcessor前置处理
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    
    try {
        // 3. 调用初始化方法
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(...);
    }
    
    if (mbd == null || !mbd.isSynthetic()) {
        // 4. BeanPostProcessor后置处理
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    
    return wrappedBean;
}

4.2 Aware接口回调

Spring提供了多个Aware接口，让Bean能够获取Spring容器的信息。

常见的Aware接口：

BeanNameAware：获取Bean名称
BeanFactoryAware：获取BeanFactory
ApplicationContextAware：获取ApplicationContext
ResourceLoaderAware：获取ResourceLoader
EnvironmentAware：获取Environment
MessageSourceAware：获取MessageSource

invokeAwareMethods方法：

java

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

4.3 BeanPostProcessor处理

前置处理：

java

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) 
        throws BeansException {
    return bean;
}

后置处理：

java

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) 
        throws BeansException {
    return bean;
}

4.4 初始化方法

初始化方法按以下顺序执行：

@PostConstruct注解的方法
InitializingBean.afterPropertiesSet()方法
init-method指定的方法

invokeInitMethods方法：

java

protected void invokeInitMethods(String beanName, Object bean,
        @Nullable RootBeanDefinition mbd) throws Throwable {
    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || 
            !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (logger.isTraceEnabled()) {
            logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
        }
        if (System.getSecurityManager() != null) {
            try {
                AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                    ((InitializingBean) bean).afterPropertiesSet();
                    return null;
                }, getAccessControlContext());
            }
            catch (PrivilegedActionException pae) {
                throw pae.getException();
            }
        }
        else {
            ((InitializingBean) bean).afterPropertiesSet();
        }
    }
    
    if (mbd != null && bean.getClass() != NullBean.class) {
        String initMethodName = mbd.getInitMethodName();
        if (StringUtils.hasLength(initMethodName) &&
                !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                !mbd.isExternallyManagedInitMethod(initMethodName)) {
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

@PostConstruct处理：

@PostConstruct注解的方法由CommonAnnotationBeanPostProcessor处理：

java

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
        implements InstantiationAwareBeanPostProcessor, BeanFactoryAware {
    
    public CommonAnnotationBeanPostProcessor() {
        setInitAnnotationType(PostConstruct.class);
        setDestroyAnnotationType(PreDestroy.class);
        setOrder(Ordered.LOWEST_PRECEDENCE - 3);
    }
}

🎯 五、销毁阶段

5.1 销毁流程

Bean的销毁在容器关闭时执行，销毁方法按以下顺序执行：

@PreDestroy注解的方法
DisposableBean.destroy()方法
destroy-method指定的方法

destroy方法：

java

protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
    if (bean != null) {
        try {
            bean.destroy();
        }
        catch (Throwable ex) {
            logger.error("Destroy method on bean with name '" + beanName + 
                    "' threw an exception", ex);
        }
    }
    
    // 调用自定义销毁方法
    if (bean != null) {
        RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        String destroyMethodName = mbd.getDestroyMethodName();
        if (StringUtils.hasLength(destroyMethodName) &&
                !(bean instanceof DisposableBean && "destroy".equals(destroyMethodName)) &&
                !mbd.isExternallyManagedDestroyMethod(destroyMethodName)) {
            try {
                invokeCustomDestroyMethod(beanName, bean, mbd);
            }
            catch (Throwable ex) {
                logger.error("Custom destroy method '" + destroyMethodName + 
                        "' on bean with name '" + beanName + "' threw an exception", ex);
            }
        }
    }
}

5.2 DisposableBeanAdapter

DisposableBeanAdapter负责处理Bean的销毁逻辑：

java

public class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable {
    
    private final Object bean;
    private final String beanName;
    private final String destroyMethodName;
    
    @Override
    public void destroy() {
        // 处理@PreDestroy注解的方法
        if (this.bean instanceof DisposableBean) {
            ((DisposableBean) this.bean).destroy();
        }
        
        // 调用自定义销毁方法
        if (StringUtils.hasLength(this.destroyMethodName)) {
            invokeCustomDestroyMethod(this.destroyMethodName);
        }
    }
}

🎯 六、完整生命周期示例

6.1 示例Bean

java

@Component
public class LifecycleBean implements BeanNameAware, BeanFactoryAware,
        ApplicationContextAware, InitializingBean, DisposableBean {
    
    private String beanName;
    
    public LifecycleBean() {
        System.out.println("1. 构造器调用");
    }
    
    @Autowired
    public void setDependency(SomeDependency dependency) {
        System.out.println("2. 属性注入：" + dependency);
    }
    
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("3. BeanNameAware.setBeanName: " + name);
    }
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4. BeanFactoryAware.setBeanFactory");
    }
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) 
            throws BeansException {
        System.out.println("5. ApplicationContextAware.setApplicationContext");
    }
    
    @PostConstruct
    public void postConstruct() {
        System.out.println("6. @PostConstruct方法");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("7. InitializingBean.afterPropertiesSet");
    }
    
    public void initMethod() {
        System.out.println("8. init-method方法");
    }
    
    @PreDestroy
    public void preDestroy() {
        System.out.println("9. @PreDestroy方法");
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("10. DisposableBean.destroy");
    }
    
    public void destroyMethod() {
        System.out.println("11. destroy-method方法");
    }
}

执行顺序：

构造器调用
属性注入
BeanNameAware.setBeanName
BeanFactoryAware.setBeanFactory
ApplicationContextAware.setApplicationContext
BeanPostProcessor.postProcessBeforeInitialization
@PostConstruct方法
InitializingBean.afterPropertiesSet
init-method方法
BeanPostProcessor.postProcessAfterInitialization
Bean使用阶段
@PreDestroy方法
DisposableBean.destroy
destroy-method方法

📖 学习资源

视频教程

书籍推荐

《Spring源码深度解析》 - 郝佳
《Spring技术内幕》 - 计文柯

网站资源

Spring Bean生命周期文档

✅ 学习检查清单

[ ] 已理解Bean生命周期完整流程
[ ] 已理解实例化阶段
[ ] 已理解属性注入阶段
[ ] 已理解初始化阶段
[ ] 已理解Aware接口的作用
[ ] 已理解BeanPostProcessor的作用
[ ] 已理解初始化方法的执行顺序
[ ] 已理解销毁阶段
[ ] 已绘制Bean生命周期时序图
[ ] 已总结核心知识点

上一章节：AOP实现原理
下一章节：循环依赖处理
返回目录：Spring源码深度解析

开发与调试

测试能力

运维与监控

NoSQL

中间件

存储

接入层

操作系统

框架

硬件知识

缓存

品质

经验底蕴

能力

任务拆分

文档能力

协议设计

基本理论

接入层架构

数据层架构

通讯机制

逻辑层架构

Bean生命周期 ​