Bean的加载过程

Spring启动时最终会调用ApplicationContext的无参构造函数，该函数中会实例化用于读取资源的BeanDefinitionReader和用于扫描资源的BeanDefinitionScanner（仅用于当前ApplicationContext类中的扫描方法使用），BeanDefinitionReader实例化时会注册ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、EventListenerMethodProcessor等BeanDefinition，然后通过调用ApplicationContext的register方法将传入的配置类给也注册到BeanDefinitionMap中；

容器启动去实例化剩余未被加载的非懒加载的单例Bean。在invokeBeanFactoryPostProcessors方法中根据各种注解解析出来的类，在这都会被初始化，实例化的过程各种BeanPostProcessor开始起作用。

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
       // 为我们的bean工厂创建类型转化器Convert
       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));
       }
       // 处理关于aspectj
       String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
       for (String weaverAwareName : weaverAwareNames) {
          getBean(weaverAwareName);
       }
       beanFactory.setTempClassLoader(null);
       beanFactory.freezeConfiguration(); // 冻结所有bean定义，说明注册的bean定义将不被修改或任何进一步的处理
       beanFactory.preInstantiateSingletons(); // 实例化剩余的单实例bean
    }
}

对于FactoryBean可以通过&beanName获取到原始的FactoryBean，若不加&符号是获取的FactoryBean中getObject方法返回的对象作为Bean。不论是普通Bean还是FactoryBean最终都是通过getBean方法加载的。

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    public void preInstantiateSingletons() throws BeansException {
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // 获取容器中所有bean定义的名称
        for (String beanName : beanNames) { // 循环所有的bean定义名称
            // 合并的bean定义，转换为统一的RootBeanDefinition类型， 方便后续处理
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            // 根据bean定义判断，不是抽象的&&是单例的&&不是懒加载的，才会去生成
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) { // 是不是工厂bean
                    // 是factoryBean会先生成实际的bean &beanName是用来获取实际bean的
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    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) { // 调用真正的getBean的流程
                            getBean(beanName);
                        }
                    }
                } else { // 非工厂Bean，就是普通的bean
                    getBean(beanName);
                }
            }
        }
        //或有的bean的名称，到这里所有的单实例的bean已经记载到单实例bean到缓存中
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName); // 从单例缓存池中获取所有的对象
            // 判断当前的bean是否实现了SmartInitializingSingleton接口
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }, getAccessControlContext());
                } else {
                    // 触发实例化之后的方法afterSingletonsInstantiated
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
    }
}

首先尝试去缓存中获取对象，若获取的是普通单例Bean对象，则getObjectForBeanInstance会直接返回。但若sharedInstance是FactoryBean类型，则需调用getObject工厂方法获取真正的bean实例。若用户想获取FactoryBean本身，这里也不会做特别的处理，直接返回即可。毕竟FactoryBean的实现类本身也是一种Bean，只不过具有一点特殊的功能而已。

Spring不能解决单例对象构造器注入和原型模式创建Bean产生的循环依赖问题，isPrototypeCurrentlyInCreation(beanName)判断会直接抛出异常。

判断AbstractBeanFacotry工厂是否有父工厂，一般情况下是没有父工厂因为abstractBeanFactory直接是抽象类，不存在父工厂，一般情况下，只有Spring和Spring MVC整合时才会有父子容器的概念，如Controller中注入Service时，发现依赖的是一个引用对象，则会调用getBean去把service找出来，但当前所在的容器是web子容器，则会在这里的先去父容器找。

若想类A在类B前被加载可以在类B上使用@DependsOn(value = {"dependsA"})注解处理dependsOn的依赖，这不是所谓的循环依赖，而是bean创建前后的依赖。

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false); // 真正的获取bean的逻辑
    }
    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        // 这里传入进来的name可能是别名, 也有可能是工厂bean的name，所以在这里需要转换
        final String beanName = transformedBeanName(name);
        Object bean;
        Object sharedInstance = getSingleton(beanName); // 尝试去缓存中获取对象
        if (sharedInstance != null && args == null) {
            // 若sharedInstance是普通的单例bean，下面的方法会直接返回。但若sharedInstance是FactoryBean类型，则需调用getObject工厂方法获取真正的bean实例。
            // 若用户想获取FactoryBean本身，这里也不会做特别的处理，直接返回即可。毕竟FactoryBean的实现类本身也是一种bean，只不过具有一点特殊的功能而已。
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        } else {
            // spring只能解决单例对象的setter注入的循环依赖，不能解决构造器注入和原型模式创建Bean产生的循环依赖问题
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            // 判断AbstractBeanFacotry工厂是否有父工厂(一般情况下是没有父工厂因为abstractBeanFactory直接是抽象类,不存在父工厂),一般情况下,只有Spring和SpringMvc整合时才会有父子容器的概念
            // 如Controller中注入Service时，发现依赖的是一个引用对象，则会调用getBean去把service找出来，但当前所在的容器是web子容器，则会在这里的先去父容器找
            BeanFactory parentBeanFactory = getParentBeanFactory();
            // 若存在父工厂，且当前bean工厂不存在当前的bean定义，则bean定义是存在于父beanFacotry中
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                String nameToLookup = originalBeanName(name); // 获取bean的原始名称
                // 若为AbstractBeanFactory类型，委托父类处理
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                } else if (args != null) { // 委托给构造函数getBean()处理
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                } else { // 没有args，委托给标准的getBean()处理
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            }
            // 方法参数typeCheckOnly，用来判断调用#getBean(...)方法时，表示是否仅仅进行类型检查获取Bean对象
            if (!typeCheckOnly) { // 若不是仅仅做类型检查，而是创建Bean对象，则需要调用#markBeanAsCreated(String beanName)方法，进行记录
                markBeanAsCreated(beanName);
            }
            try {
                // 从容器中获取beanName相应的GenericBeanDefinition对象，并将其转换为RootBeanDefinition对象
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args); // 检查当前创建的bean定义是不是抽象的bean定义
                // 处理dependsOn的依赖，这个不是所谓的循环依赖，而是bean创建前后的依赖，依赖bean的名称
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    // 若给定的依赖bean已经注册为依赖给定的bean，即循环依赖的情况，抛出BeanCreationException异常
                    for (String dep : dependsOn) {
                        // beanName是当前正在创建的bean,dep是正在创建的bean的依赖的bean的名称
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        registerDependentBean(dep, beanName); // 保存的是依赖beanName之间的映射关系：依赖beanName -> beanName的集合
                        try {
                            getBean(dep); // 获取depentceOn的bean
                        } catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }
                if (mbd.isSingleton()) { // 创建单例bean，把beanName和singletonFactory传入一个回调对象用于回调
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args); // 进入创建bean的逻辑
                        } catch (BeansException ex) { // 创建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 {
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
                    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;
            }
        }
        // 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) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        }
        return (T) bean;
    }
}

注意上面两次调用的getSingleton方法不是同一个方法，上面第一次调用的getSingleton方法：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    public Object getSingleton(String beanName) {
        // 系统一般是允许早期对象引用的allowEarlyReference通过这个参数可以控制解决循环依赖
        return getSingleton(beanName, true);
    }
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 先尝试去一级缓存单例缓存池中去获取对象，一般情况从该map中获取的对象是直接可使用的，IOC容器初始化加载单实例bean时第一次进来时该map中一般返回空
        Object singletonObject = this.singletonObjects.get(beanName);
        // 若一级缓存中没有获取到对象,且singletonsCurrentlyInCreation这个list包含该beanName，IOC容器初始化加载单实例bean时第一次进来时，该list中一般返回空，但循环依赖时可以满足该条件
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                // 尝试去二级缓存中获取对象，二级缓存中的对象是一个早期对象，就是bean刚刚调用了构造方法，还来不及给bean的属性进行赋值的对象，即纯净态就是早期对象
                singletonObject = this.earlySingletonObjects.get(beanName);
                // 二级缓存中也没有获取到对象,allowEarlyReference为true(参数是有上一个方法传递进来的true)
                if (singletonObject == null && allowEarlyReference) {
                    // 直接从三级缓存中获取ObjectFactory对象 这个对接就是用来解决循环依赖的关键所在，在ioc后期过程中,当bean调用了构造方法时,把早期对象包裹成一个ObjectFactory暴露到三级缓存中
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {// 从三级缓存中获取到对象不为空 
                        // 在这里通过暴露的ObjectFactory包装对象中,通过调用他的getObject()来获取早期对象在这个环节中会调用到getEarlyBeanReference()来进行后置处理
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject); //把早期对象放置在二级缓存
                        this.singletonFactories.remove(beanName); // ObjectFactory包装对象从三级缓存中删除掉
                    }
                }
            }
        }
        return singletonObject;
    }
}

上面第二次调用的getSingleton方法，该放法的第二个参数传入的是一个函数式接口，不会立刻执行，而是在下面调用ObjectFactory的getObject才会执行createBean。beforeSingletonCreation方法会将beanName加入到singletonsCurrentlyInCreation集合，即标记当前bean马上就要被创建了，当Bean创建完成会在afterSingletonCreation方法中将beanName从singletonsCurrentlyInCreation集合中移除。

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    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) {
                    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!)");
                }
                // 标记当前bean马上就要被创建了，singletonsCurrentlyInCreation在这里会把beanName加入进来，若第二次循环依赖，构造器注入会抛出异常
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<>();
                }
                try {
                    // 初始化bean，这个过程其实是调用上面写的createBean()方法
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                } catch (IllegalStateException ex) {
                    //回调我们singletonObjects的get方法,进行正在的创建bean的逻辑
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        throw ex;
                    }
                } catch (BeanCreationException ex) {
                    throw ex;
                } finally {
                    // 后置处理，主要做是把singletonsCurrentlyInCreation标记正在创建的bean从集合中移除
                    afterSingletonCreation(beanName);
                }
                if (newSingleton) {
                    addSingleton(beanName, singletonObject); // 加入缓存中
                }
            }
            return singletonObject;
        }
    }
}

resolveBeforeInstantiation(beanName, mbdToUse)是第一次调用bean后置处理器的地方，主要通过调用AbstractAutoProxyCreator后置处理器来进行后置处理生成代理对象，一般在此处不会生成代理对象，因为真实的对象没有生成，故在这里不会生成代理对象，这一步是AOP和事务的关键，在这里解析AOP切面信息进行缓存。doCreateBean才是真正创建bean实例对象。

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
   protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
       RootBeanDefinition mbdToUse = mbd;
       Class<?> resolvedClass = resolveBeanClass(mbd, beanName); // 确保此时的bean已经被解析了
       if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
           mbdToUse = new RootBeanDefinition(mbd);
           mbdToUse.setBeanClass(resolvedClass);
       }
       try {
           // 验证和准备覆盖方法，仅在XML方式中，lookup-method和replace-method，这两个配置存放在BeanDefinition中的 methodOverrides(仅在XML方式中）
           // 在XML方式中bean实例化的过程中如果检测到存在methodOverrides，则会动态地为当前bean生成代理并使用对应的拦截器为bean做增强处理。
           mbdToUse.prepareMethodOverrides();
       } catch (BeanDefinitionValidationException ex) {
           throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex);
       }
       try {
           // 第1个bean后置处理器，通过bean的后置处理器来进行后置处理生成代理对象，一般在此处不会生成代理对象，因为真实的对象没有生成，故在这里不会生成代理对象，这一步是我们aop和事务的关键，因为在这里解析aop切面信息进行缓存
           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);
           return beanInstance;
       } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
           throw ex;
       } catch (Throwable ex) {
           throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
       }
   }
}

上面的resolveBeforeInstantiation中调用的是applyBeanPostProcessorsBeforeInstantiation方法，而该方法中是第一次调用Bean的后置处理器的地方，该方法会执行所有实现了InstantiationAwareBeanPostProcessor接口的后置处理器，对于Spring内部有好几个实现了该接口的后置处理器，但只有AbstractAutoProxyCreator复写了这里调用的postProcessBeforeInstantiation方法。在这里通过该Bean后置处理器主要做的是解析AOP切面信息进行缓存，从上面和下面的代码结合来看若自定义一个Bean后置处理器且实现InstantiationAwareBeanPostProcessor接口复写postProcessBeforeInstantiation方法返回一个对象，可直接停止Bean的后续创建直接返回当前自定义后置处理器中返回的对象。

若返回Bean不为空，则调用所有实现InstantiationAwareBeanPostProcessor接口的后置处理器的postProcessAfterInitialization方法，这里主要是对初始化完成后的Bean进行AOP代理的创建，这也是Bean创建过程第八次调用Bean后置处理器的地方。正常情况上面的resolveBeforeInstantiation方法是不会调用applyBeanPostProcessorsAfterInitialization的。

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            // 判断容器中是否有InstantiationAwareBeanPostProcessors
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = determineTargetType(beanName, mbd); // 获取当前bean的class对象
                if (targetType != null) {
                    // 后置处理器的第一次调用，共有九处调用，事务在这里不会被调用，aop的才会被调用，因为在此处需要解析出对应的切面报错到缓存中
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    // 若InstantiationAwareBeanPostProcessors后置处理器的postProcessBeforeInstantiation返回不为null，说明生成了代理对象
                    if (bean != null) {
                        // 后置处理器的第二处调用，该后置处理器若被调用的话，则第一处的处理器肯定返回的不是null，InstantiationAwareBeanPostProcessors后置处理器postProcessAfterInitialization
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) { // 获取容器中的所有后置处理器
            if (bp instanceof InstantiationAwareBeanPostProcessor) { // 判断后置处理器是不是InstantiationAwareBeanPostProcessor
                // 把BeanPostProcessor强制转为InstantiationAwareBeanPostProcessor
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // AOP的@EnableAspectJAutoProxy为容器中导入了AnnotationAwareAspectJAutoProxyCreator，事务注解@EnableTransactionManagement为容器导入了InfrastructureAdvisorAutoProxyCreator
                // 都是实现了BeanPostProcessor接口，InstantiationAwareBeanPostProcessor进行后置处理解析切面
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) { // 获取容器中的所有的bean的后置处理器
            // 在这里是后置处理器的第九次调用，aop和事务都会在这里生存代理对象
            // AOP的@EnableAspectJAutoProxy为容器中导入了AnnotationAwareAspectJAutoProxyCreator，事务注解@EnableTransactionManagement为容器导入了InfrastructureAdvisorAutoProxyCreator
            // 都是实现了我们的BeanPostProcessor接口，InstantiationAwareBeanPostProcessor，在这里实现的是BeanPostProcessor接口的postProcessAfterInitialization来生成我们的代理对象
            Object current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) { // 若只要有一个返回null，则直接返回原始的
                return result;
            }
            result = current;
        }
        return result;
    }
}

doCreateBean主要完成的内容是，通过createBeanInstance对Bean进行实例化，通过populateBean对属性进行赋值，通过initializeBean对Bean进行初始化操作。且这三大步中又调用了很多次的Bean的后置处理器，以及一些Aware接口的调用等。

实例化完成后，判断当前Bean是否单例、是否允许循环依赖、是否正在创建，若满足条件则缓存单例到第三级缓存singletonFactories中，以防循环依赖。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
   // BeanWrapper是对Bean的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装bean的属性描述器
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) { // 从没有完成的FactoryBean中移除
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   if (instanceWrapper == null) {
      // 创建bean实例化，使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化，该方法很复杂也很重要
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   // 从beanWrapper中获取早期对象
   final Object bean = instanceWrapper.getWrappedInstance();
   Class<?> beanType = instanceWrapper.getWrappedClass();
   if (beanType != NullBean.class) {
      mbd.resolvedTargetType = beanType;
   }
   // Allow post-processors to modify the merged bean definition.
   synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
         try { //进行后置处理@AutoWired、@Value的注解的预解析
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
         } catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex);
         }
         mbd.postProcessed = true;
      }
   }
   // 缓存单例到三级缓存中，以防循环依赖，判断是否为早期引用的Bean，若是则允许提前暴露引用
   // 判断是否能够暴露早期对象的条件：是否单例、是否允许循环依赖、是否正在创建的Bean
   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
   if (earlySingletonExposure) { // 上述条件满足，允许中期暴露对象
      // 把早期对象包装成一个singletonFactory对象，该对象提供了一个getObject方法，该方法内部调用getEarlyBeanReference方法
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
   }
   // Initialize the bean instance.
   Object exposedObject = bean;
   try {
      populateBean(beanName, mbd, instanceWrapper); // 属性赋值，给属性进行赋值，调用set方法进行赋值
      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);
      }
   }
   if (earlySingletonExposure) { // 是早期对象暴露
      // 去缓存中获取对象，由于传递的allowEarlyReference是false，要求只能在一级二级缓存中去获取，不存在循环依赖的bean创建过程中，压根不会把三级缓存提升到二级缓存中
      Object earlySingletonReference = getSingleton(beanName, false);
      if (earlySingletonReference != null) { // 能够获取到
         if (exposedObject == bean) { // 经过后置处理的bean和早期的bean引用还相等的话，表示当前的bean没有被代理过
            exposedObject = earlySingletonReference;
         } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { // 处理依赖的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.");
            }
         }
      }
   }
   try { //注册销毁的bean的销毁接口
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
   } catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
   }
   return exposedObject;
}

若使用@Bean方式配置的Bean实例化时直接通过instantiateUsingFactoryMethod工程方法进行实例化，方法名称就是就是工厂方法的名称。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   Class<?> beanClass = resolveBeanClass(mbd, beanName); // 从bean定义中解析出当前bean的class对象
   // 检测类的访问权限。默认情况下非public的类是允许访问的。Bean定义默认情况nonPublicAccessAllowed为true，即使不是public的也ok
   // beanClass不为null且访问修饰符如果不是public且Bean定义的nonPublicAccessAllowed为false，若满足则抛出异常
   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());
   }
   // 该方法是spring5.0 新增加的  如果存在 Supplier 回调，则使用给定的回调方法初始化策略
   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }
   // @Bean会在这创建实例，工厂方法，通过配置类来进行配置的话，采用的就是工厂方法，方法名称就是就是工厂方法的名称
   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }
   // 当多次构建同一个bean时，可使用此处的快捷路径，即无需再次推断应该使用哪种方式构造实例，以提高效率。
   // 在多次构建同一个prototype类型的bean时，就可以走此处的捷径，这里的resolved和mbd.constructorArgumentsResolved将会在bean第一次实例化的过程中被设置。
   //判断当前构造函数是否被解析过
   boolean resolved = false;
   //有没有必须进行依赖注入
   boolean autowireNecessary = false;
   // 通过getBean传入进来的构造函数是否来指定需要推断构造函数，若传递进来的args不为空，则可直接选出对应的构造函数
   if (args == null) {
      synchronized (mbd.constructorArgumentLock) { // 判断bean定义信息中的resolvedConstructorOrFactoryMethod用来缓存已解析的构造函数或者工厂方法
         if (mbd.resolvedConstructorOrFactoryMethod != null) {
            resolved = true; // 修改已经解析过的构造函数的标志
            autowireNecessary = mbd.constructorArgumentsResolved; // 修改标记为true标识构造函数或者工厂方法已解析过
         }
      }
   }
   if (resolved) { // 若被解析过
      if (autowireNecessary) { // 通过有参的构造函数进行反射调用
         return autowireConstructor(beanName, mbd, null, null);
      } else { //调用无参数的构造函数进行创建对象
         return instantiateBean(beanName, mbd);
      }
   }
   // 通过bean的后置处理器进行选举出合适的构造函数对象
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   // 自定义了BeanPostProcessor返回了构造器或使用构造器自动装配模式或设置了BeanDefinition构造器参数或有参数:即getBean(String name,Object... args)
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      return autowireConstructor(beanName, mbd, ctors, args); // 使用自定义的构造器初始化
   }
   return instantiateBean(beanName, mbd); // 使用无参数的构造函数调用创建对象
}

第二次Bean后置处理器的调用，主要调用的是AutowiredAnnotationBeanPostProcessor后置处理器determineCandidateConstructors方法其作用就是推断出实例化的构造函数。推断逻辑如下，且Spring会根据入参的类型和入参的名字去Spring中找Bean对象并给构造函数入参赋值：

• 若一个类只有一个构造方法，不管该构造方法是无参构造方法还是有参构造方法，Spring都会用该构造方法来完成类的实例化
• 若一个类存在多个构造方法：
  • 构造方法中存在一个无参构造方法，则使用无参构造方法
  • 不存在无参构造方法则Spring报错
  • 若其中一个构造方法加了@Autowired注解，则使用加了@Autowired注解的构造方法
  • 若多个构造方法都加了@Autowired注解，则报错

在推断构造方法逻辑中还会还判断是否在对应的类中是否存在被@Lookup注解的方法，若存在则把该方法封装为LookupOverride对象并添加到BeanDefinition中。在实例化时，若判断出来当前BeanDefinition中没有LookupOverride，则直接用构造方法反射得到一个实例对象，若存在LookupOverride对象，也就是类中存在@Lookup注解了的方法，则会生成一个代理对象。@Lookup注解的作用是为单实例Bean中引用的原型Bean每次Get的时候获取一个新的Bean实例；

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
    protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName) throws BeansException {
        if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) { // 获取到容器中所有的后置处理器BeanPostProcessors
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) { // 判断后置处理器是否为SmartInstantiationAwareBeanPostProcessor
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    // 调用后置处理器的determineCandidateConstructors来决定构造方法
                    Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
                    if (ctors != null) {
                        return ctors;
                    }
                }
            }
        }
        return null;
    }
}

Bean实例化完成后，调用applyMergedBeanDefinitionPostProcessors从而第三次调用Bean的后置处理器，完成@Autowired、@Value、@Inject、@PostConstruct、@Resource等注解以及自定义的初始化方法等预解析。调用AutowiredAnnotationBeanPostProcessor将@Autowired、@Value、@Inject注入信息预解析存入externallyManagedConfigMembers中，调用CommonAnnotationBeanPostProcessor解析@Resource注解，且会调用父类InitDestroyAnnotationBeanPostProcessor，解析@PostConstruct和@PreDestroy；@Bean(initMethod = "initMethod")是在扫描BeanDefinition时解析时就已完成且在invokeInitMethods方法最后的invokeCustomInitMethod方法中被调用，且执行的先后顺序为@PostConstruct、InitializingBean的afterPropertiesSet、@Bean(initMethod = "initMethod")。

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
    protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof MergedBeanDefinitionPostProcessor) {
                MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
                bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
            }
        }
    }
}

getEarlyBeanReference中是第四次调用Bean的后置处理器，调用实现了SmartInstantiationAwareBeanPostProcessor接口的getEarlyBeanReference方法的后置处理器，这里是调用AbstractAutoProxyCreator后置处理器，主要作用是给有AOP代理的且产生循环依赖的对象创建AOP代理，若该Bean有AOP代理，但不存在循环依赖，则AOP代理是在第八次调用后置处理器时，给该Bean创建动态代理的。若已经设置了动态代理会将beanName加入到earlyProxyReferences集合中，防止重复添加动态代理。

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
    protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
       Object exposedObject = bean;
       // 判读容器中是否有InstantiationAwareBeanPostProcessors类型的后置处理器
       if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
          for (BeanPostProcessor bp : getBeanPostProcessors()) { // 获取所有的后置处理器
             if (bp instanceof SmartInstantiationAwareBeanPostProcessor) { // 判断后置处理器是否实现了SmartInstantiationAwareBeanPostProcessor接口
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp; // 进行强制转换
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName); // 挨个调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference
             }
          }
       }
       return exposedObject;
    }
}

属性进行赋值前第五次调用后置处理器，Spring自身没有做相应的事情，调用实现了InstantiationAwareBeanPostProcessor接口postProcessAfterInstantiation的后置处理器，其作用是让用户可以自定义属性，其还可以设置跳过后续的赋值操作。

紧接着调用第六次后置处理器，调用实现了InstantiationAwareBeanPostProcessor接口postProcessProperties的后置处理器，主要是注入PropertyValues对属性进行赋值操作，@Autowired、@Value注解是通过AutowiredAnnotationBeanPostProcessor中postProcessProperties方法调用InjectionMetadata.inject方法，若发现@Autowired注入的Bean未被创建，最终会调用DependencyDescriptor的resolveCandidate方法，通过getBean去创建该Bean。若存在循环依赖，给依赖的Bean进行属性赋值时会再次通过getBean调用当前Bean，从而通过getSingleton方法中对三级缓存中函数式接口的调用，即调用getEarlyBeanReference方法将三级缓存转换为二级缓存，返回给依赖的Bean进行赋值操作。

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
   if (bw == null) { // 若bw为null的话，说明对象没有实例化
      if (mbd.hasPropertyValues()) { // 进入if说明对象有属性，bw为空，不能为他设置属性，那就在下面就执行抛出异常
         throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
      } else {
         return; // Skip property population phase for null instance.
      }
   }
   /**
    * 在属性被填充前，给InstantiationAwareBeanPostProcessor类型的后置处理器一个修改bean状态的机会。官方的解释是：让用户可以自定义属性注入。
    * 若用户实现一个InstantiationAwareBeanPostProcessor类型的后置处理器，并通过postProcessAfterInstantiation方法向bean的成员变量注入自定义的信息。
    * 当时发现系统中的InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation没有进行任何处理，若自己实现了该接口，可以自定义处理，直接使用配置中的信息注入即可。
    */
   boolean continueWithPropertyPopulation = true;
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { // 是否持有InstantiationAwareBeanPostProcessor
      for (BeanPostProcessor bp : getBeanPostProcessors()) { // 获取容器中的所有的BeanPostProcessor
         if (bp instanceof InstantiationAwareBeanPostProcessor) { // 判断后置处理器是不是InstantiationAwareBeanPostProcessor
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; // 进行强制转化
            // 若存在后置处理器给属性赋值了，则返回false可来修改开关变量，就不会走下面的逻辑了
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { // 返回值为是否继续填充bean
               // postProcessAfterInstantiation：若应该在bean上面设置属性则返回true，否则返回false，一般情况下返回true
               // 返回false，将会阻止在此Bean实例上调用任何后续的InstantiationAwareBeanPostProcessor
               continueWithPropertyPopulation = false;
               break;
            }
         }
      }
   }
   if (!continueWithPropertyPopulation) { // 若后续处理器发出停止填充命令，则终止后续操作
      return;
   }
   PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); // 获取bean定义的属性
   // 判断的bean的属性注入模型AUTOWIRE_BY_NAME根据名称注入，AUTOWIRE_BY_TYPE 根据类型注入
   if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
      MutablePropertyValues newPvs = new MutablePropertyValues(pvs); // 把PropertyValues封装成为MutablePropertyValues
      if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) { // 根据bean的属性名称注入
         autowireByName(beanName, mbd, bw, newPvs);
      }
      if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) { // 根据bean的类型进行注入
         autowireByType(beanName, mbd, bw, newPvs);
      }
      pvs = newPvs; // 把处理过的属性覆盖原来的
   }
   // 用于在Spring填充属性到bean对象前，对属性的值进行相应的处理，可修改某些属性的值。这时注入到bean中的值就不是配置文件中的内容了，而是经过后置处理器修改后的内容
   boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
   // 判断是否需要检查依赖
   boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
   if (hasInstAwareBpps || needsDepCheck) {
      if (pvs == null) {
         pvs = mbd.getPropertyValues();
      }
      // 提出当前正在创建的beanWrapper依赖的对象
      PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
      if (hasInstAwareBpps) {
         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) { // 判断是否检查依赖
         checkDependencies(beanName, mbd, filteredPds, pvs);
      }
   }
   // 上面只是完成了所有注入属性的获取，将获取的属性封装在PropertyValues的实例对象pvs中，并没有应用到已经实例化的bean中，applyPropertyValues则是完成这一步骤的
   if (pvs != null) {
      applyPropertyValues(beanName, mbd, bw, pvs);
   }
}

这里对Bean进行初始化，首先会调用invokeAwareMethods方法从而调用Bean的BeanNameAware、BeanClassLoaderAware、BeanFactoryAware三个Aware接口。

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); // 若bean实现了XXXAware接口进行方法的回调
   }
   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) { // 调用bean的后置处理器的postProcessorsBeforeInitialization方法，@PostCust注解的方法
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }
   try {
      invokeInitMethods(beanName, wrappedBean, mbd); // 调用初始化方法
   } catch (Throwable ex) {
      throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex);
   }
   if (mbd == null || !mbd.isSynthetic()) { // 调用bean的后置处理器的PostProcessorsAfterInitialization方法
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }
   return wrappedBean;
}

第七次Bean的后置处理器调用，通过InitDestroyAnnotationBeanPostProcessor接口中调用LifecycleMetadata.invokeInitMethods方法来实现初始化前@PostConstruct注解的方法的调用，以及调用ApplicationContextAwareProcessor后置处理器的postProcessBeforeInitialization方法，完成EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware、ImportAware等Aware接口的调用。

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
   Object result = existingBean;
   for (BeanPostProcessor processor : getBeanPostProcessors()) { // 获取容器中的所有的bean的后置处理器
      Object current = processor.postProcessBeforeInitialization(result, beanName); // 挨个调用bean的后置处理器的postProcessBeforeInitialization
      if (current == null) { // 若只有有一个返回null 那么直接返回原始的
         return result;
      }
      result = current;
   }
   return result;
}

invokeInitMethods方法中若实现了InitializingBean接口，则调用InitializingBean接口的afterPropertiesSet方法，以及自定义的初始化方法的调用即@Bean(initMethod = "initMethod")中指定的初始化方法。

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
   boolean isInitializingBean = (bean instanceof InitializingBean); // 判断容器中是否实现了InitializingBean接口
   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
      if (logger.isDebugEnabled()) {
         logger.debug("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的afterPropertiesSet()方法
         ((InitializingBean) bean).afterPropertiesSet();
      }
   }
   if (mbd != null && bean.getClass() != NullBean.class) { // 调用initMethod
      String initMethodName = mbd.getInitMethodName(); // beanclass中是否有自定义的init方法
      // 判断自定义的init方法名称不叫afterPropertiesSet
      if (StringUtils.hasLength(initMethodName) && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) {
         invokeCustomInitMethod(beanName, bean, mbd); // 调用自定义的初始化方法
      }
   }
}

在applyBeanPostProcessorsAfterInitialization方法中完成了第八次后置处理器的调用，主要是对初始化完成后的Bean进行AOP代理的创建以及ApplicationListener的添加。最终Bean销毁的时候会调用第九次Bean的后置处理器，即调用InitDestroyAnnotationBeanPostProcessor后置处理器的postProcessBeforeDestruction方法。