Spring源碼解析——createBean方法細節之doCreateBean

doCreateBean方法位於AbstractAutowireCapableBeanFactory方法中

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        // Instantiate the bean.
        //BeanWrapper提供設置和獲取屬性值（單獨或批量），獲取屬性描述符和查詢屬性以確定它們是可讀還是可寫的功能
        BeanWrapper instanceWrapper = null;
        //如果RootBeanDefinition是單例的，則移除未完成的FactoryBean實例的緩存
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            //創建bean實例
            //------------------------------------------方法1----------------------------------------//
            instanceWrapper = createBeanInstance(beanName, mbd, args);
       //------------------------------------------方法1----------------------------------------//
        }
      //獲取BeanWrapper中封裝的Object對象，其實就是bean對象的實例
        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    //獲取BeanWrapper中封裝的bean的Class
        Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

        // Allow post-processors to modify the merged bean definition.
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
            //--------------------------------------------------2---------------------------------------------//
          ////bean 的生命週期之一。如果實現了MergedBeanDefinitionPostProcessor會在這裏調用postProcessMergedBeanDefinition方法
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                //--------------------------------------------------2---------------------------------------------//
                mbd.postProcessed = true;
            }
        }

        // Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
              //如果RootBeanDefinition是單例的，並且開啓了自動嘗試解析bean之間的循環引用，並且當前bean正在創建中，則說明這個bean需要被加入到緩存的單例bean集合中
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            /**
             * addSingletonFactory會將beanName和ObjectFactory對象作爲鍵值對保存到緩存的單例集合中
             * singletonObjects： 單例對象的緩存 ConcurrentHashMap
             * singletonFactories：單例工廠的緩存 HashMap
             * earlySingletonObjects： 早期單例對象的緩存  HashMap
             * registeredSingletons： 一組已經註冊的單例，按註冊順序排序   LinkedHashSet
             */
            addSingletonFactory(beanName, new ObjectFactory<Object>() {
                public Object getObject() throws BeansException {
//---------------------------------------------3------------------------------//
                    return getEarlyBeanReference(beanName, mbd, bean);
//---------------------------------------------3------------------------------//
                }
            });
        }
        // Initialize the bean instance.
        Object exposedObject = bean;

        try {
//---------------------------------------------4------------------------------//
                  //進行屬性填充
            populateBean(beanName, mbd, instanceWrapper);
//---------------------------------------------4------------------------------//
            if (exposedObject != null) {
                //---------------------------------------------5------------------------------//
                //初始化給定的bean實例，應用工廠回調以及init方法和bean後處理器
                exposedObject = initializeBean(beanName, exposedObject, mbd);
                //---------------------------------------------5------------------------------//
            }
        }
        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);
            }
        }
    //如果單例bean已經緩存了，則直接獲取            
        if (earlySingletonExposure) {
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
//如果不允許在循環引用的情況下使用注入原始bean實例（即使注入的bean最終被包裝），並且依賴的bean列表中存在需要創建bean。這時候就說明存在循環依賴
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    //根據beanName獲取所有依賴的bean的beanName
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
                        //刪除存在循環依賴的bean    
                        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.");
                    }
                }
            }
        }

        // Register bean as disposable.
        try {
                        //將給定的bean添加到此一次性Bean列表中，這個列表中的bean在Spring關閉的時候會查詢裏面的bean，並調用實現的銷燬方法（包含實現了DisposableBean接口的方法和自定義的destory方法），滿足其中一個條件
            // 1.實現了DisposableBean接口
            //2.自定義了destroy方法
            //3.實現了AutoCloseable接口
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }

（1）方法1：createBeanInstance

這個createBeanInstance方法位於AbstractAutowireCapableBeanFactory類中

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
        // Make sure bean class is actually resolved at this point.
        //獲取RootBeanDefinition的Class屬性
        Class<?> beanClass = resolveBeanClass(mbd, beanName);
        //如果bean的類修飾符不是public則報錯
        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());
        }
        //查看RootBeanDefinition的factor-method屬性是不是空的，不爲空，說明bean 
        // 的實現要通過先實例化對應的factoryBean然後調用factoryMethod方法實現，或者直接調用靜態的factoryMethod方法
        if (mbd.getFactoryMethodName() != null)  {
//---------------------------------------------1------------------------------------------//
            return instantiateUsingFactoryMethod(beanName, mbd, args);
//---------------------------------------------1------------------------------------------//
        }

        // Shortcut when re-creating the same bean...
         //重新創建同一個bean時相關的判斷條件
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
    //如果緩存的已解析的構造函數或工廠方法對象不爲空，則說明這是重新創建同一個bean
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
  //如果是重新創建，就直接創建
        if (resolved) {
        //如果構造函數參數標記是已解析，就直接進行構造，否則重新解析然後創建
            if (autowireNecessary) {
//-----------------------------------------2--------------------------------------------------//
                return autowireConstructor(beanName, mbd, null, null);
//-----------------------------------------2--------------------------------------------------//
            }
            else {
                //使用給出的構造器來創建bean並封裝到BeanWrapperImpl中，這個方法在autowireConstructor也有用到
                return instantiateBean(beanName, mbd);
            }
        }

        // Need to determine the constructor...
            //如果不是重新創建的bean，需要確定要用於給定bean的候選構造函數，檢查所有已註冊的構造函數
                    //bean 的生命週期之一，如果實現了SmartInstantiationAwareBeanPostProcessor接口，會在這裏調用determineCandidateConstructors方法
        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
            return autowireConstructor(beanName, mbd, ctors, args);
        }

        // No special handling: simply use no-arg constructor.
          //沒有特殊處理：只需使用no-arg構造函數
        return instantiateBean(beanName, mbd);
    }

（1.1）查看instantiateUsingFactoryMethod方法的具體實現

instantiateUsingFactoryMethod方法位於AbstractAutowireCapableBeanFactory類中

protected BeanWrapper instantiateUsingFactoryMethod(
            String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {
//相當於調用AbstractAutowireCapableBeanFactory類的instantiateUsingFactoryMethod方法
        return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
    }
//instantiateUsingFactoryMethod方法的邏輯就是用定義的factoryBean的factoryMethod方法來創建bean，或者用靜態的factoryMethod方法來實現。然後獲取到的bean用BeanWrapperImpl封裝返回的信息。

（1.2）我們查看autowireConstructor方法的具體實現 autowireConstructor方法的詳解

（2）方法2：applyMergedBeanDefinitionPostProcessors

這個方法在實例化Bean後調用

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName)
            throws BeansException {

        try {
            //獲取這個bean所有的實現了BeanPostProcessor接口的類
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                //如果是MergedBeanDefinitionPostProcessor類型的就調用實現的postProcessMergedBeanDefinition方法，
                if (bp instanceof MergedBeanDefinitionPostProcessor) {
                    MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
                    bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
                }
            }
        }
        catch (Exception ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Post-processing failed of bean type [" + beanType + "] failed", ex);
        }
    }

（3）getEarlyBeanReference方法

這個方法主要用於檢查這個bean是否已經

    protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        //bean不爲空，並且RootBeanDefinition是程序自己定義的，並且實現了InstantiationAwareBeanPostProcessors（一個bean實例化過程中調用的類）
        if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    //獲取早期訪問指定bean的引用，通常用於解析循環引用。
                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                    if (exposedObject == null) {
                        return null;
                    }
                }
            }
        }
        return exposedObject;
    }

（4）populateBean方法

使用bean定義中的屬性值填充給定BeanWrapper中的bean實例

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
        //獲取RootBeanDefinition中bean的屬性值
        PropertyValues pvs = mbd.getPropertyValues();
        //如果BeanWrapper爲null說明bean沒有實例化成功，會報錯
        if (bw == null) {
            if (!pvs.isEmpty()) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
            else {
                // Skip property population phase for null instance.
                return;
            }
        }
        // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the state of the bean before properties are set. This can be used, for example, to support styles of field injection.
        //爲任何實現了InstantiationAwareBeanPostProcessors接口的方法，提供在設置屬性之前修改bean狀態的機會，就是實例化bean的時候（不是復賦值的時候）
        boolean continueWithPropertyPopulation = true;
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    //調用實現的postProcessAfterInstantiation方法
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }
        if (!continueWithPropertyPopulation) {
            return;
        }
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            //深拷貝RootBeanDefinition的所有的屬性值。保證PropertyValue引用是獨立的，但它不能深度複製當前由各個PropertyValue對象引用的對象。
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            // Add property values based on autowire by name if applicable.
            //按照按名稱注入的方式注入
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {

                autowireByName(beanName, mbd, bw, newPvs);
            }
            // Add property values based on autowire by type if applicable.
            //按照按名稱類型的方式注入
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }
        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
        //如果bean實現了InstantiationAwareBeanPostProcessor接口或者bean需要進行依賴檢查，需要進行處理
        if (hasInstAwareBpps || needsDepCheck) {
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            //一次調用實現的InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues方法
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }
            //進行依賴檢查，主要檢查設置到bean中的數據類型和對象是否個bean對象自身定義的數據類型和對象是不是一樣
            if (needsDepCheck) {
                checkDependencies(beanName, mbd, filteredPds, pvs);
            }
        }

        applyPropertyValues(beanName, mbd, bw, pvs);
    }

//其中的autowireByName方法解析
      protected void autowireByName(
            String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
        //獲取所有的不是普通屬性（普通指的基本類型，字符串，數字類型，日期，URL，URI一個Local類或者一個Class對象）的元素的name（name從BeanWrapper中獲取）數組
        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        //按照獲取的名稱去找對應的bean，並添加到依賴緩存集合中記錄
        for (String propertyName : propertyNames) {
            if (containsBean(propertyName)) {
                Object bean = getBean(propertyName);
                pvs.add(propertyName, bean);
                registerDependentBean(propertyName, beanName);
                if (logger.isDebugEnabled()) {
                    logger.debug("Added autowiring by name from bean name '" + beanName +
                            "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
                }
            }
            else {
                if (logger.isTraceEnabled()) {
                    logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
                            "' by name: no matching bean found");
                }
            }
        }
    }

（5）initializeBean方法

在這裏會初始化已經實例化之後的bean，並會在這裏調用部分用戶自己實現了的bean生命週期的方法

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        //如果bean是BeanNameAware，BeanClassLoaderAware或者BeanFactoryAware其中某一個的實現類就需要進行處理
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>() {
                public Object run() {
                    invokeAwareMethods(beanName, bean);
                    return null;
                }
            }, getAccessControlContext());
        }
        else {
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        //bean的生命週期之一。如果實現了BeanPostProcessor接口則在這裏調用postProcessBeforeInitialization方法
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }
        //bean的生命週期之一，如果實現了InitializingBean接口，會在這裏調用實現的afterPropertiesSet方法
        try {
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
        //bean的生命週期之一。如果實現了BeanPostProcessor接口則在這裏調用postProcessAfterInitialization方法
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }