Spring学习记录之Bean的生命周期

Spring学习记录之Bean的生命周期

前言

这篇文章是我第二次学习b站老杜的spring相关课程所进行的学习记录，算是对课程内容及笔记的二次整理，以自己的理解方式进行二次记录，其中理解可能存在错误，欢迎且接受各位大佬们的批评指正；

关于本笔记，只是我对于相关知识遗忘时快速查阅了解使用，至于课程中实际实验配置等，也只是记录关键，并不会记录详细步骤，若想了解可以关注我博客的项目经验模块，我会在实际项目开发过程中总结项目经验，在该模块发布！

学习视频地址：https://www.bilibili.com/video/BV1Ft4y1g7Fb/

视频配套笔记：https://www.yuque.com/dujubin/ltckqu/kipzgd?singleDoc# 《Spring6》 密码：mg9b

目录

目录

一、我个人对这部分学习的一些见解

这部分是常见Spring面试题，所以还是需要大家熟悉。在实际开发中至少我现阶段接触的项目业务考虑Bean生命周期的情况较少。学习建议：至少需要熟知Bean的生命周期五步，熟悉七步，了解十步。

二、Bean的生命周期

问题一：什么是Bean的生命周期

Spring其实就是一个管理Bean对象的工厂。它负责对象的创建，对象的销毁等。

所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。

即简略概述如下：

什么时候创建Bean对象？

创建Bean对象的前后会调用什么方法？

Bean对象什么时候销毁？

Bean对象的销毁前后调用什么方法？

问题二：为什么要知道Bean的生命周期

其实生命周期的本质是：在哪个时间节点上调用了哪个类的哪个方法。

我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点。

只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。

我们可能需要在某个特殊的时间点上执行一段特定的代码，这段代码就可以放到这个节点上。当生命线走到这里的时候，自然会被调用。

① Bean的生命周期五步

Bean生命周期的管理，可以参考Spring的源码：AbstractAutowireCapableBeanFactory类的doCreateBean()方法。

Bean生命周期可以粗略的划分为五大步：

  • 第一步：实例化Bean（即调用Bean的无参构造或其他实例化方法创建Bean对象，但此时对象的属性均未赋值）
  • 第二步：Bean属性赋值（即调用对象属性相应的set方法或构造方法等给属性赋值）
  • 第三步：初始化Bean（即在使用该Bean之前可以调用该Bean的某个方法，做一些使用前的初始化处理）
  • 第四步：使用Bean（即开始使用Bean）
  • 第五步：销毁Bean（即在Bean销毁时调用该Bean的相应方法做销毁Bean处理）

img

编写测试程序：

定义一个Bean

User

package com.powernode.spring6.bean;

/**
 * @author 动力节点
 * @version 1.0
 * @className User
 * @since 1.0
 **/
public class User {
    private String name;

    public User() {
        System.out.println("1.实例化Bean");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("2.Bean属性赋值");
    }

    public void initBean(){
        System.out.println("3.初始化Bean");
    }

    public void destroyBean(){
        System.out.println("5.销毁Bean");
    }

}

spring.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">

    <!--
    init-method属性指定初始化方法。
    destroy-method属性指定销毁方法。
    -->
    <bean id="userBean" class="com.powernode.spring6.bean.User" init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="zhangsan"/>
    </bean>

</beans>

测试程序：

package com.powernode.spring6.test;

import com.powernode.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 动力节点
 * @version 1.0
 * @className BeanLifecycleTest
 * @since 1.0
 **/
public class BeanLifecycleTest {
    @Test
    public void testLifecycle(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User userBean = applicationContext.getBean("userBean", User.class);
        System.out.println("4.使用Bean");
        // 只有正常关闭spring容器才会执行销毁方法
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
        context.close();
    }
}

执行结果：

img

需要注意的：

  • 第一：只有正常关闭spring容器，bean的销毁方法才会被调用。
  • 第二：ClassPathXmlApplicationContext类才有close()方法。
  • 第三：配置文件中的init-method指定使用Bean前（初始化）执行的方法。destroy-method指定销毁时执行的方法。

② Bean的生命周期七步

在以上的5步中，第3步是初始化Bean，如果你还想在初始化前和初始化后添加代码，可以加入“Bean后处理器”。

编写一个类实现BeanPostProcessor类，并且重写before和after方法：

LogBeanPostProcessor

package com.powernode.spring6.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * @author 动力节点
 * @version 1.0
 * @className LogBeanPostProcessor
 * @since 1.0
 **/
public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Bean后处理器的before方法执行，即将开始初始化");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Bean后处理器的after方法执行，已完成初始化");
        return bean;
    }
}

在spring.xml文件中配置“Bean后处理器”：

spring.xml

<!--配置Bean后处理器。这个后处理器将作用于当前配置文件中所有的bean。-->
<bean class="com.powernode.spring6.bean.LogBeanPostProcessor"/>

注意：“Bean后处理器”的作用范围是当前配置文件中的所有的Bean，即当前配置文件中所有的Bean在执行初始化方法的前后都会分别执行postProcessBeforeInitialization和postProcessAfterInitialization方法。

有同学问，如果我想只对一个Bean的初始化前后执行处理方法呢？其实最简单的思路就是把你要写的所谓初始化方法前后执行的处理逻辑都写到初始化方法里即可；

执行测试程序：

img

如果加上Bean后处理器的话，Bean的生命周期就是7步了：

img

③ Bean的生命周期十步

学前补充：其实新增的三步就是多给了一些执行代码的时机。

如果根据源码跟踪，可以划分更细粒度的步骤，10步：

img

上图中检查Bean是否实现了Aware的相关接口是什么意思？

Aware相关的接口包括：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware

  • 当Bean实现了BeanNameAware，Spring会将Bean的名字传递给Bean。
  • 当Bean实现了BeanClassLoaderAware，Spring会将加载该Bean的类加载器传递给Bean。
  • 当Bean实现了BeanFactoryAware，Spring会将Bean工厂对象传递给Bean。

Aware的相关接口其实就是在初始化Bean之前给该Bean提供一些自身的信息，方便自身初始化Bean使用。

测试以上10步，可以让User类实现5个接口，并实现所有方法：

  • BeanNameAware
  • BeanClassLoaderAware
  • BeanFactoryAware
  • InitializingBean
  • DisposableBean

代码如下：

User

package com.powernode.spring6.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

/**
 * @author 动力节点
 * @version 1.0
 * @className User
 * @since 1.0
 **/
public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
    private String name;

    public User() {
        System.out.println("1.实例化Bean");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("2.Bean属性赋值");
    }

    public void initBean(){
        System.out.println("6.初始化Bean");
    }

    public void destroyBean(){
        System.out.println("10.销毁Bean");
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("3.类加载器：" + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("3.Bean工厂：" + beanFactory);
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("3.bean名字：" + name);
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("9.DisposableBean destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5.afterPropertiesSet执行");
    }
}

LogBeanPostProcessor

package com.powernode.spring6.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * @author 动力节点
 * @version 1.0
 * @className LogBeanPostProcessor
 * @since 1.0
 **/
public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("4.Bean后处理器的before方法执行，即将开始初始化");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("7.Bean后处理器的after方法执行，已完成初始化");
        return bean;
    }
}

执行结果：

img

通过测试可以看出来：

  • InitializingBean的方法早于init-method的执行。
  • DisposableBean的方法早于destroy-method的执行。

对于SpringBean的生命周期，掌握之前的7步即可。够用。

三、Bean的不同作用域与生命周期管理方式

上述我们讲到的Bean的生命周期流程都是针对于被Spring管理的单例Bean。

Spring根据Bean的作用域来选择管理方式。

  • 对于singleton（单例）作用域的Bean，Spring能够精确地知道该Bean何时被创建，何时初始化完成，以及何时被销毁（所以有以上十步）；
  • 而对于prototype（多例）作用域的Bean，Spring只负责创建，当容器创建了Bean 的实例后，Bean的实例就交给客户端代码管理，Spring容器将不再跟踪其生命周期。

补充理解：如果Bean是多例，Spring只管理到使用该Bean，即初始化Bean完成。销毁等操作都由客户自己去做。

我们把之前User类的spring.xml文件中的配置scope设置为prototype：

spring.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">

    <!--
    init-method属性指定初始化方法。
    destroy-method属性指定销毁方法。
    -->
    <bean id="userBean" class="com.powernode.spring6.bean.User" init-method="initBean" destroy-method="destroyBean" scope="prototype">
        <property name="name" value="zhangsan"/>
    </bean>

    <!--配置Bean后处理器。这个后处理器将作用于当前配置文件中所有的bean。-->
    <bean class="com.powernode.spring6.bean.LogBeanPostProcessor"/>

</beans>

执行测试程序：

img

通过测试一目了然。只执行了前8步，第9和10都没有执行。

四、自己new的对象纳入Spring容器管理

有些时候可能会遇到这样的需求，某个java对象是我们自己new的，然后我们希望这个对象被Spring容器管理，怎么实现？

User

package com.powernode.spring6.bean;

/**
 * @author 动力节点
 * @version 1.0
 * @className User
 * @since 1.0
 **/
public class User {
}

package com.powernode.spring6.test;

import com.powernode.spring6.bean.User;
import org.junit.Test;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;

/**
 * @author 动力节点
 * @version 1.0
 * @className RegisterBeanTest
 * @since 1.0
 **/
public class RegisterBeanTest {

    @Test
    public void testBeanRegister(){
        // 自己new的对象
        User user = new User();
        System.out.println(user);

        // 创建 默认可列表BeanFactory 对象
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        // 注册Bean
        factory.registerSingleton("userBean", user);
        // 从spring容器中获取bean
        User userBean = factory.getBean("userBean", User.class);
        System.out.println(userBean);
    }
}

执行结果：

img

五、总结

这部分我们了解到：

  • Bean的生命周期就是对象从创建开始到最终销毁的整个过程。
  • 生命周期的本质是在哪个时间节点上调用了哪个类的哪个方法。
  • Bean的不同作用域有不同的生命周期管理方式。
  • 我们可以把自己new的对象纳入Spring容器管理

这里需要去了解老杜这节相关讲解，可以直接点击下面链接跳转到对应课程学习了解！

049-Bean的生命周期之五步_哔哩哔哩_bilibili

posted @ 2024-01-03 11:16  zhao-XH  阅读(23)  评论(0)  编辑  收藏  举报