Spring Bean的生命周期

目录

前言

一.实例化

1.1Bean 实例化的基本流程

1.2Bean 实例化的基本流程图 

1.3Spring的后处理器

BeanFactoryPostProcessor 

二.初始化 

三.Bean的完成阶段

总结：

---

前言

        在Spring框架的学习中，我们会经常遇到关于Bean的生命周期的相关问题，而了解 Spring 生命周期的意义就在于，可以利用 Bean 在其存活期间的指定时刻完成一些相关操作。这种时刻可能有很多，但一般情况下，会在 Bean 被初始化后和被销毁前执行一些相关操作。

        在 Spring 中，Bean 的生命周期是一个很复杂的执行过程，我们可以利用 Spring 提供的方法定制 Bean 的创建过程。

        当一个 Bean 被加载到 Spring 容器时，它就具有了生命，而 Spring 容器在保证一个 Bean 能够使用之前，会进行很多工作。大体上可以总结为：实例化 ===>属性赋值===>初始化===>操作使用===>销毁，但还有很多细节部分的完成需要好好理解。

一.实例化

1.1Bean 实例化的基本流程

        Spring容器在进行初始化时，会将 xml 配置的信息封装成一个 BeanDefifinition（即：Bean的信息对象） 对象，所有的BeanDefifinition存储到一个名为 beanDefifinitionMap 的 Map 集合中如下图：

 

        Spring框架在对该Map进行遍历，使用反射创建Bean实例对象，创建好的Bean对象存储在一个名为singletonObjects的Map集合中，如下图所示：当调用getBean方法时则最终从该Map集合中取出Bean实例对象返回。

 

1.2Bean 实例化的基本流程图 

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

 

 

1.3Spring的后处理器

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

1. BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefifinitionMap填充完毕，Bean实例化之前执行；
2. BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects 之前执行。

BeanFactoryPostProcessor 

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

修改：

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

2. 注入实现类

注册：

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

2. 注入实现类

Spring 提供了一个BeanFactoryPostProcessor的子接口BeanDefifinitionRegistryPostProcessor专门用于注册BeanDefifinition操作。

public class MyBeanFactoryPostProcessor2 implements
BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory
configurableListableBeanFactory) throws BeansException {}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry
beanDefinitionRegistry) throws BeansException {
BeanDefinition beanDefinition = new RootBeanDefinition();
beanDefinition.setBeanClassName("com.apesource.pojo.Student");
beanDefinitionRegistry.registerBeanDefinition("stu",beanDefinition);
}
}

BeanPostProcessor 

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

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

会在流程节点上被Spring 自动调用。

//1.自定义MyBeanPostProcessor
public class MyBeanPostProcessor 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;
}
}
//2.注入配置MyBeanPostProcessor
<bean class="com.apesource.processors.MyBeanPostProcessor"></bean>
//3.测试控制台打印结果

详细流程图如下：

 

二.初始化 

        Bean创建之后还仅仅是个 " 半成品 " ，还需要对 Bean 实例的属性进行填充、执行一些Aware 接口方法、执行 BeanPostProcessor 方法、执行 InitializingBean 接口的初始化方法、执行自定义初始化init 方法等。该阶段是 Spring最具技术含量和复杂度的阶段； 

        由于Bean 的初始化阶段的步骤比较复杂，所以着重研究 Bean 的初始化阶段Spring Bean的初始化过程涉及如下几个过程：

• Bean实例的属性填充
• Aware接口属性注入
• BeanPostProcessor的before()方法回调
• InitializingBean接口的初始化方法回调
• 自定义初始化方法init回调
• BeanPostProcessor的after()方法回调

 

Bean实例属性填充

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

   

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

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

常用的Aware接口

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

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

 

三.Bean的完成阶段

经过初始化阶段， Bean 就成为了一个完整的 Spring Bean ，被存储到单例池 singletonObjects中去了，即完成了 Spring Bean 的整个生命周期。

总结：

Bean 生命周期的整个执行过程描述如下。

1）根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。

2）利用依赖注入完成 Bean 中所有属性值的配置注入。

3）如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。

4）如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。

5）如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。

6）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP 就是利用它实现的。

7）如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。

8）如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。

9）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了。

10）如果在 <bean> 中指定了该 Bean 的作用范围为 scope="singleton"，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在 <bean> 中指定了该 Bean 的作用范围为 scope="prototype"，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean。

11）如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。

Spring 为 Bean 提供了细致全面的生命周期过程，通过实现特定的接口或 <bean> 的属性设置，都可以对 Bean 的生命周期过程产生影响。虽然可以随意配置 <bean> 的属性，但是建议不要过多地使用 Bean 实现接口，因为这样会导致代码和 Spring 的聚合过于紧密。