Bean的生命周期

之前简单记录了下springBean的生命周期，最近翻开来看了下，发现自己遗漏了很多细节，很多点都衔接不上
今天重新翻看《spring揭秘》，查资料，补了许多细节。希望能够让自己和大家更容易看懂吧

Bean的生命周期的完全实现需要两个阶段

1. 容器的启动
2. bean的实例化过程（涵盖了bean生命周期的大部分）

容器启动阶段

1. 重点是收集到元信息配置信息，即创建bean需要的信息（beanDefinition）
   通过BeanDefinitionReader,读取到beanDefinition信息，再通过beanDefinitionRegistry,将BeanDefinition注册到其里面

// 这是 PropertiesBeanDefinitionReader 把从properties文件读取到的配置信息，
// 通过 BeanDefinitionRegistry 注册 BeanDefinition的过程
            AbstractBeanDefinition bd = BeanDefinitionReaderUtils.createBeanDefinition(
                    parent, className, getBeanClassLoader());
            bd.setScope(scope); // 作用域 默认singleton
            bd.setAbstract(isAbstract); // 是否是抽象 默认false 如果是抽象的，容器不会实例化bean，而是将beanDefinition信息作为其子类使用
            bd.setLazyInit(lazyInit); // 懒加载 默认false 如果是false,容器一启动就会加载bean
            bd.setConstructorArgumentValues(cas); // 构造参数
            bd.setPropertyValues(pvs); // 属性信息
            getRegistry().registerBeanDefinition(beanName, bd); // 注册Beandefinition

BeanDefinitionReader 有多种,包括:

• PropertiesBeanDefinitionReader 读取Properties配置文件
• GroovyBeanDefinitionReader 读取Groovy配置文件
• XmlBeanDefinitionReader 读取Xml配置文件

bean实例化前 对beanDefinition做出自定义修改

BeanFactoryPostProcessor实例化bean之前，可以允许修改beanDefinition信息，下面是spring默认实现的BeanFactoryPostProcessor类：

• PropertyPlaceholderConfigurer允许我们在XML配置文件中使用占位符（PlaceHolder），并将这些占位符所代表的资源单独配置到简单的properties文件中来加载
• PropertyOverrideConfigurer覆盖对象的属性值
• 我们可以自己实现BeanFactoryPostProcessor依赖注入beanFactory ，修改beanDefinition信息

bean实例化阶段

doCreateBean源码方法（下面仅对beanFactory容器做解析，applicationContext容器其实大同小异）

/**
     * Actually create the specified bean. Pre-creation processing has already happened
     * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
     * 
Differentiates between default bean instantiation, use of a
     * factory method, and autowiring a constructor.
     * @param beanName the name of the bean
     * @param mbd the merged bean definition for the bean
     * @param args explicit arguments to use for constructor or factory method invocation
     * @return a new instance of the bean
     * @throws BeanCreationException if the bean could not be created
     * @see #instantiateBean
     * @see #instantiateUsingFactoryMethod
     * @see #autowireConstructor
     */
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @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
        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 {
                    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));
        if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
                logger.trace("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // Initialize the bean instance.
      
        Object exposedObject = bean;
        try {
                        // 填充bean对象属性
            populateBean(beanName, mbd, instanceWrapper);
                        //  初始化bean
            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) {
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set 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 " +
                                "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        // Register bean as disposable.
        try {
            // 检查是否实现DisposableBean接口，有的话注册销毁回调方法
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }

1. 首先第一步，调用createBeanInstance方法，利用反射调用类的构造方法，实例化bean，返回beanWrapper对象,再调用getWrappedInstance方法得到实例化的bean，beanWrapper对象具有获取对象属性的功能，所以可以调用populateBean用来实现属性填充。

2. 开始实例化bean之前，会检查bean有没有实现过Aware接口，如果有则实现。

   
   // AbstractAutowireCapableBeanFactory类中的 initializeBean方法
   
   private void invokeAwareMethods(String beanName, Object bean) {
        if (bean instanceof Aware) {
   
            // 如果Spring容器检测到当前对象实例实现了该接口，会将该对象实例的bean定义对应的beanName设置到当前对象实例。
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }
   
            // 如果容器检测到当前对象实例实现了该接口，会将对应加载当前bean的Classloader注入当前对象实例。
            // 默认会使用加载org.springframework.util.ClassUtils类的Classloader
            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
                }
            }
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
   
            // 以上几个Aware接口只是针对BeanFactory类型的容器而言
        }
    }

对于ApplicationContext类型容器，会额外实现几个Aware接口

3. BeanPostProcessor阶段

BeanPostProcessor的概念容易与BeanFactoryPostProcessor的概念混淆。
但只要记住BeanPostProcessor是存在于对象实例化阶段，而BeanFactoryPostProcessor则是存在于容器启动阶段，这两个概念就比较容易区分了。

BeanPostProcessor 有两个需要子类实现的方法

public interface BeanPostProcessor {

    /**
     * 调用bean的init方法之前做的前置处理
     */
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    /**
     * 调用bean的init方法之后做的前置处理
     */
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

}

在initializeBean方法内可以看到BeanPostProcessor的调用顺序

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction