Spring Bean的生命周期

一、引言

　　要想理解Spring框架，那么Spring Bean的生命周期就是必须要了解的一环，关于Spring Bean的生命周期，就是一个Bean在IOC容器中从创建到销毁的过程，下面就开始梳理一下一个Bean的创建过程。

二、生命周期概要流程

　　简单的来说，一个Bean的生命周期分为四个阶段：

　　1、实例化（Instantiation）

　　2、属性设置（populate）

　　3、初始化（Initialization）

　　4、销毁（Destruction）

如下图：

　　具体逻辑位于AbstractAutowireCapableBeanFactory类doCreateBean方法中，代码较多，只放出了重要的部分，如下：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;

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

        try {
            //属性赋值
            this.populateBean(beanName, mbd, instanceWrapper);
            //初始化
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            //...
        }

        try {
            //注册销毁回调接口
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            //...
        }
    }

 　　上面是的步实例化、属性赋值、初始化都是Spring容器启动时的步骤，销毁是在容器关闭时的操作，容器销毁时会调用容器的close()方法去销毁容器。

三、对生命周期的扩展

　　Spring在创建Bean的时候不仅仅只创建了一个我们设置的Bean，还可以在创建Bean的时候对它进行很多的扩展，总的来说有以下几类：

　　1、BeanPostProcessor接口

　　2、InstantiationAwareBeanPostProcessor接口

　　3、Aware类型的接口

　　4、生命周期类型接口

　　其中1和2是作用于所有Bean的接口，3和4是作用于单个Bean的接口。BeanPostProcessor是初始化时的后置处理器，InstantiationAwareBeanPostProcessor是实例化时的后置处理器，Aware类型的接口如BeanNameAware、BeanFactoryAware等需要Bean自己去实现，生命周期类型接口如InitializingBean、DisposableBean。

　　加上这些扩展，现在上面的图可以变成下面这样了：

 　　接下来看详细的源码，刚刚我们提到的实例化、属性赋值、初始化这三个步骤都在doCreateBean方法中，那么在这个方法之前有什么操作吗：

    //createBean方法里面调用了doCreateBean
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        Object beanInstance;
        try {
            //这个里面调用了InstantiationAwareBeanPostProcessor的前置方法postProcessBeforeIns
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
        } catch (Throwable var10) {
            //...
        }
        //...
        try {
            //这里调用了doCreateBean
            beanInstance = this.doCreateBean(beanName, mbdToUse, args);

            return beanInstance;
        } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
            //...
        } catch (Throwable var8) {
            //...
        }
    }

    //resolveBeforeInstantiation方法里面调用了这个方法
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        Iterator var3 = this.getBeanPostProcessors().iterator();

        while(var3.hasNext()) {
            BeanPostProcessor bp = (BeanPostProcessor)var3.next();
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                //调用了InstantiationAwareBeanPostProcessor的前置方法postProcessBeforeInstantiation
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }

        return null;
    }

　　在调用完InstantiationAwareBeanPostProcessor的前置方法之后接下来进入doCreateBean方法，首先会执行createBeanInstance(beanName, mbd, args)进行实例化，然后进入populateBean(beanName, mbd, instanceWrapper)方法进行属性赋值，看一下这一部分代码还有没有别的操作：

    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            //...
        } else {
            if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                Iterator var4 = this.getBeanPostProcessors().iterator();

                while(var4.hasNext()) {
                    BeanPostProcessor bp = (BeanPostProcessor)var4.next();
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                        
                        //执行InstantiationAwareBeanPostProcessor的后置方法postProcessAfterInstantiation
                        if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                            return;
                        }
                    }
                }
            }
            if (hasInstAwareBpps) {
                Iterator var9 = this.getBeanPostProcessors().iterator();
                while(var9.hasNext()) {
                    BeanPostProcessor bp = (BeanPostProcessor)var9.next();
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                        
                        //执行执行InstantiationAwareBeanPostProcessor的postProcessProperties
                        PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
                        if (pvsToUse == null) {
                            
                            ////执行执行InstantiationAwareBeanPostProcessor的postProcessPropertyValues(该方法已废弃，不建议使用)
                            pvsToUse = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        }
                    }
                }
            }

        }
    }

　　通过源码可以看出InstantiationAwareBeanPostProcessor的几个方法分别在实例化的前后完成，然后进行属性赋值，接下来就是实例化initializeBean(beanName, exposedObject, mbd)，我们来看一下：

    //该方法位于AbstractAutowireCapableBeanFactory类中，这段代码很简单，不像其他部分还添加了很多其他操作，这块一看就明白了，就不把BeanPostProcessor、InitializingBean等具体的方法列出来了
    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(() -> {
                //invokeAwareMethods方法执行实现的Aware接口
                this.invokeAwareMethods(beanName, bean);
                return null;
            }, this.getAccessControlContext());
        } else {
            //和上面的一样，执行实现的Aware类型的接口
            this.invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            //这个方法里面执行了BeanPostProcessor的postProcessBeforeInitialization方法
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
        }

        try {
            //执行了InitializingBean的afterPropertiesSet方法和自定义的init-method方法
            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()) {
            //这个方法里面执行了BeanPostProcessor的postProcessAfterInitialization方法
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }

　　关于Aware类型的接口这里要说一下，可能你会奇怪按照我上面的那个类去找invokeAwareMethods(beanName, bean)方法会是下面这种情况：

    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 = this.getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
                }
            }

            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware)bean).setBeanFactory(this);
            }
        }

    }

　　为什么只有这三个Aware类型的接口，明明还有其他好几种啊，比如EnvironmentAware、EmbeddedValueResolverAware等，这是什么它们的容器不同，AbstractAutowireCapableBeanFactory使用的容器是BeanFactory，其他几种是ApplicationContext 添加的扩展接口，如：

    //ApplicationContextAwareProcessor中实现的接口如下
    private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof EnvironmentAware) {
            ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
        }

        if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
        }

        if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
        }

        if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
        }

        if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware)bean).setMessageSource(this.applicationContext);
        }

        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
        }

    }

　　到这一步初始化也完成了，至于销毁时在容器关闭时执行容器的close方法，close方法中会执行destroy方法销毁所有的Bean：

    //销毁Bean的方法
    public void destroy() {
        if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
            Iterator var1 = this.beanPostProcessors.iterator();

            while(var1.hasNext()) {
                //其实这里也有个销毁时的处理器，实现了BeanPostProcessor,在执行销毁方法前执行postProcessBeforeDestruction方法
                DestructionAwareBeanPostProcessor processor = (DestructionAwareBeanPostProcessor)var1.next();
                processor.postProcessBeforeDestruction(this.bean, this.beanName);
            }
        }

        if (this.invokeDisposableBean) {

            try {
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(() -> {
                        //执行DisposableBean的destroy方法
                        ((DisposableBean)this.bean).destroy();
                        return null;
                    }, this.acc);
                } else {
                    //同上，执行DisposableBean的destroy方法
                    ((DisposableBean)this.bean).destroy();
                }
            } catch (Throwable var3) {
                //...
            }
        }

        if (this.destroyMethod != null) {
            //如果存在指定的销毁方法就执行，即destroy-method指定的方法
            this.invokeCustomDestroyMethod(this.destroyMethod);
        } else if (this.destroyMethodName != null) {
            //...
        }

    }

　　到这里我们已经看完了一个Bean从实例化到销毁的所有步骤。

四、总结

　　总的来说Spring Bean的生命周期就是四大步骤，实例化 -> 属性赋值 ->初始化 ->销毁，其他的操作都是对这四个步骤的扩展。