【Spring】Bean 的生命周期

简介: 【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"));
}

相关文章
|
10天前
|
XML 安全 Java
|
1月前
|
缓存 Java Spring
实战指南:四种调整 Spring Bean 初始化顺序的方案
本文探讨了如何调整 Spring Boot 中 Bean 的初始化顺序,以满足业务需求。文章通过四种方案进行了详细分析: 1. **方案一 (@Order)**:通过 `@Order` 注解设置 Bean 的初始化顺序,但发现 `@PostConstruct` 会影响顺序。 2. **方案二 (SmartInitializingSingleton)**:在所有单例 Bean 初始化后执行额外的初始化工作,但无法精确控制特定 Bean 的顺序。 3. **方案三 (@DependsOn)**:通过 `@DependsOn` 注解指定 Bean 之间的依赖关系,成功实现顺序控制,但耦合性较高。
实战指南:四种调整 Spring Bean 初始化顺序的方案
|
8天前
|
安全 Java 开发者
Spring容器中的bean是线程安全的吗?
Spring容器中的bean默认为单例模式,多线程环境下若操作共享成员变量,易引发线程安全问题。Spring未对单例bean做线程安全处理,需开发者自行解决。通常,Spring bean(如Controller、Service、Dao)无状态变化,故多为线程安全。若涉及线程安全问题,可通过编码或设置bean作用域为prototype解决。
16 1
|
2月前
|
XML Java 数据格式
Spring从入门到入土(bean的一些子标签及注解的使用)
本文详细介绍了Spring框架中Bean的创建和使用,包括使用XML配置文件中的标签和注解来创建和管理Bean,以及如何通过构造器、Setter方法和属性注入来配置Bean。
75 9
Spring从入门到入土(bean的一些子标签及注解的使用)
|
3月前
|
缓存 安全 Java
Spring框架中Bean是如何加载的?从底层源码入手,详细解读Bean的创建流程
从底层源码入手,通过代码示例,追踪AnnotationConfigApplicationContext加载配置类、启动Spring容器的整个流程,并对IOC、BeanDefinition、PostProcesser等相关概念进行解释
278 24
Spring框架中Bean是如何加载的?从底层源码入手,详细解读Bean的创建流程
|
2月前
|
Java 测试技术 Windows
咦!Spring容器里为什么没有我需要的Bean?
【10月更文挑战第11天】项目经理给小菜分配了一个紧急需求,小菜迅速搭建了一个SpringBoot项目并完成了开发。然而,启动测试时发现接口404,原因是控制器包不在默认扫描路径下。通过配置`@ComponentScan`的`basePackages`字段,解决了问题。总结:`@SpringBootApplication`默认只扫描当前包下的组件,需要扫描其他包时需配置`@ComponentScan`。
|
3月前
|
XML Java 数据格式
Spring IOC—基于XML配置Bean的更多内容和细节(通俗易懂)
Spring 第二节内容补充 关于Bean配置的更多内容和细节 万字详解!
239 18
Spring IOC—基于XML配置Bean的更多内容和细节(通俗易懂)
|
3月前
|
XML Java 数据格式
spring复习02,xml配置管理bean
详细讲解了Spring框架中基于XML配置文件管理bean的各种方式,包括获取bean、依赖注入、特殊值处理、属性赋值、集合类型处理、p命名空间、bean作用域及生命周期和自动装配。
spring复习02,xml配置管理bean
|
2月前
|
Java 开发者 Spring
Spring bean的生命周期详解!
本文详细解析Spring Bean的生命周期及其核心概念,并深入源码分析。Spring Bean是Spring框架的核心,由容器管理其生命周期。从实例化到销毁,共经历十个阶段,包括属性赋值、接口回调、初始化及销毁等。通过剖析`BeanFactory`、`ApplicationContext`等关键接口与类,帮助你深入了解Spring Bean的管理机制。希望本文能助你更好地掌握Spring Bean生命周期。
120 1
|
2月前
|
Java Spring
获取spring工厂中bean对象的两种方式
获取spring工厂中bean对象的两种方式
46 1