转载

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

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

继续 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。代码如下：

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 <br/>
 * Package Name:PACKAGE_NAME <br/>
 * Date:2019/9/1 16:29 <br/>
 *
 * @author <a href="turodog@foxmail.com">chenzy</a><br/>
 */
@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 <br/>
 * Package Name:PACKAGE_NAME <br/>
 * Date:2019/9/1 16:25 <br/>
 *
 * @author <a href="turodog@foxmail.com">chenzy</a><br/>
 */
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 ，代码如下：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
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">

    <!-- 扫描bean -->
    <context:component-scan base-package="com.nasus"/>

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

    <!--引入自定义的BeanPostProcessor-->
    <bean class="com.nasus.lifecycle.MyBeanPostProcessor"/>

</beans>

测试类，获取 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 <br/>
 * Package Name:PACKAGE_NAME <br/>
 * Date:2019/9/1 16:38 <br/>
 *
 * @author <a href="turodog@foxmail.com">chenzy</a><br/>
 */
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">
     <!-- 注入bean 属性名称 -->
     <property name="name" value="nasus" />
</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 行，初始化容器的时候，已经完成实例化了。

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

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

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

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

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

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

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

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

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

<beans default-lazy-init="true" …>

7、源码地址

https://github.com/turoDog/review_spring

原文  https://segmentfault.com/a/1190000020253594
正文到此结束
所属分类： 编程技术 Java

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 springcloud-demo XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Spring Cloud Consul实现选举机制
  2. 2 Spring Boot集成ShedLock实现分布式定时任务
  3. 3 利用oss进行数据库和网站图片备份
  4. 4 Spring Cloud Stream实现数据流处理
  5. 5 Python3访问MySQL数据库快速入门Demo
  6. 6 Github开源项目作者可以免费申请 JetBrains 全家桶
  7. 7 Spring Cloud Vault快速入门Demo
  8. 8 Spring Cloud Gateway快速入门Demo
  9. 9 Spring Cloud Contract快速入门Demo
  10. 10 Spring Cloud Consul快速入门Demo
网站信息
  • 文章总数：82,714 篇
  • 文件总数：284,287 个
  • 标签总数：2,393 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：634 人
  • 运行天数：4,409天
  • 最后更新：2024年11月22日01点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG