spring ioc 源码分析（三）--finishBeanFactoryInitialization(beanFactory)

之前的博客专门分析了一个类到BeanDefinition的创建过程，现在分析BeanDefinition 到一个bean的创建过程：从refresh() 方法的---->finishBeanFactoryInitialization(beanFactory) 开始：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // 像容器中设置一个类型转换器
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        //设置一个占位符解析器
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }

        // loadTimeWeaver是用于类加载阶段做切入使用的
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }

        // Stop using the temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(null);

        // 冻结beanDefinition信息，也就是下面要开始创建对象了，所以不允许再改变了
        beanFactory.freezeConfiguration();

        // Instantiate all remaining (non-lazy-init) singletons. //开始实例化所有的单例bean
        beanFactory.preInstantiateSingletons();
    }

小结：该方法主要是在单例bean开始初始化前，对beanFactory设置一些初始化信息，最重要的还是： beanFactory.preInstantiateSingletons();

public void preInstantiateSingletons() throws BeansException {
       List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); //获取所有的beanNams 然后遍历每个beanName,获取其BeanDefintion，然后一个个的创建实例

        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); //这里为何是获取MergeBeanDefinition呢，原因是在xml时代，一个bean 可以通过继承一个抽象的bean,来获得初始化的属性
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { //在这里的beanDefinition必须不是抽象的，并且是单例，非懒加载的
                if (isFactoryBean(beanName)) { //如果是FactoryBean，通过get(BeanName)方式获取的是里面的getObject()返回的对象，如果是get("&beanName")的方式，就是获取到FactoryBean本身
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);//get("&beanName")方式，获取到FactoryBean本身
                    if (bean instanceof FactoryBean) {
                        final FactoryBean<?> factory = (FactoryBean<?>) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                            ((SmartFactoryBean<?>) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        if (isEagerInit) { //这里的意思是，是否要那么早初始化FactoryBean里面的getObject（）对象，默认是用到时才会初始化
                            getBean(beanName);//这里调用的是FactoryBean里面的getObject()
                        }
                    }
                }
                else {
                    getBean(beanName);//非factoryBean就开始创建对象，factoryBean 也是调用该方法创建对象，只是beanName不一样getBean(FACTORY_BEAN_PREFIX + beanName)
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) { //至此，所有的实例对象都创建完毕，对于实现SmartInitializingSingleton的bean,在这里会统一调用afterSingletonsInstantiated（）
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }, getAccessControlContext());
                }
                else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
    }

小结：上面方法主要逻辑是：遍历所有的bean的定义信息，然后分别创建实例，这里区分了FactoryBean和普通Bean的创建过程，所有Bean都创建完毕后，会对实现SmartInitializingSingleton接口的bean,调用afterSingletonsInstantiated（）

//接下来我们分析下单个bean的创建过程：getBean(beanName)

//下面参数的意思： name或者requiredType的意思是通过名称还是通过类型获取对象，args的意思是，如果是通过有参构造器去创建的bean，需要该实参，typeCheckOnly的意思是，我只是想获取返回的类型而不是对象，例如我想知道某个beanName的类型
//一般typeCheck是用于FactoryBean校验里面的getObject()返回的类型
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { 

        final String beanName = transformedBeanName(name);//这里的意思的，在xml时代，一个bean可以拥有多个别名，如果你是通过别名来创建对象的话，这里就会转成对应的BeanName，因为BeanName才是唯一的
        Object bean;

        // Eagerly check singleton cache for manually registered singletons.
        Object sharedInstance = getSingleton(beanName);//校验实例对象是否已经存在了
        if (sharedInstance != null && args == null) {
            if (logger.isTraceEnabled()) {
                if (isSingletonCurrentlyInCreation(beanName)) {//判断singletonsCurrentlyInCreation集合有没有该bean,有就代表正在创建中
                    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 = getObjectForBeanInstance(sharedInstance, name, beanName, null);//这里的意思是：既然bean已经创建了，如果是FactoryBean,那么这里就要返回FactoryBean里面的Object对象，其他的Bean直接返回
        }

        else {
            //该方法只有非单例才会出现，这里是判断prototypesCurrentlyInCreation有没包含该BeanName,prototypesCurrentlyInCreation是一个ThreadLocal,所以存在代表创建了2次
            // We're assumably within a circular reference.
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // Check if bean definition exists in this factory.
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { //这里面的逻辑是，如果BeanFactory并没有包含该Bean的定义信息，那么久去找其父类，看看父类有没该bean
                // Not found -> check parent. //查找父类看看有没该Bean
                String nameToLookup = originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                            nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) {
                    // Delegation to parent with explicit args. //使用有参构造器去创建实例
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else if (requiredType != null) {
                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);//通过类型去创建实例
                }
                else {
                    return (T) parentBeanFactory.getBean(nameToLookup);//通过名称去创建实例
                }
            }

            if (!typeCheckOnly) {
                markBeanAsCreated(beanName); //这里的意思是，本次调用方法，并非是要获取bean的类型，而是为了创建实例，将beanName存到alreadyCreated集合，代表该bean已经创建了，后面try。。catch有异常会清空该beanName
            }

            try {
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);//mergeBeanDefinition的作用是解决xml时代，bean继承一个抽象bean,获取其对应属性，类之间并非真的是继承关系
                checkMergedBeanDefinition(mbd, beanName, args);//这里检查mbd是否是抽象的，抽象的话就不能创建

                // Guarantee initialization of beans that the current bean depends on.
                String[] dependsOn = mbd.getDependsOn(); //这里是解决@DependsOn（"xx"）注解的作用，该注解的作用是，创建某个Bean前，必须先创建xx,xx可以是个数组
                if (dependsOn != null) {
                    for (String dep : dependsOn) {
                        if (isDependent(beanName, dep)) { //判断是否相互之间有依赖关系，这个要结合下面代码registerDependentBean(dep, beanName);才好理解
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        registerDependentBean(dep, beanName);
                        try {
                            getBean(dep); //先创建依赖的Bean
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }

                // Create bean instance.
                if (mbd.isSingleton()) { //如果是单例，就通过调用该方法创建
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            // Explicitly remove instance from singleton cache: It might have been put there
                            // eagerly by the creation process, to allow for circular reference resolution.
                            // Also remove any beans that received a temporary reference to the bean.
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);//这里的意思前面也分析过了，意思是，如果是FactroyBean，就调用其getObject()方法，返回对应的对象
                }

                else if (mbd.isPrototype()) { //如果是非单例
                    // It's a prototype -> create a new instance.
                    Object prototypeInstance = null;
                    try {
                        beforePrototypeCreation(beanName);//存到prototypesCurrentlyInCreation这个ThreadLocal中，代表正在创建
                        prototypeInstance = createBean(beanName, mbd, args);//该方法跟单例创建实例调用的逻辑是一样的，后续会分析
                    }
                    finally {
                        afterPrototypeCreation(beanName);//既然创建完毕，那么久可以从ThreadLocal中移除该bean了
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);//这里逻辑前面分析过了
                }

                else {
                    String scopeName = mbd.getScope(); //@Scope标注的bean 下面的逻辑跟创建非单例（原型protoType）bean一样
                    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);//前面做了markBeanAsCreated(beanName)代表该bean已经创建，失败后，这里就要删除
                throw ex;
            }
        }

        // Check if required type matches the type of the actual bean instance.
        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;
    }

//小结：上面主要对不同的bean类型做了不同的操作，同时对依赖关系的bean也做了处理，主要方法：createBean(beanName, mbd, args)

后续有一个方法会经常用到，在这里提前分析：Object sharedInstance = getSingleton(beanName,true)；

    //该方法可以解决循环依赖，也就是A和B相互依赖，例如使用@autowried注解
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {//allowEarlyReference代表是否允许循环依赖
        Object singletonObject = this.singletonObjects.get(beanName);//我们创建的单例bean都会存在该Map中，如果已经创建，那么久可以获取到，我们可以把它看作一级缓存
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
         //当一个Bean正在创建中此时已经new出来目标对象了，只是还没有经过后置处理器处理，所以此时它是正在创建中，A依赖B,然后创建B,发现B依赖A,那么久会创建A，创建A时，发现A已经正在创建了
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName); //先从二级缓存获取
                if (singletonObject == null && allowEarlyReference) {//获取不到
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); //再从三级缓存获取，该缓存是一个单例工厂
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();//工厂中获取对象
                        this.earlySingletonObjects.put(beanName, singletonObject);//存入二级缓存
                        this.singletonFactories.remove(beanName);//移除工厂  那么问题：为何要有二三级缓存？原因是工厂里面的方法可能会很复杂，所以工厂获取对象后，存到二级缓存中，下次再次获取就更高效率了
                    }
                }
            }
        }
        return singletonObject;
    }

//接下来，我们来分析bean的创建过程createBean(beanName, mbd, args)，由于单例创建过程内容多点，我们从单例的代码入手：

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "Bean name must not be null");
        synchronized (this.singletonObjects) {
            Object singletonObject = this.singletonObjects.get(beanName);  //先从单例缓存中获取
            if (singletonObject == null) {
                if (this.singletonsCurrentlyInDestruction) { //判断beanFactroy是否正在执行销毁操作
                    throw new BeanCreationNotAllowedException(beanName,
                            "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                            "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
                }
               }
                beforeSingletonCreation(beanName);//存beanName到singletonsCurrentlyInCreation集合，代表单例bean正在创建
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);//用于记录异常用，不是我们关心的点
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<>();
                }
                try {
                    singletonObject = singletonFactory.getObject();//调用工厂方法，也就是我们说的createBean(beanName, mbd, args)
                    newSingleton = true;
                }
                catch (IllegalStateException ex) {
                    // Has the singleton object implicitly appeared in the meantime ->
                    // if yes, proceed with it since the exception indicates that state.
                    singletonObject = this.singletonObjects.get(beanName);//即使有异常，但目标对象已经创建了
                    if (singletonObject == null) {
                        throw ex;
                    }
                }
                catch (BeanCreationException ex) {
                    if (recordSuppressedExceptions) { //记录下异常的操作
                        for (Exception suppressedException : this.suppressedExceptions) {
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                    throw ex;
                }
                finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
                    afterSingletonCreation(beanName); //从singletonsCurrentlyInCreation集合中移除该beanName,因为已经创建完毕了
                }
                if (newSingleton) {
                    addSingleton(beanName, singletonObject);//这里逻辑是将该单例bean添加到this.singletonObjects.put(beanName, singletonObject);和 this.registeredSingletons.add(beanName);
                }
            }
            return singletonObject;
        }
    }

//小结：上面方法的核心逻辑是：设置单例bean正在创建中，创建完毕后，存到缓存；接下来我们要分析的是：createBean(beanName, mbd, args)

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

        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.
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);//获取真实的类型
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd); //这里新创建一个mbd 防止被其他线程更改
            mbdToUse.setBeanClass(resolvedClass);
        }

        // Prepare method overrides.
        try {
            mbdToUse.prepareMethodOverrides(); //用于校验@lookup注解相关的处理校验
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }

        try {
            // InstantiationAwareBeanPostProcessor 后置处理器执行postProcessBeforeInstantiation（） 方法
            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 {
            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);
        }
    }

小结：该方法主要是在bean实例化前对bean执行后置处理器InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation(beanClass, beanName);

下面跟进： Object beanInstance = doCreateBean(beanName, mbdToUse, args);

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

        // Instantiate the bean.
        BeanWrapper instanceWrapper = null; //对实例对象进行包装
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); //缓存中获取
        }
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args); //创建bean实例，后续会重点关注
        }
        final Object bean = instanceWrapper.getWrappedInstance(); //获取目标bean
        Class<?> beanType = instanceWrapper.getWrappedClass(); //获取类型
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;//修改beanDefinition的目标对象类型
        }

        // Allow post-processors to modify the merged bean definition.
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {//调用MergedBeanDefinitionPostProcessor 后置处理器的postProcessMergedBeanDefinition(mbd, beanType, beanName); 允许修改mbd
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }

        // Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName)); //如果是单例同时允许循环依赖，同时该bean是正在创建的，很明显，符合要求
        if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
                logger.trace("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            //工厂方法会调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference(Object bean, String beanName)
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); //设置单例的二级缓存this.singletonFactories.put(beanName, singletonFactory);
        }

        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
            populateBean(beanName, mbd, instanceWrapper); //给属性赋值（后续会分析）
            exposedObject = initializeBean(beanName, exposedObject, mbd);//执行init 方法（后续会分析）
        }
        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);
            }
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = getSingleton(beanName, false);//当有循环依赖时，这里就会从二级缓存中获取到早期的bean,如果没有循环依赖，这里获取到的是null
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
　　　　　　　　　　　　//如果不相等，例如使用@Async注解标注的bean,调用initializeBean(beanName, exposedObject, mbd);获得的是一个代理对象，因此exposedObject是代理对象，而bean还是原生对象，通过二级缓存得到的是原生对象
                    //如果循环依赖的bean已经创建完了，说明他们依赖的是原生的Bean而不是代理的bean,这样就会报错
                    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.");
                    }
                }
            }
        }

        // Register bean as disposable.
        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd); //有detroy方法的bean就会收集起来，当容器销毁时，就可以调用这些bean的destroy方法
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }

小结：该方法的核心是：创建bean的实例(createBeanInstance(beanName, mbd, args); )，进行属性赋值( populateBean(beanName, mbd, instanceWrapper);)，执行init方法(initializeBean(beanName, exposedObject, mbd);)，注册有detroy方法的bean,下面分别分析这三个方法：

1.createBeanInstance(beanName, mbd, args);

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        // Make sure bean class is actually resolved at this point.
        Class<?> beanClass = resolveBeanClass(mbd, beanName); //获取实际的类型

        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { //如果不是public修饰的，代表不能访问
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        }

        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);//如果有实例工厂，直接调用工厂方法
        }

        if (mbd.getFactoryMethodName() != null) {
            return instantiateUsingFactoryMethod(beanName, mbd, args);//如果是@bean修饰的方法，那么调用该方法即可（反射调用）
        }

        // Shortcut when re-creating the same bean...
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                if (mbd.resolvedConstructorOrFactoryMethod != null) { //如果是第二次创建相同bean,如原型对象，他们的beanDefinition对象已经知道用哪个构造器或者工厂方法了，此时就直接调用对应方法即可
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        if (resolved) {//之前已经调用过了，这里直接调用对应方法，根据构造器参数是否已经解析了来处理
            if (autowireNecessary) {
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                return instantiateBean(beanName, mbd);
            }
        }

        // Candidate constructors for autowiring?
        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); //第一次解析，就要获取合适的构造器
        if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
            return autowireConstructor(beanName, mbd, ctors, args);
        }

        // Preferred constructors for default construction?
        ctors = mbd.getPreferredConstructors();//如果有默认的合适构造器
        if (ctors != null) {
            return autowireConstructor(beanName, mbd, ctors, null);
        }

        // No special handling: simply use no-arg constructor.
        return instantiateBean(beanName, mbd);//上面都不满足，那么只能调用无参构造器了
    }

小结： 该方法的作用是通过工厂方法或者@bean注解标注的方法或者构造器来进行对象的实例化

2. populateBean(beanName, mbd, instanceWrapper); bean的属性赋值

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            if (mbd.hasPropertyValues()) {//如果bean实例为空，但mbd有属性
                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, //实例化之后，属性赋值之前执行InstantiationAwareBeanPostProcessor
        // to support styles of field injection.
        boolean continueWithPropertyPopulation = true;

        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) { //如果后置处理器返回为false后就不能走下去了
            return;
        }
　　　　　　
        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
  　　　　
        if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) { //这里不看，这里是旧逻辑了，xml时代的
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            // Add property values based on autowire by name if applicable.
            if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }
            // Add property values based on autowire by type if applicable.
            if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }

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

        PropertyDescriptor[] filteredPds = null;
        if (hasInstAwareBpps) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
            //这里才是核心，我们的@Autowired 和 @Value注解注入的属性就是在这里实现的，后置处理器是：AutowiredAnnotationBeanPostProcessor
            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) { //这里不看，这里是旧逻辑了，xml时代的 复杂
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }

小结：上面方法主要的核心是：1.在bean的实例化之后，属性赋值之前执行了InstantiationAwareBeanPostProcessor后置处理器的postProcessAfterInstantiation(bw.getWrappedInstance(), beanName) 2.@autowried和@value的属性赋值实现逻辑是通过InstantiationAwareBeanPostProcessor的.postProcessProperties(pvs, bw.getWrappedInstance(), beanName)方法实现

3.exposedObject = initializeBean(beanName, exposedObject, mbd);

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        }
        else {
            invokeAwareMethods(beanName, bean); //调用aware接口的实现方法，例如ApplicationContextAware的setApplicationContext（）方法
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {//Synthetic 这个的意思是，类或者方法不是由开发人员自己定义的，而是jvm帮忙创建的
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); //执行BeanPostProcessor的applyBeanPostProcessorsBeforeInitialization方法
        }

        try {
            invokeInitMethods(beanName, wrappedBean, mbd);//执行init方法
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);//执行BeanPostProcessor的
        }

        return wrappedBean;
    }

    private void invokeAwareMethods(final String beanName, final Object bean) { //aware方法的逻辑
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }
            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
                }
            }
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }

init方法的执行：

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
            throws Throwable {

        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isTraceEnabled()) {
                logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                ((InitializingBean) bean).afterPropertiesSet(); //如果实现了InitializingBean 就调用该方法
            }
        }

        if (mbd != null && bean.getClass() != NullBean.class) {
            String initMethodName = mbd.getInitMethodName();
            if (StringUtils.hasLength(initMethodName) &&
                    !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                invokeCustomInitMethod(beanName, bean, mbd);//如果有自定义的init方法，例如@Bean(initMethod ="hello" )
            }
        }
    }

至此，一个bean的创建过程分析完毕

最后一张图总结bean创建的过程：