Spring源碼----Spring的Bean生命周期流程圖及代碼解釋

?在網(wǎng)上已經(jīng)有跟多Bean的生命周期的博客，但是很多都是基于比較老的版本了，最近吧整個流程化成了一個流程圖。待會兒使用流程圖，說明以及代碼的形式來說明整個聲明周期的流程。注意因為代碼比較多，這里的流程圖只畫出了大概的流程，具體的可以深入代碼

1.獲取Bean

第一階段獲取Bean

?這里的流程圖的入口在AbstractBeanFactory類的doGetBean方法，這里可以配合前面的getBean方法分析文章進(jìn)行閱讀。主要流程就是

  1. 先處理Bean 的名稱，因為如果以“&”開頭的Bean名稱表示獲取的是對應(yīng)的FactoryBean對象；
  2. 從緩存中獲取單例Bean，有則進(jìn)一步判斷這個Bean是不是在創(chuàng)建中，如果是的就等待創(chuàng)建完畢，否則直接返回這個Bean對象
  3. 如果不存在單例Bean緩存，則先進(jìn)行循環(huán)依賴的解析
  4. 解析完畢之后先獲取父類BeanFactory，獲取到了則調(diào)用父類的getBean方法，不存在則先合并然后創(chuàng)建Bean

2.創(chuàng)建Bean

2.1 創(chuàng)建Bean之前

在真正創(chuàng)建Bean之前邏輯

?這個流程圖對應(yīng)的代碼在AbstractAutowireCapableBeanFactory類的createBean方法中。

  1. 這里會先獲取RootBeanDefinition對象中的Class對象并確保已經(jīng)關(guān)聯(lián)了要創(chuàng)建的Bean的Class。
  2. 這里會檢查3個條件
    （1）Bean的屬性中的beforeInstantiationResolved字段是否為true，默認(rèn)是false。
    （2）Bean是原生的Bean
    （3）Bean的hasInstantiationAwareBeanPostProcessors屬性為true，這個屬性在Spring準(zhǔn)備刷新容器錢轉(zhuǎn)杯BeanPostProcessors的時候會設(shè)置，如果當(dāng)前Bean實現(xiàn)了InstantiationAwareBeanPostProcessor則這個就會是true。
    當(dāng)三個條件都存在的時候，就會調(diào)用實現(xiàn)的InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法，然后獲取返回的Bean，如果返回的Bean不是null還會調(diào)用實現(xiàn)的BeanPostProcessor接口的postProcessAfterInitialization方法，這里用代碼說明
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
              //條件1
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
          //條件2跟條件3
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
 //調(diào)用實現(xiàn)的postProcessBeforeInstantiation方法
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
//調(diào)用實現(xiàn)的postProcessAfterInitialization方法
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
                  //不滿足2或者3的時候就會設(shè)置為false
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }
  1. 如果上面3個條件其中一個不滿足就不會調(diào)用實現(xiàn)的方法。默認(rèn)這里都不會調(diào)用的這些BeanPostProcessors的實現(xiàn)方法。然后繼續(xù)執(zhí)行后面的doCreateBean方法。
2.1 真正的創(chuàng)建Bean，doCreateBean

doCreateBean方法邏輯

這個代碼的實現(xiàn)還是在AbstractAutowireCapableBeanFactory方法中。流程是

  1. 先檢查instanceWrapper變量是不是null，這里一般是null，除非當(dāng)前正在創(chuàng)建的Bean在factoryBeanInstanceCache中存在這個是保存還沒創(chuàng)建完成的FactoryBean的集合。
  2. 調(diào)用createBeanInstance方法實例化Bean，這個方法在后面會講解
  3. 如果當(dāng)前RootBeanDefinition對象還沒有調(diào)用過實現(xiàn)了的MergedBeanDefinitionPostProcessor接口的方法，則會進(jìn)行調(diào)用
  4. 當(dāng)滿足以下三點
    （1）是單例Bean
    （2）嘗試解析bean之間的循環(huán)引用
    （3）bean目前正在創(chuàng)建中
    則會進(jìn)一步檢查是否實現(xiàn)了SmartInstantiationAwareBeanPostProcessor接口如果實現(xiàn)了則調(diào)用是實現(xiàn)的getEarlyBeanReference方法
  5. 調(diào)用populateBean方法進(jìn)行屬性填充，這里后面會講解
  6. 調(diào)用initializeBean方法對Bean進(jìn)行初始化，這里后面會講解
2.1.1 實例化Bean，createBeanInstance
實例化Bean

?這里的邏輯稍微有一點復(fù)雜，這個流程圖已經(jīng)是簡化過后的了。簡要根據(jù)代碼說明一下流程

    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        //步驟1
        Class<?> beanClass = resolveBeanClass(mbd, beanName);

        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        }
        //步驟2
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);
        }
        //步驟3
        if (mbd.getFactoryMethodName() != null) {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }


        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        //步驟4.1
        if (resolved) {
                  
            if (autowireNecessary) {
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                       
                return instantiateBean(beanName, mbd);
            }
        }

          //步驟4.2
        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
            return autowireConstructor(beanName, mbd, ctors, args);
        }

        //步驟5
        ctors = mbd.getPreferredConstructors();
        if (ctors != null) {
            return autowireConstructor(beanName, mbd, ctors, null);
        }

        
        return instantiateBean(beanName, mbd);
    }
  1. 先檢查Class是否已經(jīng)關(guān)聯(lián)了，并且對應(yīng)的修飾符是否是public的
  2. 如果用戶定義了Bean實例化的函數(shù)，則調(diào)用并返回
  3. 如果當(dāng)前Bean實現(xiàn)了FactoryBean接口則調(diào)用對應(yīng)的FactoryBean接口的getObject方法
  4. 根據(jù)getBean時候是否傳入構(gòu)造參數(shù)進(jìn)行處理
    4.1 如果沒有傳入構(gòu)造參數(shù)，則檢查是否存在已經(jīng)緩存的無參構(gòu)造器，有則使用構(gòu)造器直接創(chuàng)建，沒有就會調(diào)用instantiateBean方法先獲取實例化的策略默認(rèn)是CglibSubclassingInstantiationStrategy，然后實例化Bean。最后返回
    4.2 如果傳入了構(gòu)造參數(shù)，則會先檢查是否實現(xiàn)了SmartInstantiationAwareBeanPostProcessor接口，如果實現(xiàn)了會調(diào)用determineCandidateConstructors獲取返回的候選構(gòu)造器。
    4.3 檢查4個條件是否滿足一個
    （1）構(gòu)造器不為null，
    （2）從RootBeanDefinition中獲取到的關(guān)聯(lián)的注入方式是構(gòu)造器注入（沒有構(gòu)造參數(shù)就是setter注入，有則是構(gòu)造器注入）
    （3）含有構(gòu)造參數(shù)
    （4）getBean方法傳入構(gòu)造參數(shù)不是空
    滿足其中一個則會調(diào)用返回的候選構(gòu)造器實例化Bean并返回，如果都不滿足，則會根據(jù)構(gòu)造參數(shù)選則合適的有參構(gòu)造器然后實例化Bean并返回
  5. 如果上面都沒有合適的構(gòu)造器，則直接使用無參構(gòu)造器創(chuàng)建并返回Bean。
2.1.2 填充Bean，populateBean
填充Bean

這里還是根據(jù)代碼來說一下流程

    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            if (mbd.hasPropertyValues()) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
            else {
                // Skip property population phase for null instance.
                return;
            }
        }


        boolean continueWithPropertyPopulation = true;
        //步驟1
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }

        if (!continueWithPropertyPopulation) {
            return;
        }
//步驟2--------------------
        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

        int resolvedAutowireMode = mbd.getResolvedAutowireMode();
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            // Add property values based on autowire by name if applicable.
            if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }
            // Add property values based on autowire by type if applicable.
            if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }

        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

        PropertyDescriptor[] filteredPds = null;
//步驟3
        if (hasInstAwareBpps) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
            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;
                }
            }
        }
        if (needsDepCheck) {
            if (filteredPds == null) {
                filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            checkDependencies(beanName, mbd, filteredPds, pvs);
        }
//步驟4
        if (pvs != null) {
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }
  1. 檢查當(dāng)前Bean是否實現(xiàn)了InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法則調(diào)用，并結(jié)束Bean的填充。
  2. 將按照類型跟按照名稱注入的Bean分開，如果注入的Bean還沒有實例化的這里會實例化，然后放到PropertyValues對象中。
  3. 如果實現(xiàn)了InstantiationAwareBeanPostProcessor類的postProcessProperties則調(diào)用這個方法并獲取返回值，如果返回值是null，則有可能是實現(xiàn)了過期的postProcessPropertyValues方法，這里需要進(jìn)一步調(diào)用postProcessPropertyValues方法
  4. 進(jìn)行參數(shù)填充
2.1.3 初始化Bean，initializeBean
初始化Bean

同時這里根據(jù)代碼跟流程圖來說明

  1. 如果Bean實現(xiàn)了BeanNameAware,BeanClassLoaderAware,BeanFactoryAware則調(diào)用對應(yīng)實現(xiàn)的方法
  2. Bean不為null并且bean不是合成的，如果實現(xiàn)了BeanPostProcessor的postProcessBeforeInitialization則會調(diào)用實現(xiàn)的postProcessBeforeInitialization方法。在ApplicationContextAwareProcessor類中實現(xiàn)了postProcessBeforeInitialization方法。而這個類會在Spring刷新容器準(zhǔn)備beanFactory的時候會加進(jìn)去，這里就會被調(diào)用，而調(diào)用里面會檢查Bean是不是EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware,ApplicationEventPublisherAware,MessageSourceAware,ApplicationContextAware的實現(xiàn)類。這里就會調(diào)用對應(yīng)的實現(xiàn)方法。代碼如下
    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        .......
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        .......

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
            return bean;
        }

        AccessControlContext acc = null;

        if (System.getSecurityManager() != null) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }

        if (acc != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareInterfaces(bean);
                return null;
            }, acc);
        }
        else {
            invokeAwareInterfaces(bean);
        }

        return bean;
    }
  1. 實例化Bean然后，檢查是否實現(xiàn)了InitializingBean的afterPropertiesSet方法，如果實現(xiàn)了就會調(diào)用
  2. Bean不為null并且bean不是合成的，如果實現(xiàn)了BeanPostProcessor的postProcessBeforeInitialization則會調(diào)用實現(xiàn)的postProcessAfterInitialization方法。

到此創(chuàng)建Bean 的流程就沒了，剩下的就是容器銷毀的時候的了

3.destory方法跟銷毀Bean

?Bean在創(chuàng)建完畢之后會檢查用戶是否指定了destroyMethodName以及是否實現(xiàn)了DestructionAwareBeanPostProcessor接口的requiresDestruction方法，如果指定了會記錄下來保存在DisposableBeanAdapter對象中并保存在bean的disposableBeans屬性中。代碼在AbstractBeanFactory的registerDisposableBeanIfNecessary中

    protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
          ......
                registerDisposableBean(beanName,
                        new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            ......
    }

public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
            List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) {
          .......
        String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
        if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) &&
                !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
            ......
            this.destroyMethod = destroyMethod;
        }
        this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
    }

?在銷毀Bean的時候最后都會調(diào)用AbstractAutowireCapableBeanFactory的destroyBean方法。

    public void destroyBean(Object existingBean) {
        new DisposableBeanAdapter(existingBean, getBeanPostProcessors(), getAccessControlContext()).destroy();
    }

這里是創(chuàng)建一個DisposableBeanAdapter對象，這個對象實現(xiàn)了Runnable接口，在實現(xiàn)的run方法中會調(diào)用實現(xiàn)的DisposableBean接口的destroy方法。并且在創(chuàng)建DisposableBeanAdapter對象的時候會根據(jù)傳入的bean是否實現(xiàn)了DisposableBean接口來設(shè)置invokeDisposableBean變量，這個變量表實有沒有實現(xiàn)DisposableBean接口

    public DisposableBeanAdapter(Object bean, List<BeanPostProcessor> postProcessors, AccessControlContext acc) {
        Assert.notNull(bean, "Disposable bean must not be null");
        this.bean = bean;
        this.beanName = bean.getClass().getName();
          //根據(jù)傳入的bean是否實現(xiàn)了`DisposableBean`接口來設(shè)置`invokeDisposableBean`變量
        this.invokeDisposableBean = (this.bean instanceof DisposableBean);
        this.nonPublicAccessAllowed = true;
        this.acc = acc;
        this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
    }

    public void destroy() {
        ......
  //根據(jù)invokeDisposableBean決定是否調(diào)用destroy方法
        if (this.invokeDisposableBean) {
            if (logger.isTraceEnabled()) {
                logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
            }
            try {
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                        ((DisposableBean) this.bean).destroy();
                        return null;
                    }, this.acc);
                }
                else {
                    ((DisposableBean) this.bean).destroy();
                }
            }
            catch (Throwable ex) {
                String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
                if (logger.isDebugEnabled()) {
                    logger.warn(msg, ex);
                }
                else {
                    logger.warn(msg + ": " + ex);
                }
            }
        }
......
    }
4.總結(jié)。

最后來一個大的流程


實例化前的準(zhǔn)備階段

實例化前

實例化后

初始化前

初始化之后+銷毀

關(guān)于Spring的BeanFactoryPostProcessor跟BeanPostProcessor后面會介紹

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容