Spring之Bean的生命周期-阿里云开发者社区

前言

老铁们好，欢迎阅读本期博客，上期博客与大家分享了Spring中的AOP（面向切面）的相关知识，本期博客给大家带来的是Spring之Bean的生命周期的相关知识的分享，希望本期博客能给各位老铁们带来帮助和收获。

一、Bean的生命周期简介

1. 什么是Bean的生命周期

所谓 Bean 的生命周期，就是一个 Bean 从创建到销毁，所经历的各种方法调用。

简单的来说，一个Bean的生命周期分为四个阶段：

实例化(Instantiation)

属性设置(populate)

初始化(Initialization)

销毁(Destruction)

2. Bean生命周期的流程步骤（四个阶段讲解）

2.1 实例化

通过XML、Java annotation（注解）以及Java Configuration（配置类）等方式加载Spring Bean。程序启动后，Spring把注解或者配置文件定义好的Bean对象转换成一个BeanDefination对象，然后完成整个BeanDefination的解析和加载的过程。Spring获取到这些完整的对象之后，会对整个BeanDefination进行实例化操作，实例化是通过反射的方式创建对象。

2.2 属性设置

实例化后的对象被封装在BeanWrapper对象中，并且此时对象仍然是一个原生的状态，并没有进行依赖注入。Spring根据BeanDefinition中的信息进行依赖注入, populateBean方法来完成属性的注入。

2.3 初始化

1、调用Aware接口相关的方法：invokeAwareMethod(完成beanName, beanClassLoader, beanFactory对象的属性设置)

2、调用beanPostProcessor中的前置处理方法（applyBeanPostProcessorsBeforeInitialization）

3、调用InitMethod方法：invokeInitMethod(),判断是否实现了initializingBean接口，如果有，调用afterPropertiesSet方法，没有就不调用

4、调用BeanPostProcessor后置处理方法（applyBeanPostProcessorsAfterInitialization），Spring 的Aop就是在此处实现的

2.4 销毁

判断是否实现了DisposableBean接口，调用destoryMethod方法

3. Bean生命周期的大致图解

4. Bean生命周期的方法流程图解（详情图解）

5. Bean生命周期的细节说明

BeanDefinitionReader：解析Bean的定义。在Spring容器启动过程中，会将Bean解析成Spring内部的BeanDefinition结构(将spring.xml中的<bean>标签转换成BeanDefinition结构

有点类似于XML解析)。

BeanDefinition：包含了很多属性和方法。例如：id、class（类名）、scope、ref（依赖的bean）等等。其实就是将bean（例如<bean>）的定义信息存储到这个对应BeanDefinition相应的属性中

例如：<bean id="" class="" scope=""> -----> BeanDefinition(id/class/scope)

BeanFactoryPostProcessor：是Spring容器功能的扩展接口。

注意事项：

BeanFactoryPostProcessor在spring容器加载完BeanDefinition之后，在bean实例化之前执行的。

对bean元数据（BeanDefinition）进行加工处理，也就是BeanDefinition属性填充、修改等操作。

BeanFactory：Bean工厂。它按照我们的要求生产我们需要的各种各样的bean

例如下面这串代码：

BeanFactory -> List<BeanDefinition>
BeanDefinition(id/class/scope/init-method)
<bean class="com.zking.spring02.biz.BookBizImpl"/>
foreach(BeanDefinition bean : List<BeanDefinition>){
   //根据class属性反射机制实例化对象
   //反射赋值设置属性
}

Aware感知接口：在实际开发中，经常需要用到Spring容器本身的功能资源。

例如：BeanNameAware、ApplicationContextAware等等。（BeanDefinition 实现了 BeanNameAware、ApplicationContextAware）

BeanPostProcessor：后置处理器。

作用：在Bean对象实例化和引入注入完毕后，在显示调用初始化方法的前后添加自定义的逻辑。（类似于AOP的绕环通知）

前提条件：如果检测到Bean对象实现了BeanPostProcessor后置处理器才会执行Before和After方法。

顺序：

1）Before

2）调用初始化Bean（InitializingBean和init-method，Bean的初始化才算完成）

3）After

因此完成了Bean的创建工作。

destory：销毁。

二、Bean的的单例与多例模式

1. 概述

单例：

在单例模式下，Spring容器只会创建一个Bean的实例，并在整个应用程序中共享这个实例。也就是说，每次获取该Bean时，都会返回同一个实例对象。默认情况下，Spring中的Bean是单例的。

多例：

在多例模式下，每次请求获取 Bean 都会创建一个新的实例，每个实例都是独立的。也就是说，每次都会返回一个新的实例对象。

2. 二者的区别

实例的创建和管理方式：单例只会创建一个Bean的实例，每次获取该Bean时都会返回同一个实例对象；多例每次请求获取 Bean 都会创建一个新的实例，每次都会返回一个新的实例对象。

对象的共享与独立性：单例在整个应用程序中只有一个实例对象。当多个地方依赖同一个单例Bean时，它们获取到的都是同一个对象实例。多例的Bean实例是独立的，每次获取Bean时都会得到一个新的实例对象。不同地方依赖多例Bean时，它们获取到的实例对象是独立的。

对资源的消耗：单例能够节省资源；多例可能会导致资源的过度消耗。

3. 二者优缺点

单例的优点是节约内存节约资源，弊端是有变量污染。

多例的优点是无变量污染，弊端是极其消耗内存和资源。

4. 案例论证

案例文件配置

pom.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>yx_spring</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>yx_spring Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  <properties>
    <spring.version>5.0.1.RELEASE</spring.version>
    <javax.servlet.version>4.0.0</javax.servlet.version>
    <junit.version>4.12</junit.version>
  </properties>
  <dependencies>
<!--    <dependency>-->
<!--      <groupId>junit</groupId>-->
<!--      <artifactId>junit</artifactId>-->
<!--      <version>3.8.1</version>-->
<!--      <scope>test</scope>-->
<!--    </dependency>-->
    <!-- 2、导入spring依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- 5.1、junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
<!--      <scope>test</scope>-->
    </dependency>
    <!-- 5.2、servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${javax.servlet.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.jetbrains</groupId>
      <artifactId>annotations-java5</artifactId>
      <version>RELEASE</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>yx_spring</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

将之前的junit注释掉方便后续测试类代码的测试。

ParamAction类代码

package com.yx.AOP.beanlife;
import java.util.List;
public class ParamAction {
  private int age;
  private String name;
  private List<String> hobby;
  private int num = 1;//初始值
  // private UserBiz userBiz = new UserBizImpl1();
  public ParamAction() {
    super();
  }
  public ParamAction(int age, String name, List<String> hobby) {
    super();
    this.age = age;
    this.name = name;
    this.hobby = hobby;
  }
  public void execute() {
    // userBiz.upload();
    // userBiz = new UserBizImpl2();
    System.out.println("this.num=" + this.num++);
    System.out.println(this.name);
    System.out.println(this.age);
    System.out.println(this.hobby);
  }
}

Spring-context.xml文件配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 <!--_______________________________________________________________________________________________________________-->
<!--    spring的bean的生命周期-->
    <bean class="com.yx.AOP.beanlife.ParamAction" id="paramAction">
        <constructor-arg name="name" value="三丰"></constructor-arg>
        <constructor-arg name="age" value="21"></constructor-arg>
        <constructor-arg name="hobby">
            <list>
                <value>抽烟</value>
                <value>烫头</value>
                <value>大保健</value>
            </list>
        </constructor-arg>
    </bean>
    <bean id="instanceFactory" class="com.yx.AOP.beanlife.InstanceFactory"
          scope="prototype" init-method="init" destroy-method="destroy"></bean>
</beans>

Spring默认是单例模式，但可以根据自身的需求修改为多例模式。

测试类Demo2

package com.yx.AOP.beanlife;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
/*
 * spring bean的生命週期
 * spring bean的單例多例
 */
public class Demo2 {
  // 体现单例与多例的区别
  @Test
  public void test1() {
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
//    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
    ParamAction p1 = (ParamAction) applicationContext.getBean("paramAction");
    ParamAction p2 = (ParamAction) applicationContext.getBean("paramAction");
    // System.out.println(p1==p2);
    p1.execute();
    p2.execute();
//    单例时，容器销毁instanceFactory对象也销毁；多例时，容器销毁对象不一定销毁；
    applicationContext.close();
  }
  // 体现单例与多例的初始化的时间点 instanceFactory
  @Test
  public void test2() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
  }
  // BeanFactory会初始化bean对象，但会根据不同的实现子类采取不同的初始化方式
  // 默认情况下bean的初始化，单例模式立马会执行，但是此时XmlBeanFactory作为子类，单例模式下容器创建，bean依赖没有初始化，只有要获取使用bean对象才进行初始化
  @Test
  public void test3() {
    // ClassPathXmlApplicationContext applicationContext = new
    // ClassPathXmlApplicationContext("/spring-context.xml");
    Resource resource = new ClassPathResource("/spring-context.xml");
    BeanFactory beanFactory = new XmlBeanFactory(resource);
//    InstanceFactory i1 = (InstanceFactory) beanFactory.getBean("instanceFactory");
  }
}

单例模式测试

直接运行Demo2代码中的test1()的方法。控制输出结果如下图

如上图所示，这是变量污染的表现，因为在Demo2代码的test1()的方法中实例化了两个对象，因为只有一个对象，所以实例化两个对象，在第二个对象时同时实例化了同一个对象，因此this.num再次调用对象时自动加+1。

多例模式测试

当然我们也可以设置调整为多例模式，调整Spring-context.xml的部分代码即可。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--_______________________________________________________________________________________________________________-->
<!--    spring的bean的生命周期-->
<!--    prototype:多例模式  singleton:单例  -->
    <bean class="com.yx.AOP.beanlife.ParamAction" id="paramAction" scope="prototype">
        <constructor-arg name="name" value="三丰"></constructor-arg>
        <constructor-arg name="age" value="21"></constructor-arg>
        <constructor-arg name="hobby">
            <list>
                <value>抽烟</value>
                <value>烫头</value>
                <value>大保健</value>
            </list>
        </constructor-arg>
    </bean>
    <bean id="instanceFactory" class="com.yx.AOP.beanlife.InstanceFactory"
          scope="prototype" init-method="init" destroy-method="destroy"></bean>
</beans>

再次测试Demo2的test1()方法，控制台输出结果如图下

由此可见this.num=1,没有变量污染的现象出现。

5. 结论

单例：JavaBean是跟着Spring上下文初始化的，容器生对象生，容器死对象死。

多例：JavaBean使用的时候才会创建，销毁跟着jvm走。

注：以上的结论不一定绝对正确。

三、涉及的面试题

1. Spring容器管理JavaBean的初始化过程（Spring中Bean的生命周期）

答：

.xml（Spring）/annotation（SpringMVC）/configuation（SpringBoot）配置JavaBean——（service,impl实体类）（在上述三种方式中选择一种进行配置）

BeanDefinitionReader（bean标签）解析配置的javaBean得到BeanDefinition，最终得到一个集合List<BeanDefinition>（建模的过程）。

触发一个BeanFactoryPostProcessor,在javabean初始化之前执行自己的业务。

Spring中BeanFactory会通过List<BeanDefinition>集合遍历初始化所有的javabean对象。

如果自己的javabean需要调动Spring上下文中的资源，那么需要实现Aware感知接口。

如果自己的javabean已经初始化好了，还需要扩展功能，那么需要借助BeanPostProcessor类来实现。

感谢老铁们的阅读与支持，希望老铁能够三连一波，这无疑是对我最大的支持。请敬请期待下期博客的分享，我们下期再见。

Spring之Bean的生命周期

前言

一、Bean的生命周期简介

1. 什么是Bean的生命周期

2. Bean生命周期的流程步骤（四个阶段讲解）

2.1 实例化

2.2 属性设置

2.3 初始化

2.4 销毁

3. Bean生命周期的大致图解

4. Bean生命周期的方法流程图解（详情图解）

5. Bean生命周期的细节说明

二、Bean的的单例与多例模式

1. 概述

单例：

多例：

2. 二者的区别

3. 二者优缺点

4. 案例论证

案例文件配置

pom.xml配置

ParamAction类代码

Spring-context.xml文件配置

测试类Demo2

单例模式测试

多例模式测试

5. 结论

单例：JavaBean是跟着Spring上下文初始化的，容器生对象生，容器死对象死。

多例：JavaBean使用的时候才会创建，销毁跟着jvm走。

三、涉及的面试题

1. Spring容器管理JavaBean的初始化过程（Spring中Bean的生命周期）

热门文章

最新文章

相关课程

相关电子书

相关实验场景