spring Bean生命周期（IOC）

最新推荐文章于 2023-08-18 22:20:19 发布

又菜又懒001

最新推荐文章于 2023-08-18 22:20:19 发布

阅读量241

点赞数

分类专栏： spring 文章标签： java spring bean

本文链接：https://blog.csdn.net/qq_25271459/article/details/109580675

版权

spring 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

环境，springBoot-mybatisplus，idea

创建过程

Spring提供了5个接口用来扩展创建Bean的过程，按照执行顺序排序如下

1.BeanNameAware：只有一个抽象方法setBeanName，实现该接口可以获取BeanName（通常不建议对象依赖于其bean名称）
2.BeanClassLoaderAware：只有一个抽象方法setBeanClassLoader，实现该接口可以获取BeanClassLoader
3.BeanFactoryAware：只有一个抽象方法setBeanFactory，实现该接口可以获取BeanFactory
4.InitializingBean：只有一个抽象方法afterPropertiesSet，实现该接口可以验证Bean是否符合要求，不符合时抛出异常
5.BeanFactoryPostProcessor：只有一个抽象方法postProcessBeanFactory，方法的参数是ConfigurableListableBeanFactory，我们能够得到所有的Bean，并做处理
另外@PostConstruct注解修饰的方法在3和4之间执行

总结：XxxAware可以用来获取Spring容器中Bean的相关信息
如果想把这些信息放入Bean中，则Bean需要有一个相同（如：BeanFactory beanFactory，String name，BeanClassLoader beanClassLoader）类型的属性,在相关方法中赋值。如下：

    private BeanFactory beanFactory;
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;//这样就得到了Spring的BeanFactory并赋值给了Bean
        System.out.println("4.setBeanFactory:" + beanFactory);
    }

销毁（先执行1后执行2）

1.实现接口DisposableBean，项目关闭时执行destroy方法
2.自定义方法，在@Bean注解中指定为destroy方法

创建测试Bean

1.实现BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean，BeanFactoryPostProcessor五个接口
2.实现接口的抽象方法（一共5个接口，每个接口都只有一个抽象方法，共5个方法）
3.提供一个BeanFactory类型的属性
4.提供一个无参构造方法（用来查看什么时候调用无参构造实例化对象）
5.提供init方法，myDestroy方法（用来查看什么时候调用）
6.提供一个被@PostConstruct修饰的方法（用来查看什么时候调用）
7.实现DisposableBean接口，并实现接口的一个方法（查看什么时候调用）

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

import javax.annotation.PostConstruct;

public class TestBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, BeanFactoryPostProcessor, DisposableBean {

    private BeanFactory beanFactory;

    public TestBean() {
        System.out.println("1.调用无参构造实例化对象");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("2.setBeanName:" + name);
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("3.setBeanClassLoader:" + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;//这样就得到了Spring的BeanFactory
        System.out.println("4.setBeanFactory:" + beanFactory);
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("5.postConstruct");
    }

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

    public void init() {
        System.out.println("7.初始化方法init");
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("8.postProcessBeanFactory:后置处理器，在Spring的Bean初始化完成之后");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("9.destroy");
    }
    public void myDestroy(){
        System.out.println("10.myDestroy");
    }
}

创建配置类，配置TestBean,指定init初始化方法和destroyMethod销毁方法

在这里插入代码片import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {
    @Bean(initMethod = "init",destroyMethod = "myDestroy")
    public TestBean testBean() {
        return new TestBean();
    }
}

运行启动类发现结果如下

在这里插入图片描述

项目停止效果如下

在这里插入图片描述

看着没问题，其实有大问题

纠错

创建类TestBean，TestBean1，配置类MyConfig

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

public class TestBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, BeanFactoryPostProcessor, DisposableBean, BeanPostProcessor {

    private BeanFactory beanFactory;
    //测试类的属性
    private Integer num;
    private boolean a;
    private boolean b;

    public TestBean() {
        this.num = 1;
        System.out.println("1.调用无参构造实例化对象");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("2.setBeanName:" + name);
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("3.setBeanClassLoader:" + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;//这样就得到了Spring的BeanFactory
        System.out.println("4.setBeanFactory:" + beanFactory);
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("5.postConstruct");
    }

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

    public void init() {
        System.out.println("7.初始化方法init");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("8.postProcessBeanFactory:后置处理器，在Spring的Bean初始化完成之后");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if(!a){
            a=true;
            System.out.println("8.1.############bean后置处理器");
        }
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if(!b){
            b=true;
            System.out.println("8.2############bean后置处理器");
        }
        return bean;
    }

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

    public void myDestroy() {
        System.out.println("10.myDestroy");
    }
}

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

public class TestBean1 implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, BeanFactoryPostProcessor, DisposableBean, BeanPostProcessor {
    //测试类的属性
    private boolean a;
    //测试类的属性
    private boolean b;

    public TestBean1() {
        System.out.println("11.调用无参构造实例化对象");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("22.setBeanName:" + name);
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("33.setBeanClassLoader:" + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("44.setBeanFactory:" + beanFactory);
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("55.postConstruct");
    }

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

    public void init() {
        System.out.println("77.初始化方法init");
    }


    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("88.postProcessBeanFactory:后置处理器，在Spring的Bean初始化完成之后");
    }
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if(!a){
            a=true;
            System.out.println("88.1**********bean后置处理器");
        }
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if(!b){
            b=true;
            System.out.println("88.2**********bean后置处理器");
        }
        return bean;
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("99.destroy");
    }
    public void myDestroy() {
        System.out.println("1010.myDestroy");
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {
    @Bean(initMethod = "init",destroyMethod = "myDestroy")
    public TestBean testBean() {
        return new TestBean();
    }

    @Bean(initMethod = "init",destroyMethod = "myDestroy")
    public TestBean1 testBean1() {
        return new TestBean1();
    }
}

启动项目,结果如下

停止项目效果如下

结论：springIOC容器启动时
1.先执行每个Bean的1-7步骤
2.所有的Bean的前7步骤执行完毕之后，执行每个Bean的8步骤
3.执行每个Bean的8.1步骤
4.执行每个Bean的8.2步骤

又菜又懒001

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
spring Bean生命周期（IOC）

创建过程Spring提供了5个接口用来扩展创建Bean的过程，按照执行顺序排序如下1.BeanNameAware：只有一个抽象方法setBeanName，实现该接口可以重写设置Bean名称2.BeanClassLoaderAware：只有一个抽象方法setBeanClassLoader3.BeanFactoryAware：只有一个抽象方法setBeanFactory，实现该接口可以获取BeanFactory（前提是Bean需要有一个BeanFactory类型的属性）4.Initializing
复制链接

扫一扫