根据 【动力节点】最新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")); }
