Spring-通过源码看Bean的创建过程

妖狐艹你老母 2021-06-10 20:38 381阅读 0赞

1. finishBeanFactoryInitialization()1.1 preInstantiateSingletons()方法1.2 getBean()1.3 doGetBean()1.4 createBean()1.5 doCreateBean()2. Bean生命周期

> `Spring`的核心模块是`IOC`和`AOP`，而`IOC`中创建`Bean`又是十分重要的一环。在`Spring`的启动过程中，会在`refresh()`方法中调用`finishBeanFactoryInitialization()`。在`finishBeanFactoryInitialization`中完成了非懒加载的单例`bean`的创建。所以要搞清楚`bean`的创建过程，就要从`finishBeanFactoryInitialization()`方法的源码入手。

### 1. finishBeanFactoryInitialization() ###

> 该方法十分重要，它完成了所有非懒加载的单例`Bean`的实例化和初始化，属性的填充以及解决了循环依赖等问题。

*  (注意这里特意将对象的实例化和初始化过程分开了，因为在`Spring`创建`Bean`的过程中，是先将`Bean`通过反射创建对象，然后通过后置处理器(`BeanPostProcessor`)来为对象的属性赋值。所以这里的实例化时指将`Bean`创建出来，初始化是指为`bean`的属性赋值)。
 *  `finishBeanFactoryInitialization()`方法的代码如下，`bean`的创建和初始化均在`beanFactory.preInstantiateSingletons()`中实现。

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));
        }
        // 如果前面没有注册一个类似于PropertyPlaceholderConfigurer后置处理器的bean，那么在这儿会注册一个内置的属性后置处理器
        // 这儿主要是处理被加了注解的属性
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }
        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }
        beanFactory.setTempClassLoader(null);
        // 将BeanFactory的configurationFrozen属性设置为true,给frozenBeanDefinitionNames属性赋值
        // 目的是为了不让在其他的地方在修改bean的BeanDefinition
        beanFactory.freezeConfiguration();
    
        // Instantiate all remaining (non-lazy-init) singletons.
        // 实例化剩下所有的非懒加载的单例
        beanFactory.preInstantiateSingletons();
    }

1.1 preInstantiateSingletons()方法

*  该方法会先判断`bean`是否是一个`FactoryBean`，以及是否立即实例化`FactoryBean`的`getObject()`返回的对象，但最终均是调用`getBean()`方法去实例化对象。在`Bean`实例化、初始化完成后，会判断`Bean`是否实现了`SmartSingletonInitializing`接口，如果实现了，则会调用该接口的`afterSingletonInstantiated()`方法。
 *  `Tips`：这里提到了`FactoryBean`,不是`BeanFactory`。这两者名字很像，但作用却是天差地别，有兴趣的朋友可以先自己`Google`查下相关知识。这里先简单介绍一下，后续会单独写一篇文章介绍`FactoryBean`，并通过`FactoryBean`去解析`Spring`与`MyBatis`整合的原理。
 *  `FactoryBean`是一个接口，该接口的实现类会向容器中注册两个`bean`，一个是实现类本身所代表类型的对象，一个是通过重写`FactoryBean`接口中`getObject()`方法所返回的`bean`。如下例子中：会向容器中注册两个`bean`，一个是`MapperFactoryBean`本身，一个是`UserMapper`。

@Component
    public class MapperFactoryBean implements FactoryBean {
        @Override
        public Object getObject() throws Exception {
            return new UserMapper();
        }
    
        @Override
        public Class<?> getObjectType() {
            return UserMapper.class;
        }
    }

*  由于`bean`的实例化过程太过复杂，后面会结合流程图去分析源码。`preInstantiatedSingletons()`方法的执行流程图如下

![format_png][]

*  `preInstantiatedSingletons()`代码如下

public void preInstantiateSingletons() throws BeansException {
        if (logger.isDebugEnabled()) {
            logger.debug("Pre-instantiating singletons in " + this);
        }
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                // 判断是否是factoryBean,如果是FactoryBean，则进行FactoryBean原生的实例化(非getObject()方法对应的对象)。
                // 还需要判断它是否立即实例化getObject()返回的对象，根据SmartFactoryBean的isEagerInit()的返回值判断是否需要立即实例化
                if (isFactoryBean(beanName)) {
                    // 首先实例化BeanFactory的原生对象，然后再根据isEagerInit()判断是否实例化BeanFactory中getObject()返回的类型的对象
                    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());
                        }
                        // 如果isEagerInit为true,则立即实例化FactoryBean所返回的类型的对象
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }
        // 在bean实例化以及属性赋值完成后，如果bean实现了SmartInitializingSingleton接口，则回调该接口的方法
        for (String beanName : beanNames) {
            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();
                }
            }
        }
    }

*  从上面源码中发现，不论是`FactoryBean`还是普通`Bean`，最终都是调用`getBean()`方法去创建`bean`。

1.2 getBean()

*  `getBean()`方法会调用`doGetBean()`方法。

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

1.3 doGetBean()

*  在`doGetBean()`方法当中，会先从缓存中获取(即从`singletonObjects`这个`map`集合中获取，为什么要先从缓存中获取呢？因为要从`Spring`容器获取对象和创建对象，都是通过`getBean()`方法，对于单例对象而言，对象只会被创建一次，那么先从缓存中获取对象，如果存在，则不用去新创建了，这样就保证了单例对象只被创建一次)。如果缓存中存在，则接着调用`getObjectForBeanInstance()`方法，然后返回`bean`。如果缓存中不存在，则继续往下执行。
 *  然后获取到`Bean`所对应的`BeanDefinition`对象。接着判断`bean`有没有依赖，`String[] dependsOn = mbd.getDependsOn()`，如果有依赖的对象，那么会先去实例化依赖的对象。
 *  依赖的对象创建完成后，会调用`getSingleton(beanName,lambda)`方法，这个方法的第二个参数是一个`lambda`表达式，真正创建`bean`的逻辑是在表达式的方法体中，即`createBean()`方法，`createBean()`方法会创建完成`bean`，然后在`getSingleton(beanName,lambda)`方法中会将创建完成的`bean`存入到`singletonObjects`属性中。`createBean()`后面分析。
 *  在上一步创建完`bean`后，最终仍会调用`getObjectForBeanInstance()`。这个方法的逻辑比较简单，先判断`bean`是否是一个`FactoryBean`，若不是，则直接返回`bean`；若是，则再判断`beanName`是否是以&符号开头，如果是，表示获取的是`FactoryBean`的原生对象，则直接返回`bean`；若不是以&符号开头，则会返回`FactoryBean`的`getObject()`方法的返回值对象。
 *  `doGetBean()`方法代码如下

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);
        Object bean;
        // Eagerly check singleton cache for manually registered singletons.
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        else {
            // Fail if we're already creating this bean instance:
            // 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)) {
                // Not found -> check parent.
                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 {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            }
            if (!typeCheckOnly) {
                // 标记bean为已创建
                // 并清除beanDefinition的缓存(mergedBeanDefinitions)
                markBeanAsCreated(beanName);
            }
            try {
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                // 检查bean是否是抽象类
                checkMergedBeanDefinition(mbd, beanName, args);
                // Guarantee initialization of beans that the current bean depends on.
                // 保证当前bean所依赖的bean初始化
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dep : dependsOn) {
                        // isDependent()方法用来判断dep是否依赖beanName
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        // 保存下依赖关系
                        registerDependentBean(dep, beanName);
                        try {
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }
                // Create bean instance.
                if (mbd.isSingleton()) {
                    // 此时在getSingleton方法中传入了一个lambda表达式，
                    // 此时不会立即执行lambda表达式，而是在调用这个lambda表达式的getObject()方法时才开始执行lambda的方法体
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
    
                else if (mbd.isPrototype()) {
                    // It's a prototype -> create a new instance.
                    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;
            }
        }
        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;
    }

*  `getObjectForBeanInstance()`方法的作用是为了根据`beanName`来判断是返回`FactoryBean`原生对象还是`getObject()`方法所返回的对象.若`beanName`以&符号开头，则表示返回`FactoryBean`原生对象，否则返回`getObject()`方法所返回的对象。

protected Object getObjectForBeanInstance(
            Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
        if (BeanFactoryUtils.isFactoryDereference(name)) {
            if (beanInstance instanceof NullBean) {
                return beanInstance;
            }
            if (!(beanInstance instanceof FactoryBean)) {
                throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
            }
        }
    
        // 如果不是一个FactoryBean对象或者是获取FactoryBean的原生对象(原生对象指的是beanName是以&开头)
        // 此时可以直接返回bean
        if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
            return beanInstance;
        }
    
        // 如果是获取FactoryBean的getObject()方法返回的类型对象，则需要进入到如下逻辑
        // 对于getObject()方法，它返回的对象是在在第一次调用getObject方法时进行实例化的，实例化完成以后，会将结果缓存在factoryBeanObjectCache中
        Object object = null;
        if (mbd == null) {
            object = getCachedObjectForFactoryBean(beanName);
        }
        if (object == null) {
            // Return bean instance from factory.
            FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
            // Caches object obtained from FactoryBean if it is a singleton.
            if (mbd == null && containsBeanDefinition(beanName)) {
                mbd = getMergedLocalBeanDefinition(beanName);
            }
            boolean synthetic = (mbd != null && mbd.isSynthetic());
            // 获取FactoryBean返回的对象
            object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
        return object;
    }

1.4 createBean()

*  `doGetBean()`最终会调用`createBean()`来创建`bean`。
 *  `createBean()`方法的代码中，主要有两行核心代码：

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);

*  `resolveBeforeInstantiation()`方法在`bean`实例化之前调用，在这个方法中执行了后置处理器`InstantiationAwareBeanPostProcessor`的`postProcessBeforeInstantiation()`方法，在`bean`实例化之前对`bean`进行处理。这个扩展点的意义十分重大，`Spring`的`AOP`就是在这儿实现的，感兴趣的朋友可阅读`AnnotationAwareAspectJAutoProxyCreator`这个类的源码，后续会单独写一篇文章进行分析。
 *  如果`resolveBeforeInstantiation()`的返回值不为`null`，则直接将结果返回。如果为`null`，则会继续执行方法`doCreateBean()`。在`doCreateBean()`方法中，进行了`Bean`的实例化、属性赋值、初始化等操作。
 *  `createBean()`方法的流程图
 *  ![format_png 1][]
 *  `createBean()`方法的源代码

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);
            mbdToUse.setBeanClass(resolvedClass);
        }
        // Prepare method overrides.
        try {
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }
        try {
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            // 第一次调用后置处理器(执行所有InstantiationAwareBeanPostProcessor的子类)
            // 如果InstantiationAwareBeanPostProcessor的子类的postProcessBeforeInstantiation()方法返回值不为空，表示bean需要被增强，
            // 此时将不会执行后面的逻辑，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 {
            // 第二次执行后置处理器的入口
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isDebugEnabled()) {
                logger.debug("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
        }
        catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
        }
    }

1.5 doCreateBean()

*  `doCreateBean()`方法会通过反射进行`Bean`的创建，然后对`bean`进行属性填充(在填充属性的同时，解决了循环依赖的问题)，最后会对`Bean`回调初始化相关的方法，例如：`BeanPostProcessor.postProcessBeforeInilization(),InilizaingBean.afterPropertiesSet()`,给`bean`配置的`initMethod()`方法，以及`BeanPostProcessor.postProcessAfterInilization()`。
 *  `doCreateBean()`执行的流程图如下：

![format_png 2][]

*  `doCreateBean()`方法的代码(删减了部分代码)如下:

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) {
            // 实例化bean(第二次执行后置处理器的入口),第二次执行后置处理器，主要是为了推断出实例化Bean所需要的构造器
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }
        // 此时bean对象已经创建成功，但是没有设置属性和经过其他后置处理器处理
        // Allow post-processors to modify the merged bean definition.
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    // 第三次执行后置处理器，缓存bean的注解元数据信息(用于后面在进行属性填充时使用)
                    // 这一步对于CommonAnnotationBeanPostProcessor、AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor这一类处理器
                    // 主要是将bean的注解信息解析出来，然后缓存到后置处理器中的injectionMetadataCache属性中
                    // 而对于ApplicationListenerDetector处理器，而是将bean是否是单例的标识存于singletonNames这个Map类型的属性中
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                mbd.postProcessed = true;
            }
        }
        // 判断一个bean是否放入到singletonFactories中(提前暴露出来，可以解决循环依赖的问题)
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            // 第四次出现后置处理器
            // 获取提前暴露的对象，可以解决循环引用的问题，实际上提前暴露出来的bean是放入到了singletonFactories中，key是beanName,value是一个lambda表达式
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
            // 填充属性，第五次、第六次后置处理器入口
            populateBean(beanName, mbd, instanceWrapper);
            // 第七次、第八次执行后置处理器入口
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
        }
        return exposedObject;
    }

*  `createBeanInstance()`会通过反射创建对象时，会先执行后置处理器，通过调用后置处理器的`deternineCondidateConstructors()`方法来推断出使用哪一个构造器来创建`Bean`，典型的代表类有`AutowiredAnnotationBeanPostProcessor`。
 *  `bean`被通过反射创建完成后，会再次调用后置处理器`MergedBeanDefinitionPostProcessor.postProcessMargedBeanDefinition()`方法，这一步执行后置处理器的目的是为了找出加了`@Autowired`、`@Resource`等注解的属性和方法，然后将这些注解信息缓存到`injectionMetadataCache`属性中，便于后面在`bean`初始化阶段(属性赋值阶段)，根据`@Autowired`等注解实现自动装配。这一步的代表后置处理器有`AutowiredAnnotationBeanPostProcessor`、`CommonAnnotationBeanPostProcessor`

> `AutowiredAnnotationBeanPostProcessor`是用来处理`Spring`提供的注解和`JSR-330`中的部分注解，如：`@Autowired`，`@Value`，`@Inject`。`CommonAnnotationBeanPostProcessor`是用来处理`JSR-250`中的注解，如`@Resource`、`@PostConstruct`、`@PreDestroy`。

*  接下来会将半成品的`bean`(因为此时还未给`bean`的属性赋值，未完成自动装配，因此称之为半成品)放入到`DefaultSingletonBeanRegistry`类的`singletonFactories`的属性中，`singletonFactories`属性是一个`Map`，`key`为`beanName`,值为`ObjectFactory`类型(实际上就是一个`lambda`表达式)，当调用`ObjectFactory`的`getObject()`方法时，会执行`lambda`表达式的方法体，在当前场景下，`lambda`表达式的代码如下，实际上就是执行了一次`Bean`的后置处理器。这一步的目的是为了解决`bean`之间的循环依赖，究竟是如何解决循环依赖的，以后分析。

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    // 调用后置处理的方法获取bean早期暴露出来的bean对象(半成品)
                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                }
            }
        }
        return exposedObject;
    }

*  然后会执行到`populateBean()`方法，在该方法中又会执行两次`Bean`后置处理器，第一次执行后置处理器是为了判断`Bean`是否需要继续填充属性，如果`InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()`方法返回的`false`，则表示不进行属性填充，`bean`就不会进行`@Autowired`等自动装配过程，`populateBean()`方法会直接结束。若返回`true`，则会进行接下来的属性填充，即会执行第二次后置处理器，`InstantiationAwareBeanPostProcessor.postProcessPropertyValue()`方法，这一步的主角就是`AutowiredAnnotationBeanPostProcessor`和`CommonAnnotationBeanPostBeanPostProcessor`了，它们会根据前面缓存在`injectionMetadataCache`中的注解信息来进行自动装配。
 *  在执行完`populateBean()`方法后后，接下来回执行`initializeBean()`方法，即进入初始化阶段。在`initializeBean()`方法中，最先执行`invokeAwareMethods()`方法，即执行`Aware`接口的方法，如：`BeanNameAware`、`BeanClassLoaderAware`、`BeanFactoryAware`。然后再一次执行所有`Bean`后置处理器的`BeanPostProcessor.postProcessBeforeInitialization()`方法。接着执行`invokeInitMethods()`方法，在`invokeInitMethods()`方法中，会执行`InitializingBean`的`afterPropertiesSet()`方法，和定义`bean`时自定义的`initMethod()`方法。最后再一次执行`bean`后置处理器，`BeanPostProcessor.postProcessAfterInitialization()`。
 *  至此`bean`的实例化、初始化过程已经完成，创建好的`bean`会被返回，若是单例`bean`，最后会被存放到`DefaultSingletonBeanRegistry`的`singletonObjects`中。

### 2. Bean生命周期 ###

*  从上面`Spring`的源码分析中，可以看出，启动过程中，`bean`的创建过程比较复杂，在创建过程中，前后一共出现了8次调用`BeanPostPorcessor`(实际上在`bean`的整个生命周期中，一共会出现`9`次调用后置处理器，第九次出现在`bean`的销毁阶段。)
 *  最后，结合`Spring`的源码，单例`bean`的生命周期可以总结为如下一张图

![format_png 3][]

[format_png]: /images/20210527/c5b565c0ce36425b870208c1167fb6c6.png
[format_png 1]: /images/20210527/34a38c89c5b54ac79e5c1a5c6d28cdc0.png
[format_png 2]: /images/20210527/6bf54e0937424a399962ceda6e63a2e5.png
[format_png 3]: /images/20210527/cf6da072ce794cb0ae7fcb1d419be8c9.png