【Spring】Bean 的生命周期

一、Bean 的生命周期

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

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

• 什么时候创建 Bean 对象？
• 创建 Bean 对象的前后会调用什么方法？
• Bean 对象什么时候销毁？
• Bean 对象的销毁前后调用什么方法？

 

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

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

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

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

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

 

二、Bean 生命周期之 5 步

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

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

• 第一步：实例化Bean

• 第二步：Bean属性赋值

• 第三步：初始化Bean

• 第四步：使用Bean

• 第五步：销毁Bean

package org.qiu.spring.bean;

/**
 * Bean 的生命周期（粗略的五步）：
 * 第一步：实例化 Bean（调用无参数构造方法）
 * 第二步：Bean 属性赋值（调用 setter 方法）
 * 第三步：初始化 Bean（调用 Bean 的 init 方法，这个 init 方法需要自己写，自己配）
 * 第四步：使用 Bean
 * 第五步：销毁 Bean（调用 Bean 的 destroy 方法，这个 destroy 方法需要自己写，自己配）
 *
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.spring.bean
 * @date 2022-11-11-10:45
 * @since 1.0
 */
public class User {
    private String name;

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

    public User() {
        System.out.println("第一步：无参数构造方法执行");
    }

    public void initBean(){
        System.out.println("第三步：初始化 Bean");
    }

    public void destroyBean(){
        System.out.println("第五步：销毁 Bean");
    }
}

<!-- 需要手动指定初始化方法和销毁方法 -->
<bean id="user" class="org.qiu.spring.bean.User" init-method="initBean" destroy-method="destroyBean">
    <property name="name" value="张三"/>
</bean>

@Test
public void testBeanLifecycleFive(){
    ApplicationContext application = new ClassPathXmlApplicationContext("spring.xml");
    User user = application.getBean("user", User.class);
    System.out.println("第四步：使用 Bean：" + user);

    // 必须手动关闭 Spring 容器，这样 Spring 容器才会销毁 Bean
    ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) application;
    context.close();
}

运行结果： 

需要注意的：

• 第一：只有正常关闭 Spring 容器，bean 的销毁方法才会被调用

• 第二：ClassPathXmlApplicationContext 类才有 close() 方法

• 第三：配置文件中的 init-method 指定初始化方法。destroy-method 指定销毁方法

 

三、Bean 生命周期之 7 步 

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

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

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

package org.qiu.spring.bean;

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

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.spring.bean
 * @date 2022-11-11-11:11
 * @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;
    }

    /**
     * @param bean          刚创建的 Bean 对象
     * @param beanName      Bean 的名字
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第五步：Bean后处理器的after方法执行，已完成初始化");
        return bean;
    }
}

<!-- 配置 Bean 后处理器：作用于整个配置文件中所有的 Bean -->
<bean class="org.qiu.spring.bean.LogBeanPostProcessor"/>

@Test
public void testBeanLifecycleFive(){
    ApplicationContext application = new ClassPathXmlApplicationContext("spring.xml");
    User user = application.getBean("user", User.class);
    System.out.println("第六步：使用 Bean：" + user);

    // 必须手动关闭 Spring 容器，这样 Spring 容器才会销毁 Bean
    ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) application;
    context.close();
}

 运行结果：

 

四、 Bean 生命周期之 7 步

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

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

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

• 当 Bean 实现了 BeanNameAware，Spring 会将 Bean的名字传递给 Bean

• 当 Bean 实现了 BeanClassLoaderAware，Spring 会将加载该 Bean的类加载器传递给 Bean

• 当 Bean 实现了 BeanFactoryAware，Spring 会将 Bean工厂对象传递给 Bean

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

• BeanNameAware

• BeanClassLoaderAware

• BeanFactoryAware

• InitializingBean

• DisposableBean

 

package org.qiu.spring.bean;

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

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.spring.bean
 * @date 2022-11-11-10:45
 * @since 1.0
 */
public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
    private String name;

    public User() {
        System.out.println("第一步：无参数构造方法执行");
    }

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

    public void initBean(){
        System.out.println("第六步：初始化 Bean");
    }

    public void destroyBean(){
        System.out.println("第十步：销毁 Bean");
    }

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

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

    @Override
    public void setBeanName(String name) {
        System.out.println("第三步：Bean名字" + name);
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("第九步：DisposableBean destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("第五步：afterPropertiesSet执行");
    }
}

package org.qiu.spring.bean;

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

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.spring.bean
 * @date 2022-11-11-11:11
 * @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;
    }

    /**
     * @param bean          刚创建的 Bean 对象
     * @param beanName      Bean 的名字
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第七步：Bean后处理器的after方法执行，已完成初始化");
        return bean;
    }
}

@Test
public void testBeanLifecycleFive(){
    ApplicationContext application = new ClassPathXmlApplicationContext("spring.xml");
    User user = application.getBean("user", User.class);
    System.out.println("第八步：使用 Bean：" + user);

    // 必须手动关闭 Spring 容器，这样 Spring 容器才会销毁 Bean
    ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) application;
    context.close();
}

运行结果： 

通过测试可以看出来：

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

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

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

 

---

Bean 生命周期五步：

1、实例化 Bean

2、给 Bean 的属性赋值

3、初始化 Bean

4、使用 Bean

5、销毁 Bean

---

Bean 生命周期七步：

1、实例化 Bean

2、给 Bean 的属性赋值

3、执行“Bean后处理器”的 before 方法

4、初始化 Bean

5、执行“Bean后处理器”的 after 方法

6、使用 Bean

7、销毁 Bean

---

Bean 声明周期十步：

1、实例化 Bean

2、给 Bean 的属性赋值

3、点位一

4、执行“Bean后处理器”的 before 方法

5、点位二

6、初始化 Bean

7、执行“Bean后处理器”的 after 方法

8、使用 Bean

9、点位三

10、销毁 Bean

​

---

​

点位1：检查Bean是否实现了Aware相关的接口，如果实现了接口则调用执行接口中的方法

点位2：检查Bean是否实现了InitializingBean接口，如果实现了，则调用接口中的方法

点位3：检查Bean是否实现了DisposableBean接口，如果实现了，则调用接口中的方法

的是为了给你专递一些数据，让你更加方便使用

添加这三个点位的特点：

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

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

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

• 对于 singleton 作用域的 Bean，Spring 能够精确地知道该 Bean 何时被创建，何时初始化完成，以及何时被销毁；

• 而对于 prototype 作用域的 Bean，Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期

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

<!-- 需要手动指定初始化方法和销毁方法 -->
<bean id="user" class="org.qiu.spring.bean.User" init-method="initBean" destroy-method="destroyBean" scope="prototype">
    <property name="name" value="张三"/>
</bean>

执行测试程序：  

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

 

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

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

package org.qiu.spring.bean;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.spring.bean
 * @date 2022-11-11-10:45
 * @since 1.0
 */
public class User(){
}

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

执行结果： 

 

一  叶  知  秋，奥  妙  玄  心