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;
    }