SpringBean的实例化，后置处理器以及生命周期

一.Bean实例化的基本流程：

Bean对象----->BeanDefinition信息对象

BeanDefintion存储到一个名为beanDefinitionMap中

对象存储在一个名为singletonObjects的Map中

Bean实例化的基本流程：

二.Spring的后处理器

Bean工厂后处理器- BeanFactoryPostProcessor

演示注册，修改：

2.注入实现类，（注册繁琐，更擅长修改）

演示注册：

：结果分析，获得两个Studnet对象，且user的内部也是获得，因为我们在BeanFctoryProcessor内部对于user的Bean对象做了修改，并且注册了Studnet的Bean对象

BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行；

Bean后处理器 --- BeanPostProcessor

三.Bean的生命周期

四.常用的Aware接口

生命周期总结：

一.Bean实例化的基本流程：

Bean实例化的基本流程：

spring容器在进行初始化时，会将xml配置的信息封装成一个BeanDefinition对象，所有的BeanDefinition存储到一个名为beanDedinitionMap的Map集合中去，Spring框架在对该Map进行遍历，使用反射创建Bean实例对象，创建好的Bean对象存储在一个名为SingletonObjects的Map集合中，当调用getBean方法时，则最终从该Map集合中取出Bean实例对象返回

通俗的理解：容器中的Bean最终都会变成一个BeanDefinition信息对象（Bean中配置了什么信息，都会存入BeanDefinition信息对象）

Bean对象----->BeanDefinition信息对象

BeanDefintion存储到一个名为beanDefinitionMap中

对象存储在一个名为singletonObjects的Map中

Bean实例化的基本流程：

加载xml配置文件，解析获取配置中的每个bean的信息，封装成一个个的BeanDefinition对象。
将BeanDefinition存储在一个名为beanDefinitionMap的Map<String,BeanDefinition>中。
ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象
创建好的Bean实例对象，被存储到一个名为singletonObjects的Map<String,Object>中
当执行applicationContext.getBean(beanName)时，从singletonObjects中去匹配Bena实例返回

二.Spring的后处理器

Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。Spring主要有两种后处理器：

Bean工厂后处理器- BeanFactoryPostProcessor

BeanFactoryPostProcessor是一个接口规范，实现了该接口的类只要交由Spring容器管理的话，那么Spring就会回调该接口的方法，用于对BeanDefinition注册和修改的功能。

演示注册，修改：

1.创建BeanFactoryPostProcessor实现类并重写方法

2.注入实现类，（注册繁琐，更擅长修改）

演示注册：

1.创建BeanDefinitionRegistryPostProcessor实现类并重写方法

2.注入实现类，（更擅长注册）

统一定义User类和Student类

BeanFactoryPostProcessor的实现类；

注意：在此时，我们在配置文件中注入user的Bean对象

并将BeanFactoryPostProcessor也注入进去。
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor的postProcessBeanFactory");
//        修改演示
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("user");
        beanDefinition.setBeanClassName("com.apesource.pojo.Student");

        //注册演示
        BeanDefinition beanDefinition1 = new RootBeanDefinition();
        beanDefinition1.setBeanClassName("com.apesource.pojo.Student");
        //强转为DefaultListableBeanFactory
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) beanFactory;
        defaultListableBeanFactory.registerBeanDefinition("stu",beanDefinition1);
    }
}
按照常理来说，我们可以通过user的id，获取到User对象，且没有注入Student对象，我们也不能根据stu获取Student对象

测试类及其结果：

：结果分析，获得两个Studnet对象，且user的内部也是获得，因为我们在BeanFctoryProcessor内部对于user的Bean对象做了修改，并且注册了Studnet的Bean对象

BeanDefinitionRegistryPostProcessor实现一致

但是此处不需要强制转换，擅长注册。

BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行；

Bean后处理器 --- BeanPostProcessor

Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，中间会经过初始化过程，例如属性的DI注入，初始化方法init的执行等，其中一个对外进行扩展的点BeanPostProcessor，我们称为Bean后处理器。

跟上面的Bean工厂处理器相似，它也是一个接口，实现了该接口并被容器管理的BeanPostProcessor，会在流程节点上被Spring自动调用。
BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行
演示：
自定义后处理器，并实现后处理器接口。
必须要重写两个方法，分别输出对应的方法。

/* 参数： bean 是当前被实例化的 Bean ， beanName 是当前 Bean 实例在容器中的名称

返回值：当前 Bean 实例对象 */
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor的before方法...");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor的after方法...");
        return bean;
    }
}
将后处理器注入到IOC容器中
 <bean class="com.apesource.processor.MyBeanPostProcessor" id="beanPostProcessor"></bean>
测试代码：结果
 ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        Object user = app.getBean("user");
        System.out.println(user);

三.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()方法回调

Bean 实例属性填充

BeanDefinition 中有对当前 Bean 实体的注入信息通过属性 propertyValues 进行了存储，例如

总结：

Spring 在进行属性注入时，会分为如下几种情况：

注入普通属性， String 、 int 或存储基本类型的集合时，直接通过 set 方法的反射设置进去；

注入单向对象引用属性时，从容器中 getBean 获取后通过 set 方法反射设置进去，如果容器中没有，则先创建被注入对象Bean 实例（完成整个生命周期）后，在进行注入操作；

注入双向对象引用属性时，就比较复杂了，涉及了循环引用（循环依赖）

四.常用的Aware接口

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

总结：处理器的作用，为 Bean 生命周期各个阶段提供扩展