【Spring】Bean 的生命周期

根据【动力节点】最新Spring框架教程，全网首套Spring6教程，跟老杜从零学spring入门到高级以及老杜的原版笔记 https://www.yuque.com/docs/share/866abad4-7106-45e7-afcd-245a733b073f?# 《Spring6》进行整理，文档密码：mg9b

Spring 相关文章整理汇总归纳于：https://www.yuque.com/u27599042/zuisie

什么是Bean的生命周期

Bean 的生命周期就是：对象从创建开始到最终销毁的整个过程，Bean 对象从创建到销毁中经历了哪些过程
- 什么时候创建Bean对象？
- 创建Bean对象的前后会调用什么方法？
- Bean对象什么时候销毁？
- Bean对象的销毁前后调用什么方法？
Spring其实就是一个管理Bean对象的工厂，它负责对象的创建，对象的销毁等。

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

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

Bean的生命周期之5步

Bean生命周期的管理，可以参考Spring的源码：AbstractAutowireCapableBeanFactory类的doCreateBean()方法。
Bean生命周期可以粗略的划分为五大步：
- 第一步：实例化Bean，调用无参构造方法创建对象
- 第二步：Bean属性赋值，调用对象的set方法，进行set注入
- 第三步：初始化Bean，调用Bean的init方法（该方法需要自己写，然后进行配置）
- 第四步：使用Bean
- 第五步：销毁Bean，调用Bean的Destroy方法（该方法需要自己写，然后进行配置）
  - 进行Bean的销毁，必须关闭Spring容器，只有关闭了Spring容器，Bean才会进行销毁

Bean 的编写

package cw.spring.study.pojo;

/**
 * ClassName: User
 * Package: cw.spring.study.pojo
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-26 17:21
 * @Version 1.0
 */
public class User {
    
    
    private String name;
    
    public User() {
    
    
        System.out.println("1. User 无参构造方法执行");
    }
    
    public void setName(String name) {
    
    
        this.name = name;
        System.out.println("2. User setName 方法执行");
    }
    
    public void init() {
    
    
        System.out.println("3. User init 方法执行，进行 Bean 的初始化");
    }
    
    public void destroy() {
    
    
        System.out.println("5. User destroy 方法执行，进行 Bean 的销毁");
    }
}

Bean 的配置

<!-- 
  手动指定Bean的初始化方法和销毁方法
    init-method 属性
        配置 Bean 的初始化方法
    destroy-method
        配置 Bean 的销毁方法
-->
<bean id="user" class="cw.spring.study.pojo.User" init-method="init" destroy-method="destroy">
  <property name="name" value="张三"/>
</bean>

测试

@org.junit.Test
public void testUser() {
    
    
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    User user = applicationContext.getBean("user", User.class);
    System.out.println("4. User Bean 的使用，" + user);
    // 进行Bean的销毁，必须关闭Spring容器，只有关闭了Spring容器，Bean才会进行销毁
    // ApplicationContext 接口中无关闭容器的方法，ClassPathXmlApplicationContext 中有声明定义
    ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
    // 关闭容器
    context.close();
}

Bean生命周期之7步

Bean生命周期七步，比Bean生命周期五步，在初始化Bean的前和后，添加了两步。
在以上的5步中，第3步是初始化Bean，在初始化前和初始化后执行的方法为“Bean后处理器”的before和after方法，通过“Bean后处理器”我们可以在初始化Bean的前后添加需要执行的代码。
要添加“Bean后处理器”需要类实现BeanPostProcessor类，并且重写before和after方法
Bean生命周期之7步：
- 第一步：实例化Bean
- 第二步：Bean属性赋值
- 第三步：执行“Bean后处理器”的before方法。
- 第四步：初始化Bean
- 第五步：执行“Bean后处理器”的after方法。
- 第六步：使用Bean
- 第七步：销毁Bean

创建 Bean 后处理器

package cw.spring.study.pojo;

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

/**
 * ClassName: LogBeanPostProcessor
 * Package: cw.spring.study.pojo
 * Description:
 * 日志Bean后处理器，
 * 在Bean对象的初始化前后执行相应的代码
 *
 * @Author tcw
 * @Create 2023-05-27 10:26
 * @Version 1.0
 */
public class LogBeanPostProcessor implements BeanPostProcessor {
    
    
    /**
     * 初始化Bean之前执行的代码
     *
     * @param bean 刚创建的Bean
     * @param beanName Bean的名字
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    
    
        System.out.println("日志 Bean 后处理器的 before 方法执行...");
        // return 不要修改
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    
    
        System.out.println("日志 Bean 后处理器的 after 方法执行...");
        // return 不要修改
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

配置 Bean 后处理器

在 Spring 的配置文件中配置 Bean 后处理器
Bean 后处理器配置完成后，将会作用于整个配置文件中每个 Bean 的生命周期过程中，如在spring.xml文件中配置的Bean后处理器将会作用于当前配置文件中所有的Bean。

<!-- 
  配置 Bean 后处理器
  将会作用于本配置文件中所有Bean对象的生命周期中 
-->
<bean class="cw.spring.study.pojo.LogBeanPostProcessor"/>

测试

Bean生命周期之十步

Bean生命周期十步比七步多的三步：
- 点位1：在“Bean后处理器”before方法之前，在Bean属性赋值之后
- 点位2：在“Bean后处理器”before方法之后，在Bean的初始化之前
- 点位3：使用Bean之后，或者说销毁Bean之前
添加的这三个点位的特点：都是在检查你这个Bean是否实现了某些特定的接口，如果实现了这些接口，则Spring容器会调用这个接口中的方法。

实现 Aware 相关接口

Aware相关的接口包括：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
- 当Bean实现了BeanNameAware，Spring会将Bean的名字传递给Bean。
- 当Bean实现了BeanClassLoaderAware，Spring会将加载该Bean的类加载器传递给Bean。
- 当Bean实现了BeanFactoryAware，Spring会将Bean工厂对象传递给Bean。
在“Bean后处理器”before方法之前，会检查Bean是否实现了Aware相关的接口，如果实现了接口则调用这些接口中的方法。然后调用这些方法的目的是为了给你传递一些数据，让你更加方便使用。

package cw.spring.study.pojo;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;

/**
 * ClassName: User
 * Package: cw.spring.study.pojo
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-26 17:21
 * @Version 1.0
 */
public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware {
    
    
    private String name;
    
    public User() {
    
    
        System.out.println("1. User 无参构造方法执行");
    }
    
    public void setName(String name) {
    
    
        this.name = name;
        System.out.println("2. User setName 方法执行");
    }
    
    public void init() {
    
    
        System.out.println("4. User init 方法执行，进行 Bean 的初始化");
    }
    
    public void destroy() {
    
    
        System.out.println("7. User destroy 方法执行，进行 Bean 的销毁");
    }
    
    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
    
    
        System.out.println("User Bean 的类加载器：" + classLoader);
    }
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    
    
        System.out.println("生产 User Bean 的工厂：" + beanFactory);
    }
    
    @Override
    public void setBeanName(String name) {
    
    
        System.out.println("User Bean 的名字为：" + name);
    }
}

实现 InitializingBean 接口

在Bean初始化之前，检查Bean是否实现了InitializingBean接口，如果实现了，则调用接口中的方法。
InitializingBean的方法早于init-method的执行。

public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean {
    
    
	...

	@Override
    public void afterPropertiesSet() throws Exception {
    
    
        System.out.println("InitializingBean 的 afterPropertiesSet 方法执行...");
    }
}

实现 DisposableBean 接口

在销毁Bean之前，检查Bean是否实现了DisposableBean接口，如果实现了，则调用接口中的方法。
DisposableBean的方法早于destroy-method的执行

public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware,
                    InitializingBean, DisposableBean {
    
    
	...

	@Override
    public void destroy() throws Exception {
    
    
        System.out.println("DisposableBean destroy 方法执行...");
    }

    // 之前销毁Bean的方法与DisposableBean接口中的方法重名，
    // 进行销毁方法名的修改，并修改Spring.xml文件中的配置
    public void myDestroy() {
    
    
        System.out.println("7. User destroy 方法执行，进行 Bean 的销毁");
    }

	...

}

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

Spring 会根据Bean的作用域来选择管理方式
对于singleton作用域的Bean，Spring 能够精确地知道该Bean何时被创建，何时初始化完成，以及何时被销毁；而对于 prototype 作用域的 Bean，Spring 只负责创建，当容器创建了 Bean 的实例后，对该Bean初始化完毕，等到客户端程序获取到该Bean之后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期。
Spring容器只对singleton的Bean进行完整的生命周期管理，对于prototype的Bean，Spring只进行部分的生命周期管理

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

	<!-- 配置 Bean 后处理器 -->
	<bean class="cw.spring.study.pojo.LogBeanPostProcessor"/>
	
	<bean 
			id="user" 
			class="cw.spring.study.pojo.User" 
			init-method="init" 
			destroy-method="myDestroy"
			scope="prototype"
	>
		<property name="name" value="张三"/>
	</bean>
	
</beans>

将自己 new 的对象交给 Spring 管理

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

public class Student {
    
    }

@org.junit.Test
public void testRegisterBean() {
    
    
    Student student = new Student();
    System.out.println(student);
    
    // 将自己new的对象交给Spring进行管理
    // 使用DefaultListableBeanFactory对象进行Bean实例的注册
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    // 将自己new的对象注册到Spring容器中
    factory.registerSingleton("student", student);
    
    // 从Spring容器中获取Bean
    System.out.println(factory.getBean("student"));
}

【Spring】Bean 的生命周期

什么是Bean的生命周期

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

Bean的生命周期之5步

Bean 的编写

Bean 的配置

测试

Bean生命周期之7步

创建 Bean 后处理器

配置 Bean 后处理器

测试

Bean生命周期之十步

实现 Aware 相关接口

实现 InitializingBean 接口

实现 DisposableBean 接口

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

将自己 new 的对象交给 Spring 管理

猜你喜欢