Spring 复盘(三) | Bean 的生命周期

JavaFish

发布于 2019-10-17 12:22:46

4550

发布于 2019-10-17 12:22:46

文章被收录于专栏：狗哥的 Java 世界狗哥的 Java 世界

继续 Spring 复盘，今天看了下 Spring 的 Bean 生命周期。

1、典型的 Spring 生命周期

在传统的 Java 应用中，bean 的生命周期很简单，使用 Java 关键字 new 进行Bean 的实例化，然后该 Bean 就能够使用了。一旦 bean 不再被使用，则由 Java 自动进行垃圾回收，简直不要太简单。

相比之下，Spring 管理 Bean 的生命周期就复杂多了，正确理解 Bean 的生命周期非常重要，因为 Spring 对 Bean 的管理可扩展性非常强，下面展示了一个 Bea 的构造过程。

Spring Bean 生命周期

以上图片出自《Spring 实战（第四版）》一书，图片描述了一个经典的 Spring Bean 的生命周期，书中随他的解释如下：

1．Spring对bean进行实例化； 2．Spring将值和bean的引用注入到bean对应的属性中； 3．如果bean实现了BeanNameAware接口，Spring将bean的ID传递给 setBean-Name()方法； 4．如果bean实现了BeanFactoryAware接口，Spring将调用setBeanFactory()方法，将BeanFactory容器实例传入； 5．如果bean实现了ApplicationContextAware接口，Spring将调用setApplicationContext()方法，将bean所在的应用上下文的引用传入进来； 6．如果bean实现了BeanPostProcessor接口，Spring将调用它们的post-ProcessBeforeInitialization()方法； 7．如果bean实现了InitializingBean接口，Spring将调用它们的 after-PropertiesSet()方法。类似地，如果bean使用init- method声明了初始化方法，该方法也会被调用； 8．如果bean实现了BeanPostProcessor接口，Spring将调用它们的post-ProcessAfterInitialization()方法； 9．此时，bean已经准备就绪，可以被应用程序使用了，它们将一直驻留在应用上下文中，直到该应用上下文被销毁； 10．如果bean实现了DisposableBean接口，Spring将调用它的 destroy()接口方法。同样，如果bean使用destroy-method声明了销毁方法，该方法也会被调用。

2、验证 Spring Bean 周期

写了下代码验证以上说法，首先创建一个 Person 类，它就是我们要验证的 Bean ，为方便测试，他实现了 BeanNameAware, BeanFactoryAware,ApplicationContextAware, InitializingBean, DisposableBean。代码如下：

  1 package com.nasus.bean;
  2
  3 import javax.annotation.PostConstruct;
  4 import javax.annotation.PreDestroy;
  5 import org.slf4j.Logger;
  6 import org.slf4j.LoggerFactory;
  7 import org.springframework.beans.BeansException;
  8 import org.springframework.beans.factory.BeanFactory;
  9 import org.springframework.beans.factory.BeanFactoryAware;
 10 import org.springframework.beans.factory.BeanNameAware;
 11 import org.springframework.beans.factory.DisposableBean;
 12 import org.springframework.beans.factory.InitializingBean;
 13 import org.springframework.beans.factory.config.BeanPostProcessor;
 14 import org.springframework.context.ApplicationContext;
 15 import org.springframework.context.ApplicationContextAware;
 16 import org.springframework.context.annotation.Scope;
 17
 18 /**
 19  * Project Name:review_spring <br/>
 20  * Package Name:PACKAGE_NAME <br/>
 21  * Date:2019/9/1 16:29 <br/>
 22  *
 23  * @author <a href="turodog@foxmail.com">chenzy</a><br/>
 24  */
 25 @Scope("ProtoType")
 26 public class Person implements BeanNameAware, BeanFactoryAware,
 27         ApplicationContextAware, InitializingBean, DisposableBean {
 28
 29     private static final Logger LOGGER = LoggerFactory.getLogger(Person.class);
 30
 31     private String name;
 32
 33     public Person(){
 34         System.out.println("1、开始实例化 person ");
 35     }
 36
 37     public String getName() {
 38         return name;
 39     }
 40
 41     public void setName(String name) {
 42         this.name = name;
 43         System.out.println("2、设置 name 属性");
 44     }
 45
 46     @Override
 47     public void setBeanName(String beanId) {
 48         System.out.println("3、Person 实现了 BeanNameAware 接口，Spring 将 Person 的 "
 49                 + "ID=" + beanId + "传递给 setBeanName 方法");
 50     }
 51
 52     @Override
 53     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 54         System.out.println("4、Person 实现了 BeanFactoryAware 接口，Spring 调"
 55                 + "用 setBeanFactory()方法，将 BeanFactory 容器实例传入");
 56     }
 57
 58     @Override
 59     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
 60         System.out.println("5、Person 实现了 ApplicationContextAware 接口，Spring 调"
 61                 + "用 setApplicationContext()方法，将 person 所在的应用上下文的"
 62                 + "引用传入进来");
 63     }
 64
 65     @Override
 66     public void afterPropertiesSet() throws Exception {
 67         System.out.println("8、Person 实现了 InitializingBean 接口，Spring 调用它的"
 68                 + "afterPropertiesSet()方法。类似地，如果 person 使用 init-"
 69                 + "method 声明了初始化方法，该方法也会被调用");
 70     }
 71
 72     @Override
 73     public void destroy() throws Exception {
 74         System.out.println("13、Person 实现了 DisposableBean 接口，Spring 调用它的"
 75                 + "destroy() 接口方法。同样，如果 person 使用 destroy-method 声明"
 76                 + "了销毁方法，该方法也会被调用");
 77     }
 78
 79     /**
 80      * xml 中声明的 init-method 方法
 81      */
 82     public void initMethod(){
 83         System.out.println("9、xml 中声明的 init-method 方法");
 84     }
 85
 86     /**
 87      * xml 中声明的 destroy-method 方法
 88      */
 89     public void destroyMethod(){
 90         System.out.println("14、xml 中声明的 destroy-method 方法");
 91         System.out.println("end---------------destroy-----------------");
 92     }
 93
 94     // 自定义初始化方法
 95     @PostConstruct
 96     public void springPostConstruct(){
 97         System.out.println("7、@PostConstruct 调用自定义的初始化方法");
 98     }
 99
100     // 自定义销毁方法
101     @PreDestroy
102     public void springPreDestory(){
103         System.out.println("12、@PreDestory 调用自定义销毁方法");
104     }
105
106     @Override
107     protected void finalize() throws Throwable {
108         System.out.println("finalize 方法");
109     }
110 }

除此之外，创建了一个 MyBeanPostProcessor 类继承自 BeanPostProcessor 这个类只关心 Person 初始化前后要做的事情。比如，初始化之前，加载其他 Bean。代码如下：

 1 package com.nasus.lifecycle;
 2 
 3 import com.nasus.bean.Person;
 4 import org.springframework.beans.BeansException;
 5 import org.springframework.beans.factory.config.BeanPostProcessor;
 6
 7 /**
 8  * Project Name:review_spring <br/>
 9  * Package Name:PACKAGE_NAME <br/>
10  * Date:2019/9/1 16:25 <br/>
11  *
12  * @author <a href="turodog@foxmail.com">chenzy</a><br/>
13  */
14 public class MyBeanPostProcessor implements BeanPostProcessor {
15 
16     // 容器加载的时候会加载一些其他的 bean，会调用初始化前和初始化后方法
17     // 这次只关注 Person 的生命周期
18     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
19         if(bean instanceof Person){
20             System.out.println("6、初始化 Person 之前执行的方法");
21         }
22         return bean;
23     }
24
25     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
26         if(bean instanceof Person){
27             System.out.println("10、初始化 Person 完成之后执行的方法");
28         }
29         return bean;
30     }
31
32 }

resource 文件夹下新建一个 bean_lifecycle.xml 文件注入相关 bean ，代码如下：

 1 <beans xmlns="http://www.springframework.org/schema/beans"
 2        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3        xmlns:context="http://www.springframework.org/schema/context"
 4        xsi:schemaLocation="http://www.springframework.org/schema/beans
 5 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 6 
 7     <!-- 扫描bean -->
 8     <context:component-scan base-package="com.nasus"/>
 9 
10     <!-- 实现了用户自定义初始化和销毁方法 -->
11     <bean id="person" class="com.nasus.bean.Person" init-method="initMethod" destroy-method="destroyMethod">
12         <!-- 注入bean 属性名称 -->
13         <property name="name" value="nasus" />
14     </bean>
15 
16     <!--引入自定义的BeanPostProcessor-->
17     <bean class="com.nasus.lifecycle.MyBeanPostProcessor"/>
18 
19 </beans>

测试类，获取 person 这个 Bean 并使用它，代码如下：

 1 import com.nasus.bean.Person;
 2 import java.awt.print.Book;
 3 import org.junit.Test;
 4 import org.springframework.context.ApplicationContext;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6
 7 /**
 8  * Project Name:review_spring <br/>
 9  * Package Name:PACKAGE_NAME <br/>
10  * Date:2019/9/1 16:38 <br/>
11  *
12  * @author <a href="turodog@foxmail.com">chenzy</a><br/>
13  */
14 public class lifeCycleTest {
15 
16     @Test
17     public void testLifeCycle(){
18         // 为面试而准备的Bean生命周期加载过程
19         ApplicationContext context = new ClassPathXmlApplicationContext("bean_lifecycle.xml");
20         Person person = (Person)context.getBean("person");
21         // 使用属性
22         System.out.println("11、实例化完成使用属性：Person name = " + person.getName());
23         // 关闭容器
24         ((ClassPathXmlApplicationContext) context).close();
25     }
26 
27 }

lifeCycleTest 方法最后关闭了容器，关闭的同时控制台日志输出如下：

 1、开始实例化 person 
 2、设置 name 属性
 3、Person 实现了 BeanNameAware 接口，Spring 将 Person 的 ID=person传递给 setBeanName 方法
 4、Person 实现了 BeanFactoryAware 接口，Spring 调用 setBeanFactory()方法，将 BeanFactory 容器实例传入
 5、Person 实现了 ApplicationContextAware 接口，Spring 调用 setApplicationContext()方法，将 person 所在的应用上下文的引用传入进来
 6、初始化 Person 之前执行的方法
 7、@PostConstruct 调用自定义的初始化方法
 8、Person 实现了 InitializingBean 接口，Spring 调用它的afterPropertiesSet()方法。类似地，如果 person 使用 init-method 声明了初始化方法，该方法也会被调用
 9、xml 中声明的 init-method 方法
10、初始化 Person 完成之后执行的方法
11、实例化完成使用属性：Person name = nasus
12、@PreDestory 调用自定义销毁方法
13、Person 实现了 DisposableBean 接口，Spring 调用它的destroy() 接口方法。同样，如果 person 使用 destroy-method 声明了销毁方法，该方法也会被调用
14、xml 中声明的 destroy-method 方法
end---------------destroy-----------------

由以上日志可知，当 person 默认是单例模式时，bean 的生命周期与容器的生命周期一样，容器初始化，bean 也初始化。容器销毁，bean 也被销毁。那如果，bean 是非单例呢？

3、在 Bean 实例化完成后，销毁前搞事情有时我们需要在 Bean 属性值 set 好之后和 Bean 销毁之前做一些事情，比如检查 Bean 中某个属性是否被正常的设置好值了。Spring 框架提供了多种方法让我们可以在 Spring Bean 的生命周期中执行 initialization 和 pre-destroy 方法。这些方法我在上面已经测试过了，以上代码实现了多种方法，它是重复，开发中选以下其一即可，比如：

在配置文件中指定的 init-method 和 destroy-method 方法
实现 InitializingBean 和 DisposableBean 接口
使用 @PostConstruct 和 @PreDestroy 注解（墙裂推荐使用）

4、多实例模式下的 Bean 生命周期上面测试中的 person 默认是 singleton 的，现在我们将 person 改为 protoType 模式，bean_lifecycle.xml 做如下代码修改，其余类保持不变：

1 <!-- 实现了用户自定义初始化和销毁方法 -->
2 <bean id="person" scope="prototype" class="com.nasus.bean.Person" init-method="initMethod" destroy-method="destroyMethod">
3      <!-- 注入bean 属性名称 -->
4      <property name="name" value="nasus" />
5 </bean>

此时的日志输出如下：

 1、开始实例化 person 
 2、设置 name 属性
 3、Person 实现了 BeanNameAware 接口，Spring 将 Person 的 ID=person传递给 setBeanName 方法
 4、Person 实现了 BeanFactoryAware 接口，Spring 调用 setBeanFactory()方法，将 BeanFactory 容器实例传入
 5、Person 实现了 ApplicationContextAware 接口，Spring 调用 setApplicationContext()方法，将 person 所在的应用上下文的引用传入进来
 6、初始化 Person 之前执行的方法
 7、@PostConstruct 调用自定义的初始化方法
 8、Person 实现了 InitializingBean 接口，Spring 调用它的afterPropertiesSet()方法。类似地，如果 person 使用 init-method 声明了初始化方法，该方法也会被调用
 9、xml 中声明的 init-method 方法
10、初始化 Person 完成之后执行的方法
11、实例化完成使用属性：Person name = nasus

此时，容器关闭，person 对象并没有销毁。原因在于，单实例模式下，bean 的生命周期由容器管理，容器生，bean 生；容器死，bean 死。而在多实例模式下，Spring 就管不了那么多了，bean 的生命周期，交由客户端也就是程序员或者 JVM 来进行管理。

5、多实例模式下 Bean 的加载时机

首先说说单实例，单实例模式下，bean 在容器加载那一刻起，就已经完成实例化了，证明如下，我启用 debug 模式，在 20 行打了一个断点，而日志却如下所示，说明了 bean 在 19 行，初始化容器的时候，已经完成实例化了。

单实例 bean 的加载时机

再说多实例模式下，这个模式下，bean 在需要用到 bean 的时候才进行初始化，证明如下，同样执行完 19 行，多实例模式下，控制台一片空白，说明此时的 bean 是未被加载的。

多实例模式下 bean 加载时机

debug 走到 23 行时，也就是需要用到 bean 时才被加载了，验证如下。在开发中，我们把这种加载叫做懒加载，它的用处就是减轻程序开销，等到要用时才加载，而不是一上来就加载全部。

多实例模式下 bean 加载时机

6、单实例 bean 如何实现延迟加载

只需在 xml 中加上 lazy-init 属性为 true 即可。如下，它的加载方式就变成了懒加载。

1 <!-- 实现了用户自定义初始化和销毁方法 -->
2 <bean id="person" lazy-init="true" class="com.nasus.bean.Person" init-method="initMethod" destroy-method="destroyMethod">
3      <!-- 注入bean 属性名称 -->
4      <property name="name" value="nasus" />
5 </bean>

如果想对所有的默认单例 bean 都应用延迟初始化，可以在根节点 beans 设置 default-lazy-init 属性为 true，如下所示：