Spring Bean 生命周期

下自成蹊*

已于 2022-03-06 11:01:38 修改

阅读量213

点赞数

分类专栏： Spring 文章标签： java 开发语言后端

于 2022-03-06 10:59:16 首次发布

本文链接：https://blog.youkuaiyun.com/zpx_Smart/article/details/123306652

版权

Spring 专栏收录该内容

12 篇文章

订阅专栏

在这里插入图片描述

BeanFactoryPostProcessor接口只会执行一次

BeanPostProcessor接口有几个自定义的Bean 就会执行几次

BeanFactoryPostProcessor（Bean工厂的后置处理器）

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public MyBeanFactoryPostProcessor() {
        System.out.println("【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor实现类构造方法");
    }

// 获取到 ConfigurableListableBeanFactory 我们称之为spring 容器
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("0=====>【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor接口的postProcessBeanFactory方法");
        BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition("student");
        beanDefinition.getPropertyValues().addPropertyValue("age", "21");

    }
}

BeanPostProcessor（Bean的后置处理器）

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    public MyBeanPostProcessor(){
        System.out.println("【BeanPostProcessor接口】调用BeanPostProcessor的构造方法");
    }

// Bean init 方法前被调用
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("3.1====>【BeanPostProcessor接口】调用postProcessBeforeInitialization方法，这里可对"+beanName+"的属性进行更改。");
        return bean;
    }

// bean init 方法后被调用
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("3.2===>>>【BeanPostProcessor接口】调用postProcessAfterInitialization方法，这里可对"+beanName+"的属性进行更改。");
        return bean;
    }
}

InitializingBean, DisposableBean, BeanNameAware, BeanFactoryAware

public class Student implements InitializingBean, DisposableBean, BeanNameAware, BeanFactoryAware {

    private String name;
    private int age;

    private String beanName;//实现了BeanNameAware接口，Spring可以将BeanName注入该属性中
    private BeanFactory beanFactory;//实现了BeanFactory接口，Spring可将BeanFactory注入该属性中



    Student(){

        System.out.println("1======》执行 Student 构造函数");
    }

    @PostConstruct
    public void postConstruct(){
        System.out.println("4=====>测试构造器方法 === PostConstruct");
    }

    @PreDestroy
    public void preDestroy(){
        System.out.println("7====>销毁方法 === preDestroy");
    }


    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("3======>【BeanFactoryAware接口】调用BeanFactoryAware的setBeanFactory方法得到beanFactory引用");

    }

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("2=======>【BeanNameAware接口】调用BeanNameAware的setBeanName方法得到Bean的名称");
    }

    @Override
    public void destroy() throws Exception {

    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5=======>【InitializingBean接口】调用InitializingBean接口的afterPropertiesSet方法");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("【set注入】注入学生的name属性");
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        System.out.println("【set注入】注入学生的age属性");
        this.age = age;
    }

    public String getBeanName() {
        return beanName;
    }

    public BeanFactory getBeanFactory() {
        return beanFactory;
    }

    /**
     * 自己编写的初始化方法
     */
    public void myInit(){
        System.out.println("6=======>【init-method】调用init-method属性配置的初始化方法");
    }

    /**
     * 自己编写的销毁方法
     */
    public void myDestroy(){
        System.out.println("8======>【destroy-method】调用destroy-method属性配置的销毁方法");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", beanName='" + beanName + '\'' +
                ", beanFactory=" + beanFactory +
                '}';
    }
}

配置类

@Configuration
@ComponentScan("com.example.demo.config")
public class BeanConfig {

    @Bean(value = "student", initMethod = "myInit", destroyMethod = "myDestroy")
    public Student student() {
        return new Student();
    }
}

测试类

public class TestCyclelife {

    public static void main(String[] args) {
        System.out.println("--------------【初始化容器】---------------");

        ApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
        System.out.println("-------------------【容器初始化成功】------------------");
        //得到studentBean，并显示其信息
        Student studentBean = context.getBean("student",Student.class);
        System.out.println(studentBean);

        System.out.println("--------------------【销毁容器】----------------------");
        ((AnnotationConfigApplicationContext)context).registerShutdownHook();
    }
}

日志结果

0=====>【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor接口的postProcessBeanFactory方法

3.1====>【BeanPostProcessor接口】调用postProcessBeforeInitialization方法，这里可对beanConfig的属性进行更改。
3.2===>>>【BeanPostProcessor接口】调用postProcessAfterInitialization方法，这里可对beanConfig的属性进行更改。
1======》执行 Student 构造函数
【set注入】注入学生的age属性
2=======>【BeanNameAware接口】调用BeanNameAware的setBeanName方法得到Bean的名称
3======>【BeanFactoryAware接口】调用BeanFactoryAware的setBeanFactory方法得到beanFactory引用
3.1====>【BeanPostProcessor接口】调用postProcessBeforeInitialization方法，这里可对student的属性进行更改。
4=====>测试构造器方法 === PostConstruct
5=======>【InitializingBean接口】调用InitializingBean接口的afterPropertiesSet方法
6=======>【init-method】调用init-method属性配置的初始化方法
3.2===>>>【BeanPostProcessor接口】调用postProcessAfterInitialization方法，这里可对student的属性进行更改。
-------------------【容器初始化成功】------------------
Student{name='null', age=21, beanName='student'}
--------------------【销毁容器】----------------------
7====>销毁方法 === preDestroy
8======>【destroy-method】调用destroy-method属性配置的销毁方法

InitializingBean： InitializingBean接口为bean提供了初始化方法的方式,它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。
DisposableBean : 销毁一个bean
BeanNameAware: 获取Bean 的名称，意义不是很大

BeanFactoryAware：实现 BeanFactoryAware 接口的 bean 可以直接访问 Spring 容器，被容器创建以后，它会拥有一个指向 Spring 容器的引用。
BeanFactoryPostProcessor: bean的后置处理器，bean definition都已加载，但还没有实例化任何bean，BeanFactoryPostProcessor允许插手修改context内部bean工厂,允许覆盖或添加属性。
BeanPostProcessor 可以做些Bean的订制化逻辑
DefaultListableBeanFactory spring 对应的容器类