SpringBean这一生要经历什么？_spring一个bean的实用经历-CSDN博客

本文链接：https://blog.csdn.net/weixin_46306369/article/details/121708353

【每周一文】每天闲暇时间会来看一些“大鸟的输出”，学到很多知识，但忘的也快，所以给自己立个flag，把学到的东西记录下来，让它在脑子里停留时间更长一些，开始每周一文，话不多说，Iet’s go…

开篇

对于日常通过关键字new创建的Bean（对象），会经历实例化、初始化、销毁，都是JVM在帮我们运作，今天，我们来探讨一下Spring是如何管理Bean的。

一、SpringBean的一生（执行顺序）

在这里插入图片描述

二、代码测试

代码测试结果：

==========Spring容器初始化开始==========
12月 03, 2021 11:46:31 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@6b143ee9: startup date [Fri Dec 03 23:46:31 CST 2021]; root of context hierarchy
12月 03, 2021 11:46:31 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
【1、BeanFactoryPostProcessor】调用BeanFactoryPostProcessor接口
【2、BeanFactoryPostProcessor】调用BeanFactoryPostProcessor的postProcessBeanFactory方法
【3、InstantiationAwareBeanPostProcessor】调用InstantiationAwareBeanPostProcessor接口的构造方法
【4、InstantiationAwareBeanPostProcessor】实例化Bean之前：调用InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法
【5、Bean实例化】执行Bean的无参构造函数
【6、InstantiationAwareBeanPostProcessor】调用InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues方法
【7、Bean属性设置】执行Bean的set方法,设置Bean属性值
【8、BeanNameAware】执行BeanNameAware中setBeanName方法，beanName值：beanCycleStudy
【9、BeanClassLoaderAware】执行BeanClassLoaderAware中setBeanClassLoader,ClassLoader的name = jdk.internal.loader.ClassLoaders$AppClassLoader
【10、BeanFactoryAware】执行BeanFactoryAware中setBeanFactory,beanFactory中是否包含IocBeanLifeService：false
【11、EnvironmentAware】执行EnvironmentAware的setEnvironment方法
【12、ResourceLoaderAware】执行ResourceLoaderAware的setResourceLoader方法，Resource File Name=applicationContext.xml
【13、ApplicationEventPublisherAware】执行ApplicationEventPublisherAware中setApplicationEventPublisher方法
【14、ApplicationContextAware】执行ApplicationContextAware的setApplicationContext方法，Bean Definition Names=[org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#0, beanCycleStudy, bean.MyBeanPostProcessor#0, bean.MyBeanFactoryPostProcessor#0, bean.MyInstantiationAwareBeanPostProcessor#0]
【15、postProcessBeforeInitialization】执行BeanPostProcessor中postProcessBeforeInitialization方法,beanName=beanCycleStudy
【16、@PostConstruct】执行PostConstruct注解标注的方法
【17、InitializingBean】执行InitializingBean的afterPropertiesSet方法
【18、init-method】执行指定的init-method
【19、postProcessAfterInitialization】执行BeanPostProcessor的postProcessAfterInitialization方法,beanName=beanCycleStudy
【20、InstantiationAwareBeanPostProcessor】调用InstantiationAwareBeanPostProcessor接口的postProcessAfterInitialization方法
==========Spring容器初始化完毕==========
从容器中获取Bean
Bean本尊：BeanCycleStudy{property='myProperty'},开始执行Bean的业务逻辑。。。
==========Spring容器准备销毁==========
12月 03, 2021 11:46:32 下午 org.springframework.context.support.AbstractApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@6b143ee9: startup date [Fri Dec 03 23:46:31 CST 2021]; root of context hierarchy
【21、@PreDestroy】执行preDestroy注解标注的方法
【22、DisposableBean】执行DisposableBean接口的destroy方法
【23、destroy-method】执行配置的destroy-method
==========Spring容器销毁完成==========

Process finished with exit code 0

代码：

主测试类：
public class BeanLifeTest {

    @Test
    public void test(){
        System.out.println("==========Spring容器初始化开始==========");

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        System.out.println("==========Spring容器初始化完毕==========");

        System.out.println("从容器中获取Bean");
        BeanCycleStudy beamCycleStudy = context.getBean("beanCycleStudy", BeanCycleStudy.class);

        System.out.println("Bean本尊："+beamCycleStudy+",开始执行Bean的业务逻辑。。。");

        System.out.println("==========Spring容器准备销毁==========");
        context.close();
        System.out.println("==========Spring容器销毁完成==========");
    }
}

BeanFactoryProcessor的实现类：

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public MyBeanFactoryPostProcessor(){
        System.out.println("【1、BeanFactoryPostProcessor】调用BeanFactoryPostProcessor接口");
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("【2、BeanFactoryPostProcessor】调用BeanFactoryPostProcessor的postProcessBeanFactory方法");
    }
}

BeanPostProcessor-InstantiationAwareBeanPostProcessorAdapter的实现类 :

public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter  {
    public MyInstantiationAwareBeanPostProcessor() {
        System.out.println("【3、InstantiationAwareBeanPostProcessor】调用InstantiationAwareBeanPostProcessor接口的构造方法");
    }

    /**
     * 实例化Bean之前调用
     */
    @Override
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        System.out.println("【4、InstantiationAwareBeanPostProcessor】实例化Bean之前：调用InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法");
        return null;
    }

    /**
     * 实例化Bean之后调用
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【20、InstantiationAwareBeanPostProcessor】调用InstantiationAwareBeanPostProcessor接口的postProcessAfterInitialization方法");
        return bean;
    }

    /**
     * 设置某个属性时调用
     */
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
            throws BeansException {
        System.out.println("【6、InstantiationAwareBeanPostProcessor】调用InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues方法");
        return pvs;
    }
}

BeanPostProcessor的实现类：

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【15、postProcessBeforeInitialization】执行BeanPostProcessor中postProcessBeforeInitialization方法,beanName=" + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【19、postProcessAfterInitialization】执行BeanPostProcessor的postProcessAfterInitialization方法,beanName=" + beanName);
        return bean;
    }


}

Aware子类以及配置方法的实现：

public class BeanCycleStudy implements InitializingBean,DisposableBean,ApplicationContextAware,
        ApplicationEventPublisherAware, BeanClassLoaderAware, BeanFactoryAware,
        BeanNameAware, EnvironmentAware, ImportAware, ResourceLoaderAware{

    private String property;

    public String getProperty() {
        return property;
    }

    @Override
    public String toString() {
        return "BeanCycleStudy{" +
                "property='" + property + '\'' +
                '}';
    }

    public BeanCycleStudy(){
        System.out.println("【5、Bean实例化】执行Bean的无参构造函数");
    }

    public void setProperty(String property) {
        System.out.println("【7、Bean属性设置】执行Bean的set方法,设置Bean属性值" );
        this.property = property;
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("【8、BeanNameAware】执行BeanNameAware中setBeanName方法，beanName值："
                + s);
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("【9、BeanClassLoaderAware】执行BeanClassLoaderAware中setBeanClassLoader,ClassLoader的name = " + classLoader.getClass().getName());
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("【10、BeanFactoryAware】执行BeanFactoryAware中setBeanFactory,beanFactory中是否包含IocBeanLifeService：" + beanFactory.containsBean("iocBeanLifeService"));
    }

    @Override
    public void setEnvironment(Environment environment) {
        System.out.println("【11、EnvironmentAware】执行EnvironmentAware的setEnvironment方法");
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        Resource resource = resourceLoader.getResource("classpath:applicationContext.xml");
        System.out.println("【12、ResourceLoaderAware】执行ResourceLoaderAware的setResourceLoader方法，Resource File Name="
                + resource.getFilename());

    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        System.out.println("【13、ApplicationEventPublisherAware】执行ApplicationEventPublisherAware中setApplicationEventPublisher方法");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("【14、ApplicationContextAware】执行ApplicationContextAware的setApplicationContext方法，Bean Definition Names="
                + Arrays.toString(applicationContext.getBeanDefinitionNames()));

    }

    @PostConstruct
    public void initPostConstruct(){
        System.out.println("【16、@PostConstruct】执行PostConstruct注解标注的方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【17、InitializingBean】执行InitializingBean的afterPropertiesSet方法");

    }

    /**
     * init-method配置的实现方法
     */
    public void initMethod() throws Exception {
        System.out.println("【18、init-method】执行指定的init-method");
    }

    @PreDestroy
    public void preDestroy(){
        System.out.println("【21、@PreDestroy】执行preDestroy注解标注的方法");
    }


    @Override
    public void destroy() throws Exception {
        System.out.println("【22、DisposableBean】执行DisposableBean接口的destroy方法");
    }

    /**
     * destroy-method配置的实现方法
     */
    public void destroyMethod() throws Exception {
        System.out.println("【23、destroy-method】执行配置的destroy-method");
    }

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

applicationContext.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />

    <bean name="beanCycleStudy" class="bean.BeanCycleStudy" init-method="initMethod" destroy-method="destroyMethod">
        <property name="property" value="myProperty"></property>
    </bean>
    <bean class="bean.MyBeanPostProcessor"/>
    <bean class="bean.MyBeanFactoryPostProcessor"/>
    <bean class="bean.MyInstantiationAwareBeanPostProcessor"/>
</beans>

总结：

SpringBean的执行顺序：

Spring启动时，会根据Bean配置通过反射机制去实例化Bean；
实例化前，会实例化BeanFactoryPostProcessor的实现类（触发构造方法）、调用实现类的postProcessBeanFactory方法；
实例化BeanPostProcessor的实现类（触发构造方法）、调用实现类的postProcessBeforeInstantiation方法；
实例化Bean，触发其无参构造方法；
设置Bean的属性值前，调用BeanPostProcessor的实现类的postProcessPropertyValues方法；
设置Bean的属性值，调用Bean的set属性方法；
顺序调用Aware的各个实现类，如：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware、EnvironmentAware、ResourceLoaderAware…
初始化Bean，会顺序执行**@PostConstruct**注解配置的方法；
执行InitializingBean接口的afterPropertiesSet方法；
执行Bean配置中init-method指定的方法；
执行BeanPostProcessor接口及其实现类的postProcessAfterInitialization方法
初始化完成后，开始获取Bean，执行Bean中的业务逻辑；
销毁Bean，会顺序执行**@PreDestroy**注解配置的方法；
执行DisposableBean接口的destroy方法；
执行Bean配置中destroy-method指定的方法；
over…