老子終于更新了曲伊，哈哈哈哈
上回書咱們說道叽讳，bean的生成全靠BeanDefinition，但是BeanDefinition里面僅僅只有bean的結(jié)構(gòu)內(nèi)容坟募，而它還要經(jīng)過一系列的組裝岛蚤，再最終完成后可能跟當(dāng)初定義的bean大相徑庭，就好比我和思聰在上帝那都定義為人懈糯，但是出生的時(shí)候....默默流下了淚水涤妒。這里，我們就圍繞著bean在生產(chǎn)過程中遇到的一些事件（比實(shí)例化前后處理器等）來展開剖析赚哗。

一. doGetBean

doGetBean是在AbstractBeanFactory容器中定義的方法她紫，我們就拿他來開刀。

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

        // 這里主要是處理別名或者FactoryBean的名字
        final String beanName = transformedBeanName(name);
        Object bean;

        // 先從三級(jí)緩存中嘗試獲取bean蜂奸，詳情見下文
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            if (logger.isTraceEnabled()) {
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                            "' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            // 這個(gè)主要對FactoryBean做處理犁苏，如果sharedInstance 是一個(gè)FactoryBean，那它將返回FactoryBean中所創(chuàng)建的實(shí)例
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

        else {

            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            //先委托給父BeanFactory去看看能否創(chuàng)建出實(shí)例
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                String nameToLookup = originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                            nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) {
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else if (requiredType != null) {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                else {
                    return (T) parentBeanFactory.getBean(nameToLookup);
                }
            }

            //標(biāo)記Bean為正在創(chuàng)建中的一個(gè)狀態(tài)
            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }

            try {
                //如果此bean對應(yīng)的BeanDefinition有雙親扩所，則需要合并BeanDefinition中的內(nèi)容
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);

                // 這里獲取XML中顯示指定的depends-on的依賴围详，并遞歸獲取這些依賴Bean的實(shí)例
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dep : dependsOn) {
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        registerDependentBean(dep, beanName);
                        try {
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }

                // 我們主要分析單例Bean的生成
                if (mbd.isSingleton()) {
                    // addSingleton里面調(diào)用的核心是createBean，在createBean方法創(chuàng)建完bean之后會(huì)把bean加入一級(jí)緩存并刪除二三級(jí)的緩存
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

                //忽略部分代碼
                .....

                }
            }
            catch (BeansException ex) {
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
        }

        //忽略部分代碼
        .....

        return (T) bean;
    }

getSingleton

singletonObject : 第一級(jí)緩存祖屏，存放完整的Bean
earlySingletonObjects: 第二級(jí)緩存助赞，存放不完整的Bean
singletonFactories: 第三級(jí)緩存，存放Bean工廠
singletonObject 是一個(gè) ConcurrentHashMap袁勺，而earlySingletonObjects和singletonFactories是一個(gè)HashMap雹食，看下這個(gè)方法的實(shí)現(xiàn)就知道為啥。

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        //肯定要先看看一級(jí)緩存在不在
        Object singletonObject = this.singletonObjects.get(beanName);
        //該Bean不存在或者還在創(chuàng)建中
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                //從二級(jí)緩存中取
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    //從三級(jí)緩存中取
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        //如果從Bean工廠中拿到bean則存入二級(jí)緩存并刪除三級(jí)緩存
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

二. createBean

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        if (logger.isTraceEnabled()) {
            logger.trace("Creating instance of bean '" + beanName + "'");
        }
        RootBeanDefinition mbdToUse = mbd;

        // 這里主要是加載bean的Class
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        // 這里準(zhǔn)備需要重寫的方法期丰，注意這里不是@override標(biāo)記的方法群叶，而是在XML中顯示指明要替換的方法，
        try {
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }

        try {
            //這里就精髓了钝荡，如果用戶自定義了bean的生成方式街立，則直接return，返回不會(huì)讓doCreateBean方法執(zhí)行埠通，詳情看下文
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }

        try {
            //這里是bean生成的核心具篇，詳情看下文
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isTraceEnabled()) {
                logger.trace("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
        }
        catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {

            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
        }
    }

resolveBeforeInstantiation

在bean生成的時(shí)候略步，Spring會(huì)加載很多BeanPostProcessors來對bean的生成過程做一個(gè)增強(qiáng)。
而InstantiationAwareBeanPostProcessor是眾多BeanPostProcessor子類的其中之一芹务，它里面有5個(gè)關(guān)鍵的方法：

postProcessBeforeInstantiation：Bean實(shí)例化的前置方法
postProcessAfterInstantiation：Bean實(shí)例化的后置方法
postProcessBeforeInitialization：Bean初始化的前置方法
postProcessAfterInitialization：Bean初始化的后置方法
postProcessProperties：輔助依賴注入

applyBeanPostProcessorsBeforeInstantiation的目的就是執(zhí)行Bean實(shí)例化的前置方法。假如Bean實(shí)例化的前置方法中生成了用戶自定義的Bean，那就會(huì)直接執(zhí)行Bean初始化的后置方法，之后將生成的Bean直接返回給用戶，而不交由spring的doCreateBean來創(chuàng)建Bean码撰。

    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }

二.doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            //嘗試從緩存中獲取factoryBean（就當(dāng)是我們將要獲取的bean的包裝bean實(shí)例）
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            //嘗試使用工廠方法、有參構(gòu)造函數(shù)众雷、無參構(gòu)造函數(shù)去實(shí)例化一個(gè)bean
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    //這里是為依賴注入做準(zhǔn)備灸拍，主要是AutowiredAnnotationBeanPostProcessor起作用
                    //這個(gè)PostProcessor會(huì)解析@autowired和@value注解并把標(biāo)記的屬性封裝成InjectionMetadata元數(shù)據(jù)加入緩存，
                    //之后在populateBean中會(huì)調(diào)用此PostProcessor實(shí)例化后置方法并根據(jù)這些元數(shù)據(jù)去進(jìn)行屬性注入
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }

        
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
                logger.trace("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            // addSingletonFactory就是將bean加入第三級(jí)緩存
            // getEarlyBeanReference的實(shí)現(xiàn)是在AbstractAutoProxyCreator這個(gè)類里面砾省，里面是實(shí)現(xiàn)AOP和創(chuàng)建代理對象的核心
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        Object exposedObject = bean;
        try {
            // 屬性注入的核心方法鸡岗，下文會(huì)講到
            populateBean(beanName, mbd, instanceWrapper);
            // 1.處理繼承了BeanNameAware、BeanClassLoaderAware编兄、BeanFactoryAware接口的bean并注入這些值
            // 2.執(zhí)bean初始化前置方法
            // 3.執(zhí)bean初始化方法
            // 4.執(zhí)bean初始化后置方法
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        //忽略部分代碼
        .....

        
    }

populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        //忽略部分代碼
        .....

        // 這里是執(zhí)行實(shí)例化的后置方法轩性，這個(gè)方法返回值為boolean，可以控制能否繼續(xù)執(zhí)行后面有關(guān)依賴注入的代碼
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        return;
                    }
                }
            }
        }

        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

        //這里是處理xml中某些Bean顯示指定BY_NAME或BY_TYPE的方式來注入
        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;
        }

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

        //下面這一塊就是注入的核心流程了狠鸳，主要還是依賴于AutowiredAnnotationBeanPostProcessor，會(huì)在Bean列表中找出最符合的bean注入件舵，這個(gè)有時(shí)間再細(xì)細(xì)擼
        PropertyDescriptor[] filteredPds = null;
        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);
        }

        if (pvs != null) {
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }

總結(jié)

按順序來描述一下bean生成經(jīng)歷的一些過程（縮進(jìn)太多我直接貼圖了）

image.png

Bean到底是咋生下來的逊朽？

Bean到底是咋生下來的？

一. doGetBean

getSingleton

二. createBean

resolveBeforeInstantiation

二.doCreateBean

populateBean

總結(jié)