Spring的Bean的生命周期

最新推荐文章于 2024-09-06 20:17:33 发布

cgm625637391

最新推荐文章于 2024-09-06 20:17:33 发布

阅读量142

点赞数

本文链接：https://blog.csdn.net/cgm625637391/article/details/114488831

版权

参考资料

Spring Bean的生命周期（非常详细） https://www.cnblogs.com/zrtqsk/p/3735273.html
请别再问Spring Bean的生命周期了！ https://www.jianshu.com/p/1dec08d290c1

正文

App.java

package com.example.demoorder;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        System.out.println("#现在开始初始化Spring容器");
        ConfigurableApplicationContext context = SpringApplication.run(App.class, args);
        System.out.println("#Spring容器初始化成功");
        User user = context.getBean("user", User.class);
        System.out.println("#User业务逻辑调用");
        user.show();
        System.out.println("#现在开始关闭Spring容器！");
        context.close();
    }
}

User.java

package com.example.demoorder;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.support.BeanDefinitionReader;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * xxxAware类型的接口的作用就是让我们能够拿到Spring容器中的一些资源。
 */
@Component
public class User implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {
    @Value("${name:wm}")
    private String name;
    @Value("${address:beijing}")
    private String address;

    public String getName() {
        System.out.println("#User getName()");
        return name;
    }

    public void setName(String name) {
        System.out.println("#User setName()注入属性");
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        System.out.println("#User setAddress()注入属性");
        this.address = address;
    }

    public void show() {
        System.out.println("#User{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}');
    }

    public User() {
        System.out.println("#User 构造方法,实例化对象");
    }

    @PostConstruct //初始化方法的注解方式  等同与init-method=init
    public void initMethod() {
        System.out.println("#User init-method 执行对象初始化函数");
    }

    @PreDestroy //销毁方法的注解方式  等同于 destory -method=destory222
    public void destoryMethod() {
        System.out.println("#User destory-method");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("#User BeanFactoryAware.setBeanFactory beanFactory=" + beanFactory + " 获取生成Bean的工厂");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("#User BeanNameAware.setBeanName s=" + s + " 设置bean名称");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("#User InitializingBean.afterPropertiesSet");

    }

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

UserBeanFactoryPostProcessor.java

package com.example.demoorder;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

@Component
public class UserBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public UserBeanFactoryPostProcessor() {
        super();
        System.out.println("#UserBeanFactoryPostProcessor 构造方法");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("#UserBeanFactoryPostProcessor postProcessBeanFactory。获取BeanDefinition并添加age属性");
        BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition("user");
        beanDefinition.getPropertyValues().addPropertyValue("name","cgm");
    }
}

UserBeanPostProcessor.java

package com.example.demoorder;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class UserBeanPostProcessor implements BeanPostProcessor {
    public UserBeanPostProcessor() {
        super();
        System.out.println("#UserBeanPostProcessor 构造方法");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("user")) {
            System.out.println("#UserBeanPostProcessor postProcessBeforeInitialization 在对象初始化函数前对bean属性进行修改");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("user")) {
            System.out.println("#UserBeanPostProcessor postProcessAfterInitialization 在对象初始化函数后对bean属性进行修改");
        }
        return bean;
    }
}

UserInstantiationAwareBeanPostProcessorAdapter.java

package com.example.demoorder;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
import org.springframework.stereotype.Component;

import java.beans.PropertyDescriptor;

@Component
public class UserInstantiationAwareBeanPostProcessorAdapter extends InstantiationAwareBeanPostProcessorAdapter {
    public UserInstantiationAwareBeanPostProcessorAdapter() {
        super();
        System.out.println("#UserInstantiationAwareBeanPostProcessorAdapter 构造方法");
    }

    //接口方法、实例化Bean之前调用
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanName.equals("user")) {
            System.out.println("#UserInstantiationAwareBeanPostProcessorAdapter postProcessBeforeInstantiation 实例化Bean之前调用");
        }
        return null;
    }

    //接口方法、实例化Bean之后调用
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("user")) {
            System.out.println("#UserInstantiationAwareBeanPostProcessorAdapter postProcessAfterInitialization 实例化Bean之后调用");
        }
        return bean;
    }

    // 接口方法、设置某个属性时调用
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        if (beanName.equals("user")) {
            System.out.println("#UserInstantiationAwareBeanPostProcessorAdapter postProcessPropertyValues 设置某个属性时调用");
        }
        return pvs;
    }
}

运行结果

#现在开始初始化Spring容器
#UserBeanFactoryPostProcessor 构造方法
#UserBeanFactoryPostProcessor postProcessBeanFactory。获取BeanDefinition并添加age属性
#UserBeanPostProcessor 构造方法
#UserInstantiationAwareBeanPostProcessorAdapter 构造方法
#UserInstantiationAwareBeanPostProcessorAdapter postProcessBeforeInstantiation 实例化Bean之前调用
#User 构造方法,实例化对象
#UserInstantiationAwareBeanPostProcessorAdapter postProcessPropertyValues 设置某个属性时调用
#User setName()注入属性
#User BeanNameAware.setBeanName s=user 设置bean名称
#User BeanFactoryAware.setBeanFactory beanFactory=org.springframework.beans.factory.support.DefaultListableBeanFactory@36fc695d: defining beans [org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.event.internalEventListenerProcessor,org.springframework.context.event.internalEventListenerFactory,app,org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory,user,userBeanFactoryPostProcessor,userBeanPostProcessor,userInstantiationAwareBeanPostProcessorAdapter,org.springframework.boot.autoconfigure.AutoConfigurationPackages,org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,org.springframework.boot.autoconfigure.condition.BeanTypeRegistry,propertySourcesPlaceholderConfigurer,org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServl...
#UserBeanPostProcessor postProcessBeforeInitialization 在对象初始化函数前对bean属性进行修改
#User init-method 执行对象初始化函数
#User InitializingBean.afterPropertiesSet
#UserBeanPostProcessor postProcessAfterInitialization 在对象初始化函数后对bean属性进行修改
#UserInstantiationAwareBeanPostProcessorAdapter postProcessAfterInitialization 实例化Bean之后调用
#Spring容器初始化成功
#User业务逻辑调用
#User{name='cgm', address='beijing'}
#现在开始关闭Spring容器！
#User destory-method
#User DisposableBean.destroy

生命周期流程图
Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点。

Spring Bean的生命周期只有这四个阶段。实例化和属性赋值对应构造方法和setter方法的注入，初始化和销毁是用户能自定义扩展的两个阶段。
1实例化 Instantiation
2属性赋值 Populate
3初始化 Initialization
4销毁 Destruction

在这四步之间穿插的各种扩展点，就是各类接口的方法。

各种接口方法分类
Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：
1、Bean自身的方法　　：　　这个包括了Bean本身调用的方法和通过配置文件中<bean>的init-method和destroy-method指定的方法
2、Bean级生命周期接口方法　　：　　这个包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法
3、容器级生命周期接口方法　　：　　这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。
4、工厂后处理器接口方法　　：　　这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器　　接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。