Bean的生命周期

阅读目录

一、什么是Bean的生命周期
- 为什么要知道Bean的生命周期
二、Bean的生命周期之5步
三、Bean生命周期之7步
三、Bean生命周期之10步

回到顶部

一、什么是Bean的生命周期

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

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

什么时候创建Bean对象？

创建Bean对象的前后会调用什么方法？

Bean对象什么时候销毁？

Bean对象的销毁前后调用什么方法？

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

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

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

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

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

回到顶部

二、Bean的生命周期之5步

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

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

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

1、先编写一个Bean实体：User.java

/**
 * @ClassName User
 * @Author zhangzhixi
 * @Description
 * @Date 2022-11-24 10:12
 * @Version 1.0
 */
public class User {
 
    private String name;
    private Integer age;
 
    public User() {
        System.out.println("第一步：实例化Bean");
    }
 
    /**
     * 自定义Bean的init方法
     */
    public void initBean(){
        System.out.println("第三步：初始化Bean");
    }
 
    /**
     * 自定义Bean的Destroy方法
     */
    public void destroyBean(){
        System.out.println("第五步：销毁Bean");
    }
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        System.out.println("第二步：给Bean的属性赋值");
        this.name = name;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

2、beans.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="user" class="com.zhixi.User" init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="zhangsan"/>
        <property name="age" value="23"/>
    </bean>
</beans>

3、测试

@Test
public void testFiveDemo() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    System.out.println("第四步：使用Bean");
    User user = applicationContext.getBean("user", User.class);
     
    // 向下转型为ClassPathXmlApplicationContext才能够调用Destroy方法
    ClassPathXmlApplicationContext classPathXmlApplicationContext = (ClassPathXmlApplicationContext) applicationContext;
    classPathXmlApplicationContext.close();
    System.out.println(user);
}

需要注意的：

第一：只有正常关闭spring容器，bean的销毁方法才会被调用。
第二：ClassPathXmlApplicationContext类才有close()方法。
第三：配置文件中的init-method指定初始化方法。destroy-method指定销毁方法。

回到顶部

三、Bean生命周期之7步

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

1、LogBeanPostProcessor.java

/**
 * @author zhangzhixi
 * @version 1.0
 * @className LogBeanPostProcessor
 * @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;
    }
 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Bean后处理器的after方法执行，已完成初始化");
        return bean;
    }
}

2、注册bean

<!--在全局Bean的初始化前后执行代码-->
<!--配置Bean后处理器。这个后处理器将作用于当前配置文件中所有的bean。-->
<bean id="beanPostProcessor" class="com.zhixi.LogBeanPostProcessor"/>

3、测试　　

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

回到顶部

三、Bean生命周期之10步

如果根据源码跟踪，可以划分更细粒度的步骤，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

1、User.java

package com.zhixi;
 
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
 
/**
 * @ClassName User
 * @Author zhangzhixi
 * @Description
 * @Date 2022-11-24 10:12
 * @Version 1.0
 */
public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean,DisposableBean {
 
    private String name;
    private Integer age;
 
    public User() {
        System.out.println("1、实例化Bean");
    }
 
    /**
     * 自定义Bean的init方法
     */
    public void initBean(){
        System.out.println("6、初始化Bean");
    }
 
    /**
     * 自定义Bean的Destroy方法
     */
    public void destroyBean(){
        System.out.println("10、销毁Bean");
    }
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        System.out.println("2、给Bean的属性赋值");
        this.name = name;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
 
    @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执行");
    }
}

2、Bean后置处理的：Before、After方法

/**
 * @author zhangzhixi
 * @version 1.0
 * @className LogBeanPostProcessor
 * @since 1.0
 **/
public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("4、Bean后处理器的before方法执行，即将开始初始化");
        return bean;
    }
 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("7、Bean后处理器的after方法执行，已完成初始化");
        return bean;
    }
}