Spring 中Bean的生命周期及后置处理器使用

J3code

已于 2022-11-19 13:00:41 修改

阅读量875

点赞数 1

分类专栏： Spring专栏文章标签： spring java servlet

于 2022-09-05 12:23:13 首次发布

本文链接：https://blog.csdn.net/qq_40399646/article/details/126702608

版权

Spring专栏专栏收录该内容

18 篇文章 3 订阅

订阅专栏

内容来自【自学星球】

欢迎大家来了解我的星球，和星主（也就是我）一起学习 Java ，深入 Java 体系中的所有技术。我给自己定的时间是一年，无论结果如何，必定能给星球中的各位带来点东西。

想要了解更多，欢迎访问👉：自学星球

--------------SSM系列源码文章及视频导航--------------

创作不易，望三连支持！

SSM源码解析视频

👉点我

Spring

SpringMVC

MyBatis

---------------------【End】--------------------

一、生命周期

1.1 Bean 指定 init 方法和 destroy 方法

1）编写 People 类

public class People {

    private String name;

    public People() {
        System.out.println(this.getClass().getName() + " 中的空参构造器被调用...");
    }

    public void init() {
        System.out.println(this.getClass().getName() + " 中的 init 被调用...");
    }

    public void destroy() {
        System.out.println(this.getClass().getName() + " 中的 destroy 被调用...");
    }
}

2）在配置类中指定初始化方法和销毁方法

@Configuration
public class StudySpringConfiguration {
    
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public People people() {
        People people = new People();
        people.setName("J3");
        return people;
    }
}

3）测试

public class StudySpringMain {

    public static void main(String[] args) {
        // 读取配置文件启动
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-service.xml");

        People bean = applicationContext.getBean(People.class);
        System.out.println(bean);
        applicationContext.close();
    }
}

2.1 JSR250规范提供的，@PostConstruct 和 @PreDestroy标注的方法

1）编写 People 类

public class People {

    private String name;

    public People() {
        System.out.println(this.getClass().getName() + " 中的空参构造器被调用...");
    }
    @PostConstruct
    public void init() {
        System.out.println(this.getClass().getName() + " 中的 init 被调用...");
    }
    @PreDestroy
    public void destroy() {
        System.out.println(this.getClass().getName() + " 中的 destroy 被调用...");
    }
}

2）在配置类中指定初始化方法和销毁方法

@Configuration
public class StudySpringConfiguration {
    
    @Bean
    public People people() {
        People people = new People();
        people.setName("J3");
        return people;
    }
}

3）测试

public class StudySpringMain {

    public static void main(String[] args) {
        // 读取配置文件启动
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-service.xml");

        People bean = applicationContext.getBean(People.class);
        System.out.println(bean);
        applicationContext.close();
    }
}

二、Bean 的各种后置处理器

2.1 BeanPostProcessor 后置处理器

注意该类需要被扫描到

1）编写 PeopleBeanPostProcessor 实现 BeanPostProcessor 接口

@Component
public class PeopleBeanPostProcessor implements BeanPostProcessor {

    public PeopleBeanPostProcessor() {
        System.out.println(this.getClass().getName() + " 中的空参构造器被调用...");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

        System.out.println(this.getClass().getName() + " 中的 postProcessBeforeInitialization 被调用...");

        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        System.out.println(this.getClass().getName() + " 中的 postProcessAfterInitialization 被调用...");

        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

2）测试

public class StudySpringMain {
    public static void main(String[] args) {
        // 读取配置文件启动
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-service.xml");
    }
}

BeanPostProcessor 是拦截所有 Bean 的创建过程，在初始化方法前后做相关处理

2.2 InitializingBean 及 DisposableBean 后置处理器

1）编写 MyInitializingBean 并实现相关接口

@Component
public class MyInitializingBean implements InitializingBean, DisposableBean {

    public MyInitializingBean() {
        System.out.println(this.getClass().getName() + " 中的空参构造器被调用...");
    }


    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println(this.getClass().getName() + " 中的 afterPropertiesSet 被调用...");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println(this.getClass().getName() + " 中的 destroy 被调用...");
    }
}

2）测试

public class StudySpringMain {
    public static void main(String[] args) {
        // 读取配置文件启动
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-service.xml");
    }
}

InitializingBean 和 DisposableBean 都是作用于当前 Bean ，InitializingBean 在其构造方法执行完成后调用，DisposableBean 在其 Bean 卸载的时候调用。

三、Bean 工厂后置处理器

1）编写实体

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
    // Bean定义加载完成调用，调用一次（所有Bean加载完成之后，才会执行）
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println(this.getClass().getName() + " 中的 postProcessBeanFactory 被调用...");
    }
}

执行时机：所有 Bean 定义被加载到 BeanDefinition 中时才进行执行。

那么这就给我们留下了很多做小动作的事情，因为此时 Bean 只是加载了配置，还未进行任何实例化。如，我们可以对加载的 Bean 是否单例进行修改等。

四、BeanDefinitionRegistryPostProcessor 后置处理器

1）编写实体

public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
        // Bean定义还未开始加载之前调用，调用一次
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        System.out.println(this.getClass().getName() + " 中的 postProcessBeanDefinitionRegistry 被调用...");
    }

        // Bean定义加载完成调用，调用一次
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println(this.getClass().getName() + " 中的 postProcessBeanFactory 被调用...");
    }
}