文章目录

环境
什么是Bean的生命周期
为什么要知道Bean的生命周期
Bean生命周期之5步
Bean生命周期之7步
Bean生命周期之10步
- 三个点位详解：
- - 点位1
  - 点位2
  - 点位3
- 演示程序
Bean的作用域不同，管理方式不同
自己new的对象如何让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。");
    }

}

创建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>

测试程序：

    @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();
    }

请添加图片描述

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。");
    }

}

要想实现“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;
    }
}

创建一个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);
    }
}

创建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"/>

测试程序：

    @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();
    }

请添加图片描述

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);
}

当Bean实现了BeanClassLoaderAware，Spring会将加载该Bean的类加载器传递给setBeanClassLoader方法，并调用。

public interface BeanClassLoaderAware extends Aware {
    void setBeanClassLoader(ClassLoader var1);
}

当Bean实现了BeanFactoryAware，Spring会将Bean工厂对象传递给setBeanFactory方法，并调用。

public interface BeanFactoryAware extends Aware {
    void setBeanFactory(BeanFactory var1) throws BeansException;
}

点位2

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

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

点位3

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

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

演示程序

定义一个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方法执行");
    }
}

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"/>

测试程序：

    @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();
    }

请添加图片描述

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>

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

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

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

两个步骤：

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

创建一个Bean：Student类

public class Student {
}

测试程序：

    @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);
    }