SpringBean的生命周期

一、流程说明

1、 启动spring容器,也就是创建beanFactory(bean工厂),

　　一般用的是beanFactory的子类applicationcontext,

　　applicationcontext比一般的beanFactory要多很多功能,比如aop、事件等。

　　通过applicationcontext加载配置文件,或者利用注解的方式扫描将bean

　　的配置信息加载到spring容器里面。

2、 加载之后,spring容器会将这些配置信息(java bean的信息),封装成BeanDefinition对象
　　BeanDefinition对象其实就是普通java对象之上再封装一层,
　　赋予一些spring框架需要用到的属性,比如是否单例,是否懒加载等等。

3、 然后将这些BeanDefinition对象以key为beanName,
　　值为BeanDefinition对象的形式存入到一个map里面,
　　将这个map传入到spring beanfactory去进行springBean的实例化。

4、 传入到pring beanfactory之后,利用BeanFactoryPostProcessor接口这个扩展点
　　去对BeanDefinition对象进行一些属性修改。

5、 开始循环BeanDefinition对象进行springBean的实例化,springBean的实例化也就
　　是执行bean的构造方法(单例的Bean放入单例池中,但是此刻还未初始化),
　　在执行实例化的前后,可以通过InstantiationAwareBeanPostProcessor扩展点
　　(作用于所有bean)进行一些修改。

6、 spring bean实例化之后,就开始注入属性,
　　首先注入自定义的属性,比如标注@autowrite的这些属性,
　　再调用各种Aware接口扩展方法,注入属性(spring特有的属性),
　　比如BeanNameAware.setBeanName,设置Bean的ID或者Name;

7、 初始化bean,对各项属性赋初始化值,,初始化前后执行BeanPostProcessor
　　(作用于所有bean)扩展点方法,对bean进行修改。

　　初始化前后除了BeanPostProcessor扩展点还有其他的扩展点,执行顺序如下:

　　(1). 初始化前 postProcessBeforeInitialization()
　　(2). 执行构造方法之后 执行 @PostConstruct作用的方法（@PostConstruct注解）
　　(3). 所有属性赋初始化值之后 afterPropertiesSet()
　　(4). 初始化时 配置文件中指定的 init-method 方法
　　(5). 初始化后 postProcessAfterInitialization()

　　先执行BeanPostProcessor扩展点的前置方法postProcessBeforeInitialization(),
　　再执行@PostConstruct标注的方法
　　所有属性赋值完成之后执行afterPropertiesSet()
　　然后执行 配置文件或注解中指定的 init-method 方法
　　最后执行BeanPostProcessor扩展点的后置方法postProcessAfterInitialization()

8、 此时已完成bean的初始化,在程序中就可以通过spring容器拿到这些初始化好的bean。

9、 随着容器销毁,springbean也会销毁,销毁前后也有一系列的扩展点。
　　销毁bean之前,执行@PreDestroy 的方法，再执行重写DisposableBean接口的destroy方法
　　最后销毁时,执行配置文件或注解中指定的 destroy-method 方法。

以上就是spring bean的整个生命周期

其实就是根据配置文件或注解信息,生成BeanDefinition,
循环BeanDefinition去实例化对象-》注入属性-》初始化-》销毁,在这4个阶段执行前后,spring框架提供了一系列的扩展点。

 

二、代码演示说明

　　2.1、实体类

package com.lyh.beanLife;

import lombok.Data;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @Author lyh
 * @Date 2022/4/29
 * @Description 测试Spring Bean的生命周期
 */
@Data
public class Book implements BeanNameAware, BeanFactoryAware , ApplicationContextAware , InitializingBean, DisposableBean {

    String bookName;

    public Book() {
        System.out.println("Book 构造方法执行（实例化）");
    }

    @Override
    public void setBeanName(String beanName) {
        System.out.println("setBeanName 执行");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("setBeanFactory 执行");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("setApplicationContext 执行");
    }

    // javaJava自带的注解
    @PostConstruct
    public void myPostConstruct(){
        System.out.println("myPostConstruct 执行");
    }

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

    public void myInitMethod(){
        System.out.println("myInitMethod 执行");
    }

    // javaJava自带的注解
    @PreDestroy
    public void PreDestroy(){
        System.out.println("PreDestroy 执行");
    }

    @Override
    public void destroy(){
        System.out.println("destroy 执行");
    }

    public void myDestroyMethod(){
        System.out.println("myDestroyMethod 执行");
    }
}

　　2.2、自定义BeanPostProcessor

package com.lyh.beanLife;

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

/**
 * @Author lyh
 * @Date 2022/4/29
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    // bean初始化前
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Book){
            System.out.println("postProcessBeforeInitialization 执行");
        }
        return bean;
    }

    // bean初始化后
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Book){
            System.out.println("postProcessAfterInitialization 执行");
        }
        return bean;
    }
}

　　2.3、将bean注入到容器中，指定init方法和destroy方法

@Configuration
public class BeanConfig {

    @Bean(initMethod = "myInitMethod",destroyMethod = "myDestroyMethod")
    public Book book(){
        return new Book();
    }
}

　　2.4、启动springboot应用并关闭应用查看输出结果