• （八）Bean的生命周期

    文章目录


    上一篇：（七）Bean的实例化方式
    下一篇：（九）Spring之Bean的循环依赖问题

    环境

    spring6里程碑版本的仓库
    依赖：spring context依赖、junit依赖、log4j2依赖
    log4j2.xml文件放到类路径下。

    什么是Bean的生命周期

    Spring其实就是一个管理Bean对象的工厂。它负责对象的创建，对象的销毁等。
    所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。
    Bean生命周期的管理，可以参考Spring的源码：AbstractAutowireCapableBeanFactory类的doCreateBean()方法。

    为什么要知道Bean的生命周期

    其实生命周期的本质是：在哪个时间节点上调用了哪个类的哪个方法。
    我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点。
    只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。
    我们可能需要在某个特殊的时间点上执行一段特定的代码，这段代码就可以放到这个节点上。当生命线走到这里的时候，自然会被调用。

    Bean生命周期之5步

    Bean生命周期之五大步：

    • 第一步：实例化Bean (调用无参数构造方法)
    • 第二步：Bean属性赋值 （调用set）
    • 第三步：初始化Bean （调用Bean的初始化方法）
    • 第四步：使用Bean
    • 第五步：销毁Bean （调用Bean的销毁方法）

    定义一个Bean：SpringBean5类
    初始化方法和销毁方法需要自己定义。

    public class SpringBean5 {
    private String name;

    public void setName(String name) {
        System.out.println("第二步：Bean属性赋值。");
        this.name = name;
    }

    public SpringBean5() {
        System.out.println("第一步：实例化Bean。");
    }

    public void init(){
        //这个方法需要自己写自己配，不一定是这个方法名，方法名随意。
        System.out.println("第三步：初始化Bean。");
    }

    public void destroy(){
        //这个方法也需要自己写自己配，不一定是这个方法名，方法名随意。
        System.out.println("第五步：销毁Bean。");
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    创建spring5.xml配置：
    需要在配置文件配置通过init-method属性配置初始化方法，通过destroy-method属性配置销毁方法

    	<bean id="springBean5" class="com.bean.lifecycle.bean.SpringBean5" init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="张三"/>
    </bean>

    • 1
    • 2
    • 3

    测试程序：

        @Test
    public void testBeanLifecycle5(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring5.xml");
        SpringBean5 springBean5 = applicationContext.getBean("springBean5", SpringBean5.class);
        System.out.println("第四步：使用Bean：" + springBean5);
        //必须手动关闭Spring容器，注意Spring容器才会销毁Bean
        //applicationContext没有close这个方法，这个方法在ClassPathXmlApplicationContext里面，需要进行转型
        ((ClassPathXmlApplicationContext) applicationContext).close();
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    请添加图片描述

    Bean生命周期之7步

    Bean生命周期之七大步：比五步在初始化Bean的前和后多两步

    • 第一步：实例化Bean (调用无参数构造方法)
    • 第二步：Bean属性赋值 （调用set）
    • 第三步：执行“Bean后处理器”的before方法。
    • 第四步：初始化Bean （调用Bean的初始化方法）
    • 第五步：执行“Bean后处理器”的after方法。
    • 第六步：使用Bean
    • 第七步：销毁Bean （调用Bean的销毁方法）

    定义一个Bean：SpringBean7类

    public class SpringBean7 {
    private String name;

    public void setName(String name) {
        System.out.println("第二步：Bean属性赋值。");
        this.name = name;
    }

    public SpringBean7() {
        System.out.println("第一步：实例化Bean。");
    }

    public void init(){
        //这个方法需要自己写自己配，不一定是这个方法名，方法名随意。
        System.out.println("第四步：初始化Bean。");
    }

    public void destroy(){
        //这个方法也需要自己写自己配，不一定是这个方法名，方法名随意。
        System.out.println("第七步：销毁Bean。");
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    要想实现“Bean后处理器”，需要实现BeanPostProcessor接口，并且重写before和after方法
    接口如下：
    这两个方法都是默认方法，都有两个参数，并且默认都返回bean

    • bean参数：bean对象
    • beanName参数：bean的名字
    public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    创建一个SpringBeanPostProcessor类实现该接口：

    public class SpringBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第三步：执行Bean后处理器的before方法。");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第五步：执行Bean后处理器的after方法。");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    创建spring7.xml配置：
    需要配置Bean后处理器，这个配置将作用于当前整个配置文件种所有的Bean。

    	<bean id="springBean7" class="com.bean.lifecycle.bean.SpringBean7" init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="张三"/>
    </bean>
    <bean class="com.bean.lifecycle.bean.SpringBeanPostProcessor"/>

    • 1
    • 2
    • 3
    • 4

    测试程序：

        @Test
    public void testBeanLifecycle7(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring7.xml");
        SpringBean7 springBean7 = applicationContext.getBean("springBean7", SpringBean7.class);
        System.out.println("第六步：使用Bean：" + springBean7);
        //必须手动关闭Spring容器，注意Spring容器才会销毁Bean
        //applicationContext没有close这个方法，这个方法在ClassPathXmlApplicationContext里面，需要进行转型
        ((ClassPathXmlApplicationContext) applicationContext).close();
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    请添加图片描述

    Bean生命周期之10步

    Bean生命周期之十大步：多了三个点位

    • 第一步：实例化Bean (调用无参数构造方法)
    • 第二步：Bean属性赋值 （调用set）
    • 点位1：检查Bean是否实现Aware相关接口，并调用接口中的方法。
    • 第三步：执行“Bean后处理器”的before方法。
    • 点位2：检查Bean是否实现InitializingBean接口，并调用接口中的方法
    • 第四步：初始化Bean （调用Bean的初始化方法）
    • 第五步：执行“Bean后处理器”的after方法。
    • 第六步：使用Bean
    • 点位3：检查Bean是否实现DisposableBean，并调用接口中的方法
    • 第七步：销毁Bean （调用Bean的销毁方法）

    三个点位详解：

    这三个点位的特点：都是在检查你这个Bean是否实现了某些特定的接口，如果实现了这些接口，则Spring容器会调用这个接口中的方法。

    点位1

    点位1：在“Bean后处理器”before方法之前
    检查Bean是否实现了Aware相关的接口，如果实现了接口则调用这些接口中的方法。
    然后调用这些方法的目的是为了给你传递一些数据，让你更加方便使用。
    Aware相关的接口包括：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware

    • 当Bean实现了BeanNameAware，Spring会将Bean的名字传递给setBeanName方法，并调用。
    public interface BeanNameAware extends Aware {
    void setBeanName(String var1);
}

    • 1
    • 2
    • 3
    • 当Bean实现了BeanClassLoaderAware，Spring会将加载该Bean的类加载器传递给setBeanClassLoader方法，并调用。
    public interface BeanClassLoaderAware extends Aware {
    void setBeanClassLoader(ClassLoader var1);
}


    • 1
    • 2
    • 3
    • 4
    • 当Bean实现了BeanFactoryAware，Spring会将Bean工厂对象传递给setBeanFactory方法，并调用。
    public interface BeanFactoryAware extends Aware {
    void setBeanFactory(BeanFactory var1) throws BeansException;
}

    • 1
    • 2
    • 3

    点位2

    点位2：在“Bean后处理器”before方法之后
    检查Bean是否实现了InitializingBean接口，如果实现了，则调用接口中的方法。

    public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

    • 1
    • 2
    • 3

    点位3

    点位3：使用Bean之后，或者说销毁Bean之前
    检查Bean是否实现了DisposableBean接口，如果实现了，则调用接口中的方法。

    public interface DisposableBean {
    void destroy() throws Exception;
}

    • 1
    • 2
    • 3

    演示程序

    定义一个Bean，分别实现这些接口：SpringBean10类

    public class SpringBean10 implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware,InitializingBean,DisposableBean {
    private String name;

    public void setName(String name) {
        System.out.println("第二步：Bean属性赋值。");
        this.name = name;
    }

    public SpringBean10() {
        System.out.println("第一步：实例化Bean。");
    }

    public void initBean(){
        //这个方法需要自己写自己配，不一定是这个方法名，方法名随意。
        System.out.println("第四步：初始化Bean。");
    }

    public void destroyBean(){
        //这个方法也需要自己写自己配，不一定是这个方法名，方法名随意。
        System.out.println("第七步：销毁Bean。");
    }
    /*
        setBeanClassLoader对应：BeanClassLoaderAware接口
        setBeanFactory对应：BeanFactoryAware
        setBeanName对应：BeanNameAware
        afterPropertiesSet对应：InitializingBean
        我们自己写的方法destroy与DisposableBean接口的方法重了，所以我们把我们销毁方法改为destroyBean
     */
    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("点位1：Bean的类加载器是：" + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("点位1：生产Bean的工厂对象是：" + beanFactory);
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("点位1：Bean的名字是：" + s);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("点位2：InitializingBean接口的afterPropertiesSet方法执行");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("点位3：DisposableBean接口的destroy方法执行");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54

    Bean后处理器还是使用之前的SpringBeanPostProcessor
    创建spring10.xml配置：

    	<bean id="springBean10" class="com.bean.lifecycle.bean.SpringBean10"
          init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="张三"/>
    </bean>
    <bean class="com.bean.lifecycle.bean.SpringBeanPostProcessor"/>

    • 1
    • 2
    • 3
    • 4
    • 5

    测试程序：

        @Test
    public void testBeanLifecycle10(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring10.xml");
        SpringBean10 springBean10 = applicationContext.getBean("springBean10", SpringBean10.class);
        System.out.println("第六步：使用Bean：" + springBean10);
        //必须手动关闭Spring容器，注意Spring容器才会销毁Bean
        //applicationContext没有close这个方法，这个方法在ClassPathXmlApplicationContext里面，需要进行转型
        ((ClassPathXmlApplicationContext) applicationContext).close();
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    请添加图片描述

    Bean的作用域不同，管理方式不同

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

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

    演示程序使用之前的Bean生命周期10步，只需要把Bean改成多例的即可，spring10配置：

    	<bean id="springBean10" class="com.bean.lifecycle.bean.SpringBean10"
          init-method="initBean" destroy-method="destroyBean" scope="prototype">
        <property name="name" value="张三"/>
    </bean>

    • 1
    • 2
    • 3
    • 4

    再次运行程序：
    请添加图片描述
    只管理到了使用Bean

    自己new的对象如何让Spring管理

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

    两个步骤：

    • 步骤一：创建默认可列表BeanFactory对象
    • 步骤二：调用相关方法把自己new的对象注册进去

    创建一个Bean：Student类

    public class Student {
}


    • 1
    • 2
    • 3

    测试程序：

        @Test
    public void testRsgisterBean(){
        //自己new的对象
        Student student = new Student();
        System.out.println(student);
        //将自己new的对象纳入Spring容器进行管理
        //首先创建默认可列表BeanFactory对象
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        //然后调用相关方法把对象注册进去
        factory.registerSingleton("studentBean",student);

        //从Spring容器中获取
        Object studentBean = factory.getBean("studentBean");
        System.out.println(studentBean);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    在这里插入图片描述

  • 相关阅读:
    数字时代古文的传承———云南文化瑰宝“爨文化“(我为家乡发声)
    Java版本spring cloud + spring boot企业电子招投标系统源代码
    C/C++ 进阶（4）二叉搜索树
    【图神经网络学习笔记系列】01-Graph Attention Networks 学习笔记
    您真的了解Java中的锁吗？这7种不同维度下的锁知道吗？
    小程序AI智能名片商城系统直连：打造用户与企业无缝对接的新时代！
    JavaCV的摄像头实战之十三：年龄检测
    你真的懂Java怎么输出Hello World吗？
    偏向锁理论太抽象，实战了解下偏向锁如何发生以及如何升级【实战篇】
    STM32CubeMX上手初体验
  • 原文地址：https://blog.csdn.net/weixin_45832694/article/details/127920325