Bean的生命周期

bean的生命周期分为四个阶段：

1. 实例化
2. 属性赋值
3. 初始化
4. 销毁

源码解析

前言

首先spring容器在获取bean时会调用getBean(beanName)方法（或同名重载方法），getBean()所有重载都是基于doGetBean()方法实现的。

    // AbstractBeanFactory.class
    
    protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
        String beanName = this.transformedBeanName(name);
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        if (sharedInstance != null && args == null) {
            ...
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
            ...

            try {
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                ...

                // 判断是否是单例
                if (mbd.isSingleton()) {
                    // 获取单例
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    ...
                } else {
                    ...
                }
            } catch (BeansException var26) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var26;
            }
        }

        if (requiredType != null && !requiredType.isInstance(bean)) {
            ...
        } else {
            return bean;
        }
    }

在这个方法中会根据三级缓存机制拿到缓存的bean，如果都没有则会执行bean的创建流程，即执行createBean()方法，createBean()的核心逻辑都在doCreateBean()方法中，所以我们想要了解bean的生命周期需要集中学习这个代码的执行逻辑。

    // AbstractAutowireCapableBeanFactory.class

    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }

        // 实例化
        if (instanceWrapper == null) {
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

        Object bean = instanceWrapper.getWrappedInstance();
        ...

        // 判断是否是正在创建的单例Bean
        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) {
            ...

            // 添加到三级缓存
            this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
            });
        }

        Object exposedObject = bean;

        try {
            // 属性赋值
            this.populateBean(beanName, mbd, instanceWrapper);
            // 初始化
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                throw (BeanCreationException)var18;
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
        }

        ...
    }

bean的生命周期中的前三个阶段在doCreateBean()中都能定位到对应的方法：

• 实例化（this.createBeanInstance(beanName, mbd, args)）
• 属性赋值（this.populateBean(beanName, mbd, instanceWrapper)）
• 初始化（this.initializeBean(beanName, exposedObject, mbd)）

实例化

属性赋值

初始化

    // AbstractAutowireCapableBeanFactory.class

    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(() -> {
                this.invokeAwareMethods(beanName, bean);
                return null;
            }, this.getAccessControlContext());
        } else {
            this.invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        // 初始化前扩展
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
        }

        // 初始化
        try {
            this.invokeInitMethods(beanName, wrappedBean, mbd);
        } catch (Throwable var6) {
            throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
        }

        // 初始化后扩展
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }

这里有四个扩展点：

• xxxAware。
• 初始化前。this.applyBeanPostProcessorsBeforeInitialization(bean, beanName)。
• 初始化。afterPropertiesSet()。
• 初始化后。this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)。会执行AOP动态代理操作并返回动态代理对象。