Bean 实例化的基本流程和生命周期

一、Bean 实例化的基本流程

Spring容器在进行初始化时，会将xml配置的的信息封装成一个BeanDefinition对象，

所有的 BeanDefinition存储到一个名为beanDefinitionMap的Map集合中去，Spring框架在对该Map进行遍历，使用反射创建Bean实例对象，

创建好的Bean对象存储在一个名为singletonObjects的Map集合中，当调用 getBean方法时则最终从该Map集合中取出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实现类并重写方法 2. 注入实现类

演示注册： 1. 创建BeanFactoryPostProcessor实现类并重写方法 2. 注入实现类

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("wei.pojo.Student");

        //注册演示
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("wei.pojo.Student");
        //强转成DefaultListableBeanFactory
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) beanFactory;
        defaultListableBeanFactory.registerBeanDefinition("stu",beanDefinition);

    }
}

Bean工厂后处理器 – BeanDefinitionRegistryPostProcessor

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

public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("wei.pojo.Student");
        registry.registerBeanDefinition("stu2",beanDefinition);
    }
}

2.BeanPostProcessor

Bean后处理器 – BeanPostProcessor

Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，中间会经过Bean的初始化过程。

例如：属性的填充、初始方法init的执行等，其中有一个对外进行扩展的点BeanPostProcessor，我们称为Bean后处理。跟上面的 Bean工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的BeanPostProcessor， 会在流程节点上被Spring自动调用。 

自定义演示： 

1.自定义MyBeanPostProcessor

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;
    }
}

2.注入配置MyBeanPostProcessor

<bean class="wei.processor.MyBeanPostProcessor"></bean>

3.测试控制台打印即可

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

常用的Aware接口

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

代码实例如下： 

 1.导入坐标

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.7</version>
    </dependency>

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
    </dependency>
</dependencies>

2.编写aware接口注入代码

public class User implements BeanNameAware, ApplicationContextAware, BeanFactoryAware {
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println(beanFactory);

    }

    @Override
    public void setBeanName(String s) {
        System.out.println(s);

    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println(applicationContext);

    }
}

3.xml配置

<bean class="com.wei.pojo.User" id="users"></bean>

4.测试

public class Test01 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Object user = applicationContext.getBean("users");
        System.out.println(user);
    }
}

 结果如下：