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

谁践踏了优雅 2024-04-17 21:48 11阅读 0赞

![bean-lifecycle][]

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

1、典型的 Spring 生命周期

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

相比之下，Spring 管理 Bean 的生命周期就复杂多了，正确理解 Bean 的生命周期非常重要，因为 Spring 对 Bean 的管理可扩展性非常强，下面展示了一个 Bea 的构造过程。  
![Spring Bean 生命周期][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。代码如下：

package com.nasus.bean;
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.BeanNameAware;
 import org.springframework.beans.factory.DisposableBean;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.annotation.Scope;
 
 /** * Project Name:review_spring * Package Name:PACKAGE_NAME * Date:2019/9/1 16:29 * * @author <a href="turodog@foxmail.com">chenzy</a> */
 @Scope("ProtoType")
 public class Person implements BeanNameAware, BeanFactoryAware,
 ApplicationContextAware, InitializingBean, DisposableBean { 
 
 private static final Logger LOGGER = LoggerFactory.getLogger(Person.class);
 
 private String name;
 
 public Person(){ 
 System.out.println("1、开始实例化 person ");
 }
 
 public String getName() { 
 return name;
 }
 
 public void setName(String name) { 
 this.name = name;
 System.out.println("2、设置 name 属性");
 }
 
 @Override
 public void setBeanName(String beanId) { 
 System.out.println("3、Person 实现了 BeanNameAware 接口，Spring 将 Person 的 "
 + "ID=" + beanId + "传递给 setBeanName 方法");
 }
 
 @Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException { 
 System.out.println("4、Person 实现了 BeanFactoryAware 接口，Spring 调"
 + "用 setBeanFactory()方法，将 BeanFactory 容器实例传入");
 }
 
 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
 System.out.println("5、Person 实现了 ApplicationContextAware 接口，Spring 调"
 + "用 setApplicationContext()方法，将 person 所在的应用上下文的"
 + "引用传入进来");
 }
 
 @Override
 public void afterPropertiesSet() throws Exception { 
 System.out.println("8、Person 实现了 InitializingBean 接口，Spring 调用它的"
 + "afterPropertiesSet()方法。类似地，如果 person 使用 init-"
 + "method 声明了初始化方法，该方法也会被调用");
 }
 
 @Override
 public void destroy() throws Exception { 
 System.out.println("13、Person 实现了 DisposableBean 接口，Spring 调用它的"
 + "destroy() 接口方法。同样，如果 person 使用 destroy-method 声明"
 + "了销毁方法，该方法也会被调用");
 }
 
 /** * xml 中声明的 init-method 方法 */
 public void initMethod(){ 
 System.out.println("9、xml 中声明的 init-method 方法");
 }
 
 /** * xml 中声明的 destroy-method 方法 */
 public void destroyMethod(){ 
 System.out.println("14、xml 中声明的 destroy-method 方法");
 System.out.println("end---------------destroy-----------------");
 }
 
 // 自定义初始化方法
 @PostConstruct
 public void springPostConstruct(){ 
 System.out.println("7、@PostConstruct 调用自定义的初始化方法");
 }
 
 // 自定义销毁方法
 @PreDestroy
 public void springPreDestory(){ 
 System.out.println("12、@PreDestory 调用自定义销毁方法");
 }
 
 @Override
 protected void finalize() throws Throwable { 
 System.out.println("finalize 方法");
 }
 }

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

package com.nasus.lifecycle;
 
 import com.nasus.bean.Person;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.config.BeanPostProcessor;
 
 /** * Project Name:review_spring * Package Name:PACKAGE_NAME * Date:2019/9/1 16:25 * * @author <a href="turodog@foxmail.com">chenzy</a> */
 public class MyBeanPostProcessor implements BeanPostProcessor { 
 
 // 容器加载的时候会加载一些其他的 bean，会调用初始化前和初始化后方法
 // 这次只关注 Person 的生命周期
 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
 if(bean instanceof Person){ 
 System.out.println("6、初始化 Person 之前执行的方法");
 }
 return bean;
 }
 
 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
 if(bean instanceof Person){ 
 System.out.println("10、初始化 Person 完成之后执行的方法");
 }
 return bean;
 }
 
 }

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

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

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

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 做如下代码修改，其余类保持不变：

<bean id="person" scope="prototype" class="com.nasus.bean.Person" init-method="initMethod" destroy-method="destroyMethod">
 
 <property name="name" value="nasus" />
 </bean>

此时的日志输出如下：

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

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

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

![单实例 bean 的加载时机][bean]

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

![多实例模式下 bean 加载时机][bean 1]

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

![多实例模式下 bean 加载时机][bean 2]

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

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

<bean id="person" lazy-init="true" class="com.nasus.bean.Person" init-method="initMethod" destroy-method="destroyMethod">
 
 <property name="name" value="nasus" />
 </bean>

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

**推荐阅读：**  
[\*1、\*java | 什么是动态代理][1_java _]

[\*2、\*Spring 复盘(1) | IOC][2_Spring _1_ _ IOC]

[\*3、\*Spring 复盘(2) | AOP][3_Spring _2_ _ AOP]

[\*4、\*SpringBoot | 启动原理][4_SpringBoot _]

[*5*、SpringBoot | 自动配置原理][5_SpringBoot _]

[\*6、\*Spring MVC 复盘 | 工作原理及配置详解][6_Spring MVC _ _]

![一个优秀的废人][format_png]

[bean-lifecycle]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8zMjgyMTM0LTViY2RiNTg5OWQ2ZDRjZWQuanBlZw?x-oss-process=image/format,png
[Spring Bean]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8zMjgyMTM0LTYzNmRhYzgzMzU5ODhhZTkucG5n?x-oss-process=image/format,png
[bean]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8zMjgyMTM0LWViZGRhYzM4YThlZTAwODUucG5n?x-oss-process=image/format,png
[bean 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8zMjgyMTM0LWE5MTNjOWFkOGVjNGFhMmYucG5n?x-oss-process=image/format,png
[bean 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8zMjgyMTM0LTYxN2IzNzU3MGVhZDkyODEucG5n?x-oss-process=image/format,png
[1_java _]: http://mp.weixin.qq.com/s?__biz=MzU2MDY0NDA1MQ==&mid=2247483991&idx=1&sn=9e975618909b78006aaa9a3f001959f1&chksm=fc05a8ebcb7221fd4d9e7e8b645a5b1bd2536bc49a3eaf34eb18c1f7bcc33337ecd98af54e98&scene=21#wechat_redirect
[2_Spring _1_ _ IOC]: http://mp.weixin.qq.com/s?__biz=MzU2MDY0NDA1MQ==&mid=2247484498&idx=1&sn=919d78265e4f78cf5b6c7311210bba04&chksm=fc05aeeecb7227f8cb44d3cb74d695346077c33d499132b63e3f8feaa4b9757a88bdddcc2e23&scene=21#wechat_redirect
[3_Spring _2_ _ AOP]: http://mp.weixin.qq.com/s?__biz=MzU2MDY0NDA1MQ==&mid=2247484514&idx=1&sn=c955f8f11a4f3d835922dace4a601d83&chksm=fc05aedecb7227c850f0ad68d6bf397a1ed97788a5672065b2e195fa5c51ca3f93442e103479&scene=21#wechat_redirect
[4_SpringBoot _]: http://mp.weixin.qq.com/s?__biz=MzU2MDY0NDA1MQ==&mid=2247484325&idx=1&sn=ef09f84b1597285896adad51a019e33d&chksm=fc05a919cb72200f0c6bcd3ce0832e3b7954d79b7529e07c133c394de9e9153813acd623fbcc&scene=21#wechat_redirect
[5_SpringBoot _]: http://mp.weixin.qq.com/s?__biz=MzU2MDY0NDA1MQ==&mid=2247483960&idx=1&sn=0f84bbb92c5cb5298388056bef405aff&chksm=fc05a884cb722192e33ea62ad1febdc79e2a101d4ca2e8171760c1dda14cab940320209a088a&scene=21#wechat_redirect
[6_Spring MVC _ _]: http://mp.weixin.qq.com/s?__biz=MzU2MDY0NDA1MQ==&mid=2247484519&idx=1&sn=04bf13c9f9c0101851369e1c69ecd7d3&chksm=fc05aedbcb7227cddce620a3f1bdb2561d87d8743db86c0e7872db344efc6c8d73febb306e5c&scene=21#wechat_redirect
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8zMjgyMTM0LTA0N2U2ZGUzMDNlYTMyYTM?x-oss-process=image/format,png