自学内容网 自学内容网

Spring Bean的生命周期


注:这里说的 Spring Bean 的生命周期指的是 singleton bean,对于 prototype 的 bean ,Spring 在创建好交给使用者之后则不会再管理后续的生命周期,所以IOC容器不会调用销毁方法。

一、知识点

4 个阶段:
实例化(Instantiation)
属性赋值(Populate)
初始化(Initialization)
销毁(Destruction)

在这里插入图片描述

二、源码分析

// AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {

    // 1. 实例化
    BeanWrapper instanceWrapper = null;
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    
    Object exposedObject = bean;
    try {
        // 2. 属性赋值
        populateBean(beanName, mbd, instanceWrapper);
        // 3. 初始化
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }

    // 4. 销毁-注册回调接口
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }

    return exposedObject;
}

// AbstractAutowireCapableBeanFactory.java
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    // 3. 检查 Aware 相关接口并设置相关依赖
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        invokeAwareMethods(beanName, bean);
    }

    // 4. BeanPostProcessor 前置处理
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    // 5. 若实现 InitializingBean 接口,则调用 afterPropertiesSet() 方法,在属性注入完成后调用
    // 6. 若配置自定义的 init-method方法,则执行
    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
    }
    // 7. BeanPostProceesor 后置处理
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

// DisposableBeanAdapter.java
public void destroy() {
    // 9. 若实现 DisposableBean 接口,则执行 destory()方法
    if (this.invokeDisposableBean) {
        try {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                    ((DisposableBean) this.bean).destroy();
                    return null;
                }, this.acc);
            }
            else {
                ((DisposableBean) this.bean).destroy();
            }
        }
    }
    
// 10. 若配置自定义的 detory-method 方法,则执行
    if (this.destroyMethod != null) {
        invokeCustomDestroyMethod(this.destroyMethod);
    }
    else if (this.destroyMethodName != null) {
        Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
        if (methodToInvoke != null) {
            invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
        }
    }
}

三、扩展

这些接口的实现类是独立于 Bean 的,并且会注册到 Spring 容器中。在 Spring 容器创建任何 Bean 的时候,这些后处理器都会发生作用。

1、InstantiationAwareBeanPostProcessor

该类是 BeanPostProcessor 的子接口,常用的有如下三个方法:
postProcessBeforeInstantiation(Class beanClass, String beanName):在bean实例化之前调用
postProcessProperties(PropertyValues pvs, Object bean, String beanName):在bean实例化之后、构造方法前调用
postProcessAfterInstantiation(Class beanClass, String beanName):在实例化 Bean 之后、构造方法之后调用

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

2、Aware

组件的“觉醒”
Aware 之前的名字就是可以拿到什么资源,例如 BeanNameAware 可以拿到 BeanName,以此类推。
调用时机:所有的 Aware 方法都是在初始化阶段之前调用的


若 Spring 检测到 bean 实现了 Aware 接口,则会为其注入相应的依赖。
–> 通过让 bean 实现 Aware 接口,则能在 bean 中获得相应的 Spring 容器资源。


当组件实现Aware接口的时候,会实现Aware接口里提供的 setXXX方法
这些 setXXX方法可以让组件对象获取一些信息,形参中会包含对应的信息,比如组件在容器中的组件id等


BeanFactory 类型的容器

Spring 中提供的 Aware 接口:
BeanNameAware:该接口只有一个方法 setBeanName(String name),用来获取 bean 的 id 或者 name。
BeanClassLoaderAware:该接口只有一个方法 setBeanClassLoader(ClassLoader bc1),用来获取 bean 的 ClassLoader。
BeanFactoryAware:该接口只有一个方法 setBeanFactory(BeanFactory beanFactory),用来获取当前环境中的 BeanFactory。

// AbstractAutowireCapableBeanFactory.java
private void invokeAwareMethods(final String beanName, final Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
            
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

ApplicationContext 类型的容器

Spring 中提供的 Aware 接口:常用:
ApplicationContextAware:该接口只有一个方法 setApplicationContext(ApplicationContext applicationContext),用来获取当前环境中的 ApplicationContext。

// ApplicationContextAwareProcessor.java
private void invokeAwareInterfaces(Object bean) {
    if (bean instanceof EnvironmentAware) { // 注入 Enviroment,一般用于获取配置属性
        ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
    }
    if (bean instanceof EmbeddedValueResolverAware) { // 注入 EmbeddedValueResolver(Spring EL解析器),一般用于参数解析
        ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
    }
    if (bean instanceof ResourceLoaderAware) {
        ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
    }
    if (bean instanceof ApplicationEventPublisherAware) {
        ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
    }
    if (bean instanceof MessageSourceAware) {
        ((MessageSourceAware)bean).setMessageSource(this.applicationContext);
    }
    if (bean instanceof ApplicationContextAware) {
        ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
    }
}

2、BeanPostProcessor

BeanPostProcessor 是 Spring 为修改 bean 提供的强大扩展点,其可作用于容器中除它本身外所有 bean
常用于:为当前对象提供代理实现。例如 Spring AOP 功能,生成对象的代理类,然后返回

该接口有两个方法:
postProcessBeforeInitialization(Object bean, String beanName):初始化前置处理,在初始化之前调用此方法
postProcessAfterInitialization(Object bean, String beanName):初始化后置处理,在初始化之后调用此方法

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}
// AbstractAutoProxyCreator.java
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
        this.proxyTypes.put(cacheKey, proxy.getClass());
        // 返回代理类
        return proxy;
    }
    return null;
}

四、实例

1、注解方式

dao层:

@Getter
@ToString
@Repository
public class UserDao implements InitializingBean, BeanNameAware, DisposableBean, ApplicationContextAware {

    private Integer id;
    private String name;

    // 1-1. 实例化 Bean 实例:调用构造方法
    public UserDao(Integer id, String name) {
        this.id = id;
        this.name = name;
        System.out.println("调用全参构造函数");
    }

    // 1-1. 实例化 Bean 实例:调用构造方法
    // 具体使用哪一个构造方式看 new 对象
    public UserDao() {
        System.out.println("调用无参构造函数");
    }

    // 2. 设置对象属性 属性注入
    public void setId(Integer id) {
        this.id = id;
        System.out.println("\n2. 设置对象属性");
        System.out.println("id属性注入");
    }

    // 2. 设置对象属性 属性注入
    public void setName(String name) {
        this.name = name;
        System.out.println("name属性注入");
    }

    // 3. 初始化--检查 Aware 相关接口并设置相关依赖
    // BeanNameAware 下的 setBeanName 方法
    @Override
    public void setBeanName(String name) {
        System.out.println("\n3. 初始化");
        System.out.println("调用 BeanNameAware.setBeanName() 方法");
    }

    // 3。 初始化--检查 Aware 相关接口并设置相关依赖
    // ApplicationContextAware 下的 setApplicationContext 方法
    // if (bean instanceof ApplicationContextAware) {
    //        ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
    //    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        System.out.println("3. 检查 Aware 相关接口并设置相关依赖---调用 ApplicationContextAware.setApplicationContext() 方法");
    }

    // 4. BeanPostProcessor 前置处理 见 MyBeanPostProcessor类

    // 5. 初始化--是否实现 InitializingBean 接口
    // InitializingBean 下的 afterPropertiesSet 方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5. 是否实现 InitializingBean 接口---调用 InitializingBean.afterPropertiesSet() 方法");
    }

    // 6. 初始化--是否配置自定义的 init-method
    public void myInit() {
        System.out.println("6. 是否配置自定义的 init-method---调用 init-method 方法");
    }

    // 7. BeanPostProcessor 后置处理 见 MyBeanPostProcessor类

    // 8. 注册 Destruction 相关回调接口 略

    // 9. 销毁--是否实现 DisposableBean 接口
    // DisposableBean 下的 destroy 方法
    @Override
    public void destroy() throws Exception {
        System.out.println("\n4. 销毁");
        System.out.println("调用 DisposableBean.destroy() 方法");
    }

    // 10. 销毁--是否配置自定义的 destroy-method
    public void myDestroy() throws Exception {
        System.out.println("调用 destroy-method 方法");
    }
}

@Repository
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    // 1-0. 实例化 Bean 实例
    // InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation() 方法 在实例化 Bean 之前调用
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("userDao".equals(beanName)) {
            System.out.println("1. 实例化 Bean 实例");
            System.out.println("调用 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation() 方法");
        }
        return null;
    }

    // 1-1. 实例化 Bean 实例:调用全参构造方法 见 UserDao

    // 1-2. 实例化 Bean 实例
    // InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法 在实例化 Bean 之后、构造方法之前调用
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("userDao".equals(beanName)) {
            UserDao userDao = (UserDao) bean;
            System.out.println("调用 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法");
        }
        return true;
    }

    // 1-3. 实例化 Bean 实例
    // InstantiationAwareBeanPostProcessor.postProcessProperties() 方法 在实例化 Bean 之后、构造方法之后调用
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if ("userDao".equals(beanName)) {
            System.out.println("调用 InstantiationAwareBeanPostProcessor.postProcessProperties() 方法");
        }
        return null;
    }
}

@Repository
public class MyBeanPostProcessor implements BeanPostProcessor {

    // 4. 初始化--BeanPostProcessor 前置处理
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userDao".equals(beanName)) {
            System.out.println("4. BeanPostProcessor 前置处理---调用 BeanPostProcessor.postProcessBeforeInitialization() 方法");
        }
        return bean;
    }

    // 7.初始化--BeanPostProcessor 后置处理
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userDao".equals(beanName)) {
            System.out.println("7. BeanPostProcessor 后置处理---调用 BeanPostProcessor.postProcessAfterInitialization() 方法");
        }
        return bean;
    }
}

配置类:
@Configuration
public class MyConfig {

    // @Bean(initMethod = "myInit", destroyMethod = "destroy") // 不执行 myDestroy
    @Bean(initMethod = "myInit", destroyMethod = "myDestroy") // 执行 myDestroy 和 destroy
    public UserDao userDao() {
        return  new UserDao(23, "xiaoyu-alive");
    }

    @Bean
    public MyInstantiationAwareBeanPostProcessor myInstantiationAwareBeanPostProcessor() {
        return  new MyInstantiationAwareBeanPostProcessor();
    }

    @Bean
    public MyBeanPostProcessor myBeanPostProcessor() {
        return  new MyBeanPostProcessor();
    }
}

测试类:

@SpringBootTest
public class SpringbootdemoApplicationTests {

    @Test
    public void test() throws Exception {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
        Object userDao = applicationContext.getBean("userDao");
        // 销毁方法只有在IOC容器关闭的时候才调用,所以在测试代码中关闭IOC容器
        //关闭ioc容器
        applicationContext.close();
    }
}

在这里插入图片描述

2、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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean class="com.test.springbootdemo.dao.MyInstantiationAwareBeanPostProcessor"></bean>

    <bean id="userDao" class="com.test.springbootdemo.dao.UserDao">
        <property name="id" value="23"/>
        <property name="name" value="xiaoyu-alive"></property>
    </bean>

    <bean class="com.test.springbootdemo.dao.MyBeanPostProcessor"></bean>
</beans>

@Test
public void mytest() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml"); // 也可以使用绝对路径
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    ((AbstractApplicationContext) applicationContext).close();
}

测试结果同上

注:取消 MyInstantiationAwareBeanPostProcessor 和 MyBeanPostProcessor 的注入的测试结果:

在这里插入图片描述



参考:

如何记忆 Spring Bean 的生命周期

Spring注解(六):Bean的生命周期中自定义初始化和销毁方法的四种方式

一文读懂 Spring Bean 的生命周期


原文地址:https://blog.csdn.net/xiaoyu_alive/article/details/135740524

免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!