上節(jié)簡(jiǎn)單說(shuō)了FatoryBeanRegistrySupport的方法和以及作用,我們知道該方法主要是對(duì)工廠的FactoryBean的一系列的處理,如注冊(cè)以及后置處理等操作.接下來(lái)我們來(lái)簡(jiǎn)單的理解下AbstractBeanFactory的作用和它的家族體系.首先來(lái)看它的家族體系如圖:

AbstractBeanFactory.png

由圖我們直接的看出,AbstractBeanFactory繼承了FatoryBeanRegistrySupport的同時(shí),也實(shí)現(xiàn)了ConfigurableBeanFactory,可想而知abstractFactoryBean的功能有多強(qiáng)大,這里只是簡(jiǎn)單的猜測(cè),我們來(lái)看它的具體實(shí)例.

一. AbstractBeanFactory的作用

• api里是這樣說(shuō)的,是抽象BeanFactory的基類,同時(shí)實(shí)現(xiàn)了ConfigurableBeanFactory的SPI,提供了所有的功能
• 也可以從我們定義的資源中resource中來(lái)獲取bean的定義.
• 也提供了單例bean的緩存通過(guò)他的爺爺如圖中的DefaultSingletonBeanRegistry,同時(shí)提供了單例和多例和別名的定義等操作.
• 上述只是其中的一部分,總之來(lái)說(shuō)它的作用還是挺大的.

二.源碼閱讀

由于該類方法較多,這里我們簡(jiǎn)單的說(shuō)幾個(gè)重要的方法:

//獲取bean
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

該方法是實(shí)現(xiàn)了BeanFactory接口的getBean()方法,spring里面都是一般這樣做的,獲取某個(gè)東西,實(shí)際上封裝了一層內(nèi)部調(diào)用如上述代碼的doGetBean()方法,那么該方法肯定是我們學(xué)習(xí)的重要目標(biāo)了,那么它到底是做了什么我們來(lái)看,代碼如下:

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

    //該方法去掉別名之后的bean的name,如我這里有一個(gè)Student的真實(shí)的bean,別名為 Student------>aaStudent
    //Student-------->aaaaStudent,該方法內(nèi)部循環(huán)處理,最終返回Student即可
    final String beanName = transformedBeanName(name);
    Object bean;

    //從上面的去掉別名的beanName拿到后,從緩存中去拿,調(diào)用了DefaultSingletonBeanRegistry的getSingleton方法
    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 + "'");
            }
        }
        //獲取bean的實(shí)例
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    //這里表明上述的sharedInstance為null
    else {
        //這里分情況來(lái)看,spring考慮到了,如果當(dāng)前的bean已經(jīng)被創(chuàng)建,獲取會(huì)失敗,可能有別的bean在引用該bean
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        //從父工廠中去拿,看是否有該bean的定義
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            //當(dāng)前類的爸爸中沒(méi)找到,從爺爺輩去找,直到找到
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                //調(diào)用AbstractBeanFactory的doGetBean方法去獲取bean的實(shí)例
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            }
            //args為首次創(chuàng)建bean的實(shí)例時(shí)的參數(shù)
            else if (args != null) {
                //使用代理的方式去獲取bean實(shí)例
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            //bean的真實(shí)類型
            else if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            //這里表示我們的args和requiredType都為null,直接通過(guò)得到的bean的名字去獲取實(shí)例
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }
        //對(duì)bean的真實(shí)類型檢查,在檢查之前不可使用該bean
        if (!typeCheckOnly) {
            //對(duì)已經(jīng)創(chuàng)建完的bean的實(shí)例做標(biāo)記,如:已完成創(chuàng)建
            markBeanAsCreated(beanName);
        }

        try {
            //合并父子bean的定義
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            //檢查合并之后的bean的定義,必要時(shí)拋異常
            checkMergedBeanDefinition(mbd, beanName, args);

            //先初始化當(dāng)前bean所依賴的bean
            //如:我的訂單類需要商品類,此刻spring會(huì)先初始化商品類,大概就是這樣的
            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 + "'");
                    }
                    //給當(dāng)前bean注冊(cè)一個(gè)依賴bean
                    registerDependentBean(dep, beanName);
                    try {

                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            // Create bean instance.
            //創(chuàng)建bean實(shí)例
            //單例的情況下
            if (mbd.isSingleton()) {
                //從緩存(singletonObjects)中去拿
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        //最后從緩存中移除對(duì)應(yīng)的實(shí)例原因有:
                        //1.每當(dāng)有bean在創(chuàng)建時(shí),允許循環(huán)參考來(lái)解析對(duì)應(yīng)的beanDefinition
                        //2.刪除臨時(shí)引用該bean的bean
                        destroySingleton(beanName);
                        throw ex;
                    }
                });

                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            //多例的情況下:
            else if (mbd.isPrototype()) {

                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    //創(chuàng)建完bean的處理
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            else {
                //獲取bean的作用域
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new BeanCreationException(beanName,
                            "Scope '" + scopeName + "' is not active for the current thread; consider " +
                            "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                            ex);
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    //檢查類型與實(shí)際的bean的是否匹配
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
        }
        catch (TypeMismatchException ex) {
            if (logger.isTraceEnabled()) {
                logger.trace("Failed to convert bean '" + name + "' to required type '" +
                        ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

上面代碼是spring如何獲取bean的過(guò)程,實(shí)際最核心的是createBean() 方法,該方法真正的創(chuàng)建bean的過(guò)程

/**
 * 該方法是AbstractAutowireCapableBeanFactory中的實(shí)現(xiàn)方法
 *
 */
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;

    // Make sure bean class is actually resolved at this point, and
    // clone the bean definition in case of a dynamically resolved Class
    // which cannot be stored in the shared merged bean definition.
    //解析bean的class
    //1.這里當(dāng)解析的resolvedClass和mbd.hasBeanClass()為falsembd.getBeanClassName()同時(shí)成立時(shí)
    //2.這里需要我們new一個(gè)合并的beanDefinition類,同時(shí)設(shè)置class類型
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    //覆蓋了RootBeanDefinition的prepareMethodOverrides方法
    try {
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }

    try {
        //獲取一個(gè)解析之后的代理bean的實(shí)例,而不是真正的bean實(shí)例
        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 {
        //這里才是真正的執(zhí)行創(chuàng)建bean的方法
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        // A previously detected exception with proper bean creation context already,
        // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    }
}

再來(lái)看真正的創(chuàng)建bean的方法:

/**
 * 該方法是真正的創(chuàng)建bean的方法
 * @param beanName 要?jiǎng)?chuàng)建bean的名稱
 * @param mbd 定義bean的beanDefinition文件
 * @param args 創(chuàng)建bean時(shí),構(gòu)造方法所需的參數(shù)或者是調(diào)用bean工廠時(shí)來(lái)創(chuàng)建bean所需的參數(shù)
 * @return 完成創(chuàng)建之后的bean的實(shí)例
 * @throws BeanCreationException
 */
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
        throws BeanCreationException {

    //實(shí)例化bean的過(guò)程
    BeanWrapper instanceWrapper = null;
    //如果是單例,從factoryBeanInstanceCache中移除相應(yīng)的bean實(shí)例
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    //創(chuàng)建實(shí)例
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    //獲取封裝實(shí)例
    final Object bean = instanceWrapper.getWrappedInstance();
    //獲取對(duì)應(yīng)實(shí)例的class類型
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        //將獲取到的bean類型賦值給mbd的resolvedTargetType
        //resolvedTargetType用來(lái)保存真實(shí)類型bean的類型
        mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    //允許后置處理修改mbd
    synchronized (mbd.postProcessingLock) {
        //postProcessed默認(rèn)為false,故不能修改,這里取反表示可以修改
        if (!mbd.postProcessed) {
            try {
                //對(duì)bean進(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;
        }
    }

    //處理循環(huán)引用和bean的生命周期
    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(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    //初始化bean實(shí)例
    Object exposedObject = bean;
    try {
        //給bean的實(shí)例填充屬性
        populateBean(beanName, mbd, instanceWrapper);
        //初始化bean的實(shí)例
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
        else {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }
    //引用問(wèn)題處理,這里先暴露早期單例引用的bean
    if (earlySingletonExposure) {
        //從緩存注冊(cè)中獲取,這里不允許早期引用的創(chuàng)建
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName,
                            "Bean with name '" + beanName + "' has been injected into other beans [" +
                            StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                            "] in its raw version as part of a circular reference, but has eventually been " +
                            "wrapped. This means that said other beans do not use the final version of the " +
                            "bean. This is often the result of over-eager type matching - consider using " +
                            "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }

    //注冊(cè)bean
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

上述就是spring創(chuàng)建bean的過(guò)程,實(shí)際上真正創(chuàng)建bean的方法在doCreateBean這里,關(guān)于spring的如何獲取bean的過(guò)程在后續(xù)再說(shuō).