Java Spring Bean的生命周期管理详解

目录

• Spring Bean的生命周期管理
• 一、Spring Bean的生命周期
• 二、通过@Bean的参数（initMethod ,destroyMethod）指定Bean的初始化和销毁方法
• 1、项目结构
• 2、Person
• 3、Bean注册配置类（单实例）
• 4、测试类
• 5、测试结果
• 6、Bean注册配置类（多实例）
• 7、测试结果
• 三、Bean实现接口InitializingBean, DisposableBean
• 1、Person
• 2、Bean注册配置类
• 3、测试结果
• 四、通过注解@PostConstruct和@PreDestroy
• 1、Person
• 2、测试结果
• 五、使用接口BeanPostProcessor实现类（后置处理器）
• 1、项目结构
• 2、Person
• 3、Bean注册配置类
• 4、BeanPostProcessor实现类（后置处理器）
• 5、测试结果
• 总结
  

Spring Bean的生命周期管理

一、Spring Bean的生命周期

通过以下方式来指定Bean的初始化和销毁方法，
当Bean为单例时，Bean归Spring容器管理，Spring容器关闭，就会调用Bean的销毁方法
当Bean为多例时，Bean不归Spring容器管理，Spring容器关闭，不会调用Bean的销毁方法

二、通过@Bean的参数（initMethod ,destroyMethod）指定Bean的初始化和销毁方法

1、项目结构

2、Person

public class Person {
    public Person(){
        System.out.println(\"Person 创建了...\");
    }
    public void init(){
        System.out.println(\"Person 初始化了...\");
    }
    public void destroy(){
        System.out.println(\"Person 被销毁了...\");
    }
}

3、Bean注册配置类（单实例）

import com.dashu.bean.Person;
import org.springframework.context.annotation.*;
@Configuration
public class BeanConfig {
    @Bean(initMethod = \"init\",destroyMethod = \"destroy\")
    public Person person(){
        return new Person();
    }
}

4、测试类

import com.dashu.bean.Person;
import com.dashu.config.BeanConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Main {
    public static void main(String[] args) {
        //加载配置类获取容器
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(BeanConfig.class);
        //获取Bean
        Person bean = annotationConfigApplicationContext.getBean(Person.class);
        //关闭容器
        annotationConfigApplicationContext.close();
    }
}

5、测试结果

6、Bean注册配置类（多实例）

import com.dashu.bean.Person;
import org.springframework.context.annotation.*;
@Configuration
public class BeanConfig {
    @Scope(\"prototype\")
    @Bean(initMethod = \"init\",destroyMethod = \"destroy\")
    public Person person(){
        return new Person();
    }
}

7、测试结果

三、Bean实现接口InitializingBean, DisposableBean

1、Person

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
public class Person implements InitializingBean, DisposableBean {
    public Person(){
        System.out.println(\"Person 创建了...\");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println(\"Person 初始化了...\");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println(\"Person 被销毁了...\");
    }
}

2、Bean注册配置类

import com.dashu.bean.Person;
import org.springframework.context.annotation.*;
@Configuration
public class BeanConfig {
    @Bean
    public Person person(){
        return new Person();
    }
}

3、测试结果

四、通过注解@PostConstruct和@PreDestroy

@PostConstruct：标注在Bean的初始化方法上
@PreDestroy：标注在Bean的销毁方法上

1、Person

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class Person {
    public Person(){
        System.out.println(\"Person 创建了...\");
    }
    @PostConstruct
    public void init(){
        System.out.println(\"Person 初始化了...\");
    }
    @PreDestroy
    public void destroy(){
        System.out.println(\"Person 被销毁了...\");
    }
}

2、测试结果

五、使用接口BeanPostProcessor实现类（后置处理器）

1、项目结构

2、Person

import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Component
public class Person {
    public Person(){
        System.out.println(\"Person 创建了...\");
    }
    @PostConstruct
    public void init(){
        System.out.println(\"Person 初始化了...\");
    }
    @PreDestroy
    public void destroy(){
        System.out.println(\"Person 被销毁了...\");
    }
}

3、Bean注册配置类

import org.springframework.context.annotation.*;
@Configuration
@ComponentScan({\"com.dashu\"})
public class BeanConfig {
}

4、BeanPostProcessor实现类（后置处理器）

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
/**
 * 后置处理器：初始化前后进行处理工作
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * 初始化之前工作
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(\"初始化之前...\"+beanName+\"=[\"+bean+\"]\");
        return bean;
    }
    /**
     * 初始化之后工作
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public  Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(\"初始化之后...\"+beanName+\"=[\"+bean+\"]\");
        return bean;
    }
}

5、测试结果

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注的更多内容!