Spring Bean 的生命周期（看着图不迷路）

时间：2022-11-03 21:52:58

目录

Bean的生命周期5步走系列：

BeanLifeCycle类

Spring.xml 配置文件

BeanLifeTest测试方法

运行结果：

Bean的生命周期7步走系列:在实例化Bean的前和后加了两步。

定义myInstantiationAwareBeanPostProcessor 类

实现InstantiationAwareBeanPostProcessor 接口

并将这个类配置到Spring.xml中

复用5步走的测试方法

运行结果：

Bean的生命周期9步系列:在初始化Bean的前和后添加两步。

需要实现BeanPostProcessor接口并重写 Initialization 的两个方法

Spring.xml配置

复用5步走的测试方法

测试结果：

Bean的生命周期10步走系列:比9步多了在属性赋值之后感知

BeanLifeCycle类

复用5步走的测试方法

测试结果：

Bean的生命周期11步走系列:比10步多添加了初始化Bean之前处理的方法。

BeanLifeCycle类

复用5步走的测试方法

测试结果：

Bean的生命周期12步走系列:在销毁Bean之前添加了一步。

BeanLifeCycle类

复用5步走的测试方法

测试结果：

Spring Bean 的生命周期（看着图不迷路）

Bean的生命周期5步走系列：

分别是如下图：

Spring Bean 的生命周期（看着图不迷路）

BeanLifeCycle类

/**
 * Bean的生命周期按照粗略的五步的话:
 * 第一步:实例化Bean(调用无参数构造方法。)
 * 第二步:给Bean属性赋值(调用set方法。)
 * 第三步:初始化Bean (会调用Bean的init方法。注意:这个init方法需要自己写,自己配。)
 * 第四步:使用Bean
 * 第五步:销毁Bean (公调用Bean/destroy方法。注意:这个destroy方法需要自己写,自己配。)
 * @Author darren
 * @Date 2022/11/2 9:25
 */
public class BeanLifeCycle {

    private String name;

    public BeanLifeCycle() {
        System.out.println("第一步:实例化Bean");
    }

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        System.out.println("第二步:给Bean属性赋值");
        this.name = name;
    }


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


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

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

Spring.xml 配置文件

  <!--Bean 的生命周期-->
    <bean id="beanLife" class="com.power.node.spring6.bean.BeanLifeCycle" init-method="initMethod"
          destroy-method="destroyMethod">
        <property name="name" value="bean_name"/>
    </bean>

BeanLifeTest测试方法

public class BeanLifeTest {
    /**
     * Bean的生命周期
     */
    @Test
    public void testBeanLifeCycle(){
        ClassPathXmlApplicationContext classPathXmlApplicationContext =
                new ClassPathXmlApplicationContext("beanLife.xml");
        BeanLifeCycle beanLife = classPathXmlApplicationContext.getBean("beanLife", BeanLifeCycle.class);
        System.out.println("第四步:使用Bean "+beanLife.toString());
        System.out.println("");

        classPathXmlApplicationContext.close();
    }
}

运行结果：

第一步:实例化Bean
第二步:给Bean属性赋值
第三步:初始化Bean
第四步:使用Bean BeanLifeCycle{name='bean_name'}
第五步:销毁Bean

Bean的生命周期7步走系列:在实例化Bean的前和后加了两步。

如图：

Spring Bean 的生命周期（看着图不迷路）

定义myInstantiationAwareBeanPostProcessor 类

实现InstantiationAwareBeanPostProcessor 接口

/**
 * 实例化前后处理器
 * @Author darren
 * @Date 2022/11/2 17:16
 */
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(final Class<?> beanClass, final String beanName)
            throws BeansException {
        System.out.println("    第1.1步-实例化之前-后期处理器");
        return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInstantiation(beanClass,
                beanName);
    }

    @Override
    public boolean postProcessAfterInstantiation(final Object bean, final String beanName)
            throws BeansException {
        System.out.println("    第1.1步-实例化之后-后期处理器");
        System.out.println("");
        return InstantiationAwareBeanPostProcessor.super.postProcessAfterInstantiation(bean,
                beanName);
    }
}

并将这个类配置到Spring.xml中


    <!--Bean 的生命周期-->
    <bean id="beanLife" class="com.power.node.spring6.bean.BeanLifeCycle" init-method="initMethod"
          destroy-method="destroyMethod">
        <property name="name" value="bean_name"/>
    </bean>

    <!--实例化前后处理器-->
    <bean id="myInstantiationAwareBeanPostProcessor"
          class="com.power.node.spring6.bean.MyInstantiationAwareBeanPostProcessor"/>
</beans>

复用5步走的测试方法

运行结果：

          第1.1步-实例化之前-后期处理器
    第一步:实例化Bean
          第1.2步-实例化之后-后期处理器
    第二步:Bean属性赋值
    第三步:初始化Bean
    第四步:使用Bean
    第五步:销毁Bean

    注意：
    需要实现InstantiationAwareBeanPostProcessor接口并重写Instantiation方法后并配置到xml,
        postProcessBeforeInstantiation:实例化之前-后期处理器
        postProcessAfterInstantiation :实例化之后-后期处理器

Bean的生命周期9步系列:在初始化Bean的前和后添加两步。

Spring Bean 的生命周期（看着图不迷路）

需要实现BeanPostProcessor接口并重写 Initialization 的两个方法

postProcessBeforeInitialization:初始化之前-后期处理器
postProcessAfterInitialization :初始化之后-后期处理器

/**
 * 初始化前后置处理器
 * @Author darren
 * @Date 2022/11/2 9:56
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(final Object bean, final String beanName)
            throws BeansException {
        System.out.println("    第3.1步-初始化前的-后期处理器");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);

    }

    @Override
    public Object postProcessAfterInitialization(final Object bean, final String beanName)
            throws BeansException {
        System.out.println("    第3.2步-初始化后的-后期处理器");
        System.out.println("");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

Spring.xml配置

    <!--Bean 的生命周期-->
    <bean id="beanLife" class="com.power.node.spring6.bean.BeanLifeCycle" init-method="initMethod"
          destroy-method="destroyMethod">
        <property name="name" value="bean_name"/>
    </bean>

    <!--实例化前后处理器-->
    <bean id="myInstantiationAwareBeanPostProcessor"
          class="com.power.node.spring6.bean.MyInstantiationAwareBeanPostProcessor"/>

    <!--初始化前后置处理器-->
    <bean id="myBeanPostProcessor" class="com.power.node.spring6.bean.MyBeanPostProcessor"/>

复用5步走的测试方法

测试结果：

    第1.1步-实例化之前-后期处理器
第一步:实例化Bean
    第1.1步-实例化之后-后期处理器

第二步:给Bean属性赋值
    
    第3.1步-初始化前的-后期处理器   
第三步:初始化Bean
    第3.2步-初始化后的-后期处理器

第四步:使用Bean BeanLifeCycle{name='bean_name'}
第五步:销毁Bean

Bean的生命周期10步走系列:比9步多了在属性赋值之后感知

如图：

Spring Bean 的生命周期（看着图不迷路）

BeanLifeCycle类

需要这个类实现Aware(感知)接口，
    如：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware、ApplicationContextAware
在属性赋值之后感知可以获取或设置下面信息
    BeanName、BeanClassLoader、BeanFactory、ApplicationContext

public class BeanLifeCycle implements BeanNameAware, BeanFactoryAware, BeanClassLoaderAware,
        ApplicationContextAware {

    private String name;

    public BeanLifeCycle() {
        System.out.println("第一步:实例化Bean");
    }

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        System.out.println("第二步:给Bean属性赋值");
        this.name = name;
    }

    @Override
    public void setBeanName(final String s) {
        System.out.println("    第2.2步-属性感知-设置属性名称:"+s);
    }

    @Override
    public void setBeanClassLoader(final ClassLoader classLoader) {
        System.out.println("    第2.3步-属性感知-设置类加载器:"+classLoader);
    }

    @Override
    public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
        System.out.println("    第2.4步-属性感知-设置bean工厂:"+beanFactory);
    }

    @Override
    public void setApplicationContext(final ApplicationContext applicationContext)
            throws BeansException {
        System.out.println("    第2.5步-属性感知-设置上下文:"+applicationContext);
        System.out.println("");
    }


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


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

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

复用5步走的测试方法

测试结果：

    第1.1步-实例化之前-后期处理器
第一步:实例化Bean
    第1.1步-实例化之后-后期处理器

第二步:给Bean属性赋值
    第2.2步-属性感知-设置属性名称:beanLife
    第2.3步-属性感知-设置类加载器:jdk.internal.loader.ClassLoaders$AppClassLoader@78308db1
    第2.4步-属性感知-设置bean工厂:org.springframework.beans.factory.support.DefaultListableBeanFactory@5812f68b: defining beans [beanLife,myInstantiationAwareBeanPostProcessor,myBeanPostProcessor]; root of factory hierarchy
    第2.5步-属性感知-设置上下文:org.springframework.context.support.ClassPathXmlApplicationContext@29f7cefd, started on Wed Nov 02 21:11:42 CST 2022

    第3.1步-初始化前的-后期处理器
第三步:初始化Bean
    第3.2步-初始化后的-后期处理器

第四步:使用Bean BeanLifeCycle{name='bean_name'}
第五步:销毁Bean

Bean的生命周期11步走系列:比10步多添加了初始化Bean之前处理的方法。

如图：

Spring Bean 的生命周期（看着图不迷路）

BeanLifeCycle类

需要这个类实现InitializingBean接口，重写afterPropertiesSet方法

public class BeanLifeCycle implements BeanNameAware, BeanFactoryAware, BeanClassLoaderAware,
        ApplicationContextAware, InitializingBean {

    private String name;

    public BeanLifeCycle() {
        System.out.println("第一步:实例化Bean");
    }

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        System.out.println("第二步:给Bean属性赋值");
        this.name = name;
    }

    @Override
    public void setBeanName(final String s) {
        System.out.println("    第2.2步-属性感知-设置属性名称:"+s);
    }

    @Override
    public void setBeanClassLoader(final ClassLoader classLoader) {
        System.out.println("    第2.3步-属性感知-设置类加载器:"+classLoader);
    }

    @Override
    public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
        System.out.println("    第2.4步-属性感知-设置bean工厂:"+beanFactory);
    }

    @Override
    public void setApplicationContext(final ApplicationContext applicationContext)
            throws BeansException {
        System.out.println("    第2.5步-属性感知-设置上下文:"+applicationContext);
        System.out.println("");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("        第3.1.1步-初始化之前调用");
    }

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


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

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

复用5步走的测试方法

测试结果：

    第1.1步-实例化之前-后期处理器
第一步:实例化Bean
    第1.1步-实例化之后-后期处理器

第二步:给Bean属性赋值
    第2.2步-属性感知-设置属性名称:beanLife
    第2.3步-属性感知-设置类加载器:jdk.internal.loader.ClassLoaders$AppClassLoader@78308db1
    第2.4步-属性感知-设置bean工厂:org.springframework.beans.factory.support.DefaultListableBeanFactory@5812f68b: defining beans [beanLife,myInstantiationAwareBeanPostProcessor,myBeanPostProcessor]; root of factory hierarchy
    第2.5步-属性感知-设置上下文:org.springframework.context.support.ClassPathXmlApplicationContext@29f7cefd, started on Wed Nov 02 21:11:42 CST 2022

    第3.1步-初始化前的-后期处理器
        第3.1.1步-初始化之前调用
第三步:初始化Bean
    第3.2步-初始化后的-后期处理器

第四步:使用Bean BeanLifeCycle{name='bean_name'}
第五步:销毁Bean

Bean的生命周期12步走系列:在销毁Bean之前添加了一步。

如图：

Spring Bean 的生命周期（看着图不迷路）

BeanLifeCycle类

需要这个类实现DisposableBean接口，并重写destroy方法，调用时机是在指定destroy-method 之前调用

public class BeanLifeCycle implements BeanNameAware, BeanFactoryAware, BeanClassLoaderAware,
        ApplicationContextAware, InitializingBean, DisposableBean {

    private String name;

    public BeanLifeCycle() {
        System.out.println("第一步:实例化Bean");
    }

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        System.out.println("第二步:给Bean属性赋值");
        this.name = name;
    }

    @Override
    public void setBeanName(final String s) {
        System.out.println("    第2.2步-属性感知-设置属性名称:"+s);
    }

    @Override
    public void setBeanClassLoader(final ClassLoader classLoader) {
        System.out.println("    第2.3步-属性感知-设置类加载器:"+classLoader);
    }

    @Override
    public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
        System.out.println("    第2.4步-属性感知-设置bean工厂:"+beanFactory);
    }

    @Override
    public void setApplicationContext(final ApplicationContext applicationContext)
            throws BeansException {
        System.out.println("    第2.5步-属性感知-设置上下文:"+applicationContext);
        System.out.println("");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("        第3.1.1步-初始化之前调用");
    }

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

    @Override
    public void destroy() throws Exception {
        System.out.println("    第5.1步-销毁-在destroy-method 之前调用");
    }

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

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

复用5步走的测试方法

测试结果：

    第1.1步-实例化之前-后期处理器
第一步:实例化Bean
    第1.1步-实例化之后-后期处理器

第二步:给Bean属性赋值
    第2.2步-属性感知-设置属性名称:beanLife
    第2.3步-属性感知-设置类加载器:jdk.internal.loader.ClassLoaders$AppClassLoader@78308db1
    第2.4步-属性感知-设置bean工厂:org.springframework.beans.factory.support.DefaultListableBeanFactory@5812f68b: defining beans [beanLife,myInstantiationAwareBeanPostProcessor,myBeanPostProcessor]; root of factory hierarchy
    第2.5步-属性感知-设置上下文:org.springframework.context.support.ClassPathXmlApplicationContext@29f7cefd, started on Wed Nov 02 21:11:42 CST 2022

    第3.1步-初始化前的-后期处理器
        第3.1.1步-初始化之前调用
第三步:初始化Bean
    第3.2步-初始化后的-后期处理器

第四步:使用Bean BeanLifeCycle{name='bean_name'}

    第5.1步-销毁-在destroy-method 之前调用
第五步:销毁Bean

标签：Spring spring java spring boot

相关文章

