SpringBean的生命周期

一、概述

1.1什么是Spring的Bean？

从[Spring Framework](Introduction to the Spring IoC Container and Beans :: Spring Framework)的官方文档中可以得知：

java 复制代码

In Spring, the objects that form the backbone of your application and that are managed 
by the Spring IoC container are called beans. A bean is an object that is instantiated, 
assembled, and managed by a Spring IoC container. 
Otherwise, a bean is simply one of many objects in your application. 
Beans, and the dependencies among them, 
are reflected in the configuration metadata used by a container.

简单来描述一下，bean 是由 Spring IoC 容器实例化、组装和管理的对象。

1.2什么是Bean的生命周期？

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

所谓的生命周期就是：对象从创建开始到最终销毁的整个完整的过程。什么时候创建Bean对象？创建Bean对象的前后会调用什么方法？Bean对象什么时候销毁？Bean对象的销毁前后调用什么方法？【PS:有点类似人的一生】

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

二、Bean的生命周期

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

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

第一步：实例化Bean
第二步：Bean属性赋值
第三步：初始化Bean
第四步：使用Bean
第五步：销毁Bean

示例：写一个Bean

java 复制代码

package com.stringzhua.pojo;

/**
 * @Author Stringzhua
 * @Date 2024/9/21 16:27
 * description:
 */
public class Music {
    private String musicName;

    public Music() {
        System.out.println("第一步：实例化Bean，无参构造方法进行了");
    }

    public void setMusicName(String musicName) {
        this.musicName = musicName;
        System.out.println("第二步：给Bean属性赋值");
    }

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

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

    @Override
    public String toString() {
        return "Music{" +
                "musicName='" + musicName + '\'' +
                '}';
    }
}

applicationContext.xml配置

需要在标签中调用init-method和destroy-method属性，手动指定初始化方法和销毁方法

xml 复制代码

<?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 id="music" class="com.stringzhua.pojo.Music" init-method="init_method" destroy-method="destroy_method">
        <property name="musicName" value="有何不可"></property>
    </bean>
</beans>

测试一下:

①需要手动关闭Spring容器（调用close方法），这样Spring容器才会销毁Bean，才会去调用我们定义的destroyBean方法！

② 注意：只有ApplicationContext的实现类ClassPathXmlApplicationContext有close方法，ApplicationContext没有，所以需要强制类型转换；然后调用close方法！

java 复制代码

package com.stringzhua.test;

import com.stringzhua.pojo.Music;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author Stringzhua
 * @Date 2024/9/21 16:31
 * description:
 */
public class Test01 {
    @Test
    public void test01(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Music music = applicationContext.getBean("music", Music.class);
        System.out.println("第四步：使用Bean"+music);

        // 需要手动关闭Spring容器
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
        context.close();
    }
}

需要注意的：

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

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

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

三、Bean生命周期之7步

在以上的5步中，第3步是初始化Bean，如果你还想在初始化前和初始化后添加代码，可以加入"Bean后处理器"。编写一个类实现BeanPostProcessor类，并且重写before和after方法：

Bean生命周期可以细化为七大步：

第一步：实例化Bean

第二步：Bean属性赋值

第三步：执行"Bean后处理器"的before方法

第四步：初始化Bean

第五步：执行"Bean后处理器"的after方法

第六步：使用Bean

第七步：销毁Bean

示例:

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

注意：方法中有两个参数：

①第一个参数是创建的Bean对象！

②第二个参数是Bean的名字！

java 复制代码

package com.stringzhua.pojo;

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

public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第三步:Bean后处理器的before方法执行，即将开始初始化 Bean: " + beanName);
        return bean; // 直接返回 bean
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第五步:Bean后处理器的after方法执行，已完成初始化 Bean: " + beanName);
        return bean; // 直接返回 bean
    }
}

java 复制代码

package com.stringzhua.pojo;

public class MyBean {
    private String beanName;

    public void setBeanName(String beanName) {
        this.beanName = beanName;
        System.out.println("第二步：给Bean属性赋值");
    }

    public MyBean() {
        System.out.println("第一步：实例化Bean，无参构造方法进行了");
    }

    @Override
    public String toString() {
        return "MyBean{" +
                "beanName='" + beanName + '\'' +
                '}';
    }

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

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

在applicationContext.xml文件中配置"Bean后处理器"：

xml 复制代码

<!-- 配置 Bean 后处理器 -->
    <bean class="com.stringzhua.pojo.LogBeanPostProcessor"/>

    <bean name="myBean" class="com.stringzhua.pojo.MyBean" init-method="init_method" destroy-method="destroy_method">
        <property name="beanName" value="我的世界"></property>
    </bean>

进行测试:

java 复制代码

 @Test
    public void test02(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyBean myBean = (MyBean) applicationContext.getBean("myBean");
        // 使用 Bean
        System.out.println("第六步：使用Bean"+myBean);
        // 需要手动关闭Spring容器
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
        context.close();
    }

四、Bean生命周期之10步

（1）在"Bean后处理器"before方法之前干了什么事儿？

检查Bean是否实现了Aware相关的接口，如果实现了接口则调用这些接口中的方法；调用这些方法的目的是为了给你传递一些数据，让你更加方便使用。

（2）在"Bean后处理器"before方法之后干了什么事儿？

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

（3）使用Bean之后，或者说销毁Bean之前干了什么事儿？

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

总结：添加的这三个点位的特点，都是在检查你这个Bean是否实现了某些特定的接口，如果实现了这些接口，则Spring容器会调用这个接口中的方法！

如果根据源码跟踪，可以划分更细粒度的步骤，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个接口，并实现所有方法：

java 复制代码

BeanNameAware
BeanClassLoaderAware
BeanFactoryAware
InitializingBean
DisposableBean

示例代码:

java 复制代码

package com.stringzhua.pojo;

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

public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
//        System.out.println("第三步:Bean后处理器的before方法执行，即将开始初始化 Bean: " + beanName);
        System.out.println("4.Bean后处理器的before方法执行，即将开始初始化 Bean: " + beanName);
        return bean; // 直接返回 bean
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("7.Bean后处理器的after方法执行，已完成初始化 Bean: " + beanName);
        return bean; // 直接返回 bean
    }
}

java 复制代码

package com.stringzhua.pojo;

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

/**
 * @Author Stringzhua
 * @Date 2024/9/22 12:25
 * description:
 */

public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
    private String name;

    public User() {
        System.out.println("1.实例化Bean");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("2.Bean属性赋值");
    }

    public void initBean(){
        System.out.println("6.初始化Bean");
    }

    public void destroyBean(){
        System.out.println("10.销毁Bean");
    }

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

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

    @Override
    public void setBeanName(String name) {
        System.out.println("3.bean名字：" + name);
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("9.DisposableBean destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5.afterPropertiesSet执行");
    }
}

xml 复制代码

    <!-- 配置 Bean 后处理器 -->
    <bean class="com.stringzhua.pojo.LogBeanPostProcessor"/>

    <bean name="user" class="com.stringzhua.pojo.User" init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="我的世界"></property>
    </bean>

测试:

java 复制代码

@Test
public void test03(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    User user = (User) applicationContext.getBean("user");
    // 使用 Bean
    System.out.println("8.使用Bean"+user);
    // 需要手动关闭Spring容器
    ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
    context.close();
}

通过测试可以看出来：

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

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

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

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

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

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

我们把之前User类的applicationContext.xml文件中的配置scope设置为prototype：

通过测试发现只执行了前8步，第9和10都没有执行。

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

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

java 复制代码

package com.stringzhua.test;

/**
 * @Author Stringzhua
 * @Date 2024/9/22 12:35
 * description:
 */
public class User {
}

java 复制代码

package com.stringzhua.test;

import org.springframework.beans.factory.support.DefaultListableBeanFactory;

public class RegisterBeanTest {
    public static void main(String[] args){
        // 自己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);
    }
}

七、总结

实例化（Instantiation）：

在这一阶段，Spring容器通过调用无参构造方法来创建bean实例。

1.项目启动后,spring委派给bean的信息读取器读取xml或注解，将每个bean
标签转化为beandefinition信息对象并打包存在map集合
2.从map集合中提取出每个bean的信息对象执行工厂后处理器
3.创建出1个半成品javabean对象

属性注入（Dependency Injection）：

Spring通过依赖注入（setter注入或构造函数注入）将配置文件中指定的属性值或依赖对象注入到bean实例中。

初始化（Initialization）：

在属性注入完成后，如果bean实现了InitializingBean接口，Spring将调用afterPropertiesSet()方法。另外，如果在bean配置中指定了自定义的初始化方法，Spring也会调用该方法。
半成品javabean对象依次执行属性赋值
aware接口
后处理器before
接口初始化
属性初始化
后处理器after
并创建出完整javabean对象存在singletonObjectsmap集合中

使用（Usage）：

在初始化完成后，bean就可以被应用程序使用了。在这个阶段，bean通常会执行它的业务逻辑。
用户调用getbean方法，从singletonObjectsmap集合中提取到想要的对象内容

销毁（Destruction）：

当Spring容器关闭时，如果bean实现了DisposableBean接口，Spring将调用destroy()方法。同样，如果在bean配置中指定了自定义的销毁方法，Spring也会调用该方法。
伴随容器的关闭，自动回收一部分javabean对象，回收时会自动调用接口的销毁以及属性的销毁

八、一些细节

1.Bean 实例化的基本流程

Spring容器在进行初始化时，会将xml配置的的信息封装成一个BeanDefinition对象，所有的 BeanDefinition存储到一个名为beanDefinitionMap的Map集合中去，Spring框架在对该Map进行遍历，使用反射创建Bean实例对象，创建好的Bean对象存储在一个名为singletonObjects的Map集合中，当调用 getBean方法时则最终从该Map集合中取出Bean实例对象返回

Bean信息定义对象-BeanDefinition

BeanDefinition存储到一个名为beanDefinitionMap

对象存储在一个名为singletonObjects的Map

Bean 实例化的基本流程

加载xml配置文件，解析获取配置中的每个的信息，封装成一个个的BeanDefinition对象;

将BeanDefinition存储在一个名为beanDefinitionMap的Map中;

ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象; 创建好的Bean实例对象，被存储到一个名为singletonObjects的Map中;

当执行applicationContext.getBean(beanName)时，从singletonObjects去匹配Bean实例返回

2.Spring的Bean后处理器

Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。Spring主要有两种后处理器：

BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行；

BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects 之前执行。

2.1BeanFactoryPostProcessor

Bean 工厂后处理器 -- BeanFactoryPostProcessor

BeanFactoryPostProcessor是一个接口规范，实现了该接口的类只要交由Spring 容器管理的话，那么Spring就会回调该接口的方法，用于对BeanDefinition 注册和修改的功能。

演示修改：

创建 BeanFactoryPostProcessor 实现类并重写方法

注入实现类

演示注册：

创建 BeanFactoryPostProcessor 实现类并重写方法

注入实现类

Bean 工厂后处理器 -- BeanDefinitionRegistryPostProcessor

Spring 提供了一个 BeanFactoryPostProcessor 的子接口 BeanDefinitionRegistryPostProcessor 专门用于注册BeanDefinition 操作

java 复制代码

public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {
 
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        // Implementation goes here
    }
 
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.apesource.pojo.Student");
        beanDefinitionRegistry.registerBeanDefinition("stu", beanDefinition);
    }
}

BeanPostProcessor

Bean 后处理器 -- BeanPostProcessor

Bean被实例化后，到最终缓存到名为 singletonObjects 单例池之前，中间会经过 Bean 的初始化过程，例如：属性的填充、初始方法init 的执行等，其中有一个对外进行扩展的点 BeanPostProcessor ，我们称为 Bean后处理。跟上面的 Bean 工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的 BeanPostProcessor ，会在流程节点上被 Spring 自动调用。

自定义演示：

自定义 MyBeanPostProcessor 类:

java 复制代码

1public class MyBeanPostProcessor implements BeanPostProcessor {
2
3    /* 
4     * 参数：bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称
5     * 返回值：当前Bean实例对象
6     */
7    @Override
8    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
9        System.out.println("BeanPostProcessor的before方法...");
10        return bean;
11    }
12
13    /* 
14     * 参数：bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称
15     * 返回值：当前Bean实例对象
16     */
17    @Override
18    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
19        System.out.println("BeanPostProcessor的after方法...");
20        return bean;
21    }
22}

注入配置 MyBeanPostProcessor:

xml 复制代码

1<!-- 假设这是Spring配置文件的一部分 -->
2<bean id="myBeanPostProcessor" class="com.stringzhua.processors.MyBeanPostProcessor" />
3
4<!-- 假设有另一个bean定义用于User -->
5<bean id="user" class="com.stringzhua.pojo.User" />

测试控制台打印结果如下:

1User创建了...

2BeanPostProcessor的before方法...

3User属性填充...

4User初始化方法执行...

5BeanPostProcessor的after方法...

6com.stringzhua.pojo.User@56ac3a89

3.常用的Aware接口

Aware接口是一种框架辅助属性注入的一种思想，其他框架中也可以看到类似的接口。框架具备高度封装性，我们接触到的一般都是业务代码，一个底层功能API 不能轻易的获取到，但是这不意味着永远用不到这些对象，如果用到了，就可以使用框架提供的类似Aware 的接口，让框架给我们注入该对象

总结：处理器的作用，为Bean 生命周期各个阶段提供扩展

Aware接口	回调方法	作用
ServletContextAware	setServletContext(ServletContext context)	Spring框架回调方法注入ServletContext对象，web环境下才生效
BeanFactoryAware	setBean(BeanFactory factory)	Spring框架回调方法注入beanFactory对象
BeanNameAware	setBeanName(String beanName)	Spring框架回调方法注入当前Bean在容器中的beanName
ApplicationContextAware	setApplicationContext(ApplicationContext applicationContext)	Spring框架回调方法注入applicationContext对象

生命周期总结：