Bean的生命周期

一、Bean实例化的基本流程

Bean 实例化的基本流程
       1. Spring容器在进行初始化时，会将xml配置的的信息封装成一个BeanDefinition对象，所有的
BeanDefinition存储到一个名为beanDefinitionMap的Map集合中去，Spring框架在对该Map进行遍
历，使用反射创建Bean实例对象，创建好的Bean对象存储在一个名为singletonObjects的Map集合中，当调用getBean方法时则最终从该Map集合中取出Bean实例对象返回。
        2.加载xml配置文件，解析获取配置中的每个的信息，封装成一个个的BeanDefinition对象;
将BeanDefinition存储在一个名为beanDefinitionMap的Map<String,BeanDefinition>中;
ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象;
创建好的Bean实例对象，被存储到一个名为singletonObjects的Map<String,Object>中;
当执行applicationContext.getBean(beanName)时，从singletonObjects去匹配Bean实例返回

二.Spring的后处理器

        Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。Spring主要有两种后处理器：
BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例
化之前执行；
BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects
之前执行

1.BeanFactoryPostProcessor

Bean工厂后处理器 – BeanFactoryPostProcessor
BeanFactoryPostProcessor是一个接口规范，实现了该接口的类只要交由Spring容器管理的话，那么Spring就会回调该接口的方法，用于对BeanDefinition注册和修改的功能。
演示修改和注册：
        1. 创建BeanFactoryPostProcessor实现类并重写方法

package com.apesource.processor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
//        //测试修改
//        BeanDefinition student = configurableListableBeanFactory.getBeanDefinition("student");
//        //修改beanDefinition student 的类为 User
//        student.setBeanClassName("com.apesource.bean.User");

        //测试注册
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.apesource.bean.User");

        //强制类型转换为DefaultListableBeanFactory
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableListableBeanFactory;
        defaultListableBeanFactory.registerBeanDefinition("user", beanDefinition);


    }

}

        2. 注入实现类

    <!--    注入BeanFactoryPostProcessor-->
    <bean class="com.apesource.processor.MyBeanFactoryPostProcessor"></bean>

Bean工厂后处理器 – BeanDefinitionRegistryPostProcessor

Spring 提供了一个BeanFactoryPostProcessor的子接口BeanDefinitionRegistryPostProcessor专门用于注册BeanDefinition操作

public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {

    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        //注册
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.apesource.bean.User");
        beanDefinitionRegistry.registerBeanDefinition("user", beanDefinition);
    }

    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {


    }
}

2.BeanPostProcessor
Bean后处理器 – BeanPostProcessor
Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，中间会经过Bean的初始化过程，例如：属性的填充、初始方法init的执行等，其中有一个对外进行扩展的点BeanPostProcessor，我们称为Bean后处理。跟上面的 Bean工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的BeanPostProcessor，会在流程节点上被Spring自动调用。

public class MyMyBeanPostProcessor implements BeanPostProcessor {
    /*  参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称
        返回值：当前Bean实例对象 */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor的before方法...");
        return bean;
    }

    /*  参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称
        返回值：当前Bean实例对象 */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor的after方法...");
        return bean;
    }
}

三.Spring Bean的生命周期

Spring Bean的生命周期是从 Bean 实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中，这个过程被称为Spring Bean的生命周期。Spring Bean的生命周期大体上分为三个阶段
        Bean的实例化阶段：Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的， 是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的
        Bean通过反射进行实例化；
        Bean的初始化阶段：Bean创建之后还仅仅是个"半成品"，还需要对Bean实例的属性进行填充、执行一些Aware 接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具技术含量和复杂度的阶段；
        Bean的完成阶段：经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池singletonObjects中去了，即完成了Spring Bean的整个生命周期。

由于Bean的初始化阶段的步骤比较复杂，所以着重研究Bean的初始化阶段
Spring Bean的初始化过程涉及如下几个过程：
        Bean实例的属性填充
        Aware接口属性注入
        BeanPostProcessor的before()方法回调
        InitializingBean接口的初始化方法回调
        自定义初始化方法init回调
        BeanPostProcessor的after()方法回调

总结：
Spring在进行属性注入时，会分为如下几种情况：
注入普通属性，String、int或存储基本类型的集合时，直接通过set方法的反射设置进去；
注入单向对象引用属性时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没
有，则先创建被注入对象Bean实例（完成整个生命周期）后，在进行注入操作；
注入双向对象引用属性时，就比较复杂了，涉及了循环引用（循环依赖）

四、常用的Aware接口

Aware接口是一种框架辅助属性注入的一种思想，其他框架中也可以看到类似的接口。框架具备高度封
装性，我们接 触到的一般都是业务代码，一个底层功能API不能轻易的获取到，但是这不意味着永远用
不到这些对象，如果用到了 ，就可以使用框架提供的类似Aware的接口，让框架给我们注入该对象
总结：处理器的作用，为Bean生命周期各个阶段提供扩展

五、总结：

bean的生命周期分为四个阶段：实例化，属性注入，初始化，销毁。

具体步骤：

        1.实例化Bean

        2.属性注入

        3.处理各种Aware接口

        4.实现BeanPostProsser前置处理

        5.InitializingBean接口初始化

        6.init-method自定义方法初始化

        7.BeanPostProcessor后置处理

        执行完上述步骤就可以正常使用Bean

        8.执行DisposableBean销毁Bean

        9.执行destroy-method自定义销毁方法