Spring扩展接口BeanFactoryAware,InitializingBean,DisposableBean与bean的生命周期

一、介绍

从一张spring经典bean的生命周期图说起：

接口介绍：

• xxAware接口:包含常见的BeanFactoryAware、BeanFactoryAware、ApplicationContextAware
• BeanPostProcessor接口:方法postProcessBeforeInitialization()、postProcessAfterInitialization(),用于在bean初始化时进行前置、后置处理。
• InitializingBean接口:方法afterPropertiesSet()，顾名思义在Properties配置文件初始化之后调用。
• DisposableBean接口:方法destroy()，bean的生命周期结束前调用。
• init-method方法:初始化方法
• destroy方法:销毁方法

 二、示例

这里整一个demo，如下所示：

BeanFactoryAware,InitializingBean,DisposableBean接口实现类：

public class SpringStartTestBean implements BeanFactoryAware,InitializingBean,DisposableBean {

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware.setBeanFactory() running");
    }

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

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

    public void initMethod(){
        System.out.println("initMethod() running");
    }

    public void destroyMethod(){
        System.out.println("destroyMethod() running");
    }
}

BeanPostProcessor接口实现类：

public class TestBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor.postProcessBeforeInitialization() running|beanName="+beanName);
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor.postProcessAfterInitialization() running|beanName="+beanName);
        return null;
    }
}

spring配置文件：

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName">
 
    <bean id="stringStartTest" class="com.spring.test.SpringStartTestBean" init-method="initMethod" destroy-method="destroyMethod"/>

    <bean id="testBeanPostProcessor" class="com.spring.test.TestBeanPostProcessor" />
</beans>

注：这里可能有小伙伴会问，为什么BeanPostProcessor接口要单独整一个实现类，用第一个类不可以吗？这是因为BeanPostProcessor接口实现类是所有bean共有的，每个bean初始化前后都会调BeanPostProcessor实现类的方法，因此放到某个具体的bean中都不合适。

启动类：

public class Test {
    
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");
        ((ClassPathXmlApplicationContext) context).close();
    }

}

运行结果：

 可见，实现的各个接口方法调用顺序符合原图。

注：

• destroy-method一般作为DisposableBean.destory()方法的替代，二者功能等效，因为DisposableBean.destory()接口实现依赖于Spring，为与Spring解耦可以用destroy-method；
• 两个destroy()方法运行有两个前提：
  • context关闭，如我们实例中的((ClassPathXmlApplicationContext) context).close();
  • bean的scope为singleton，即spring只销毁单例的bean

 三、源码分析

1、bean的创建

前面的跳过，直接通过refash()方法往下调用：

ApplicationContext.refresh()

　　->ApplicationContext.registerBeanPostProcessors()

　　　　->PostProcessorRegistrationDelegate.registerBeanPostProcessors()

　　　　　　->AbstractBeanFactory.getBean()->......

　　　　　　　　->AbstractAutowireCapableBeanFactory.initializeBean()

　　

 在AbstractAutowireCapableBeanFactory.initializeBean()方法中：

如上所示：

invokeAwareMethods()方法调用各个xxAware接口的实现方法，然后调用BeanPostProcessor接口实现的postProcessBeforeInitialization()方法，继而调用init-method指定的方法，最后调用BeanPostProcessor接口实现的postProcessAfterInitialization()方法.

而InitializingBean的接口实现方法调用是在方法invokeInitMethod()中，调用init-method之前：

 2、bean的销毁

spring中bean的销毁由context的销毁触发的，我们从ClassPathXmlApplicationContext.close()方法进入：

AbstractApplicationContext.close()

　　->AbstractApplicationContext.doClose()

　　　　->AbstractApplicationContext.destroyBeans()

　　　　　　->DefaultListableBeanFactory.destroySingletons()

　　　　　　　　->DefaultListableBeanRegistry.destroySingletons()

　　　　　　　　　　->DefaultListableBeanRegistry.destroySingleton()

　　　　　　　　　　　　->DefaultListableBeanRegistry.destroyBean()

　　　　　　　　　　　　　　->DisposableBeanAdapter.destroy()

在DisposableBeanAdapter.destroy()方法中：

    @Override
    public void destroy() {
        if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
            for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
                processor.postProcessBeforeDestruction(this.bean, this.beanName);
            }
        }

        if (this.invokeDisposableBean) {
            if (logger.isTraceEnabled()) {
                logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
            }
            try {
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                        ((DisposableBean) this.bean).destroy();
                        return null;
                    }, this.acc);
                }
                else {
                    ((DisposableBean) this.bean).destroy();//调用DisposableBean接口实现类的destroy()方法
                }
            }
            catch (Throwable ex) {
                String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
                if (logger.isDebugEnabled()) {
                    logger.warn(msg, ex);
                }
                else {
                    logger.warn(msg + ": " + ex);
                }
            }
        }

        if (this.destroyMethod != null) {
            invokeCustomDestroyMethod(this.destroyMethod);//调用destory-Method指定的销毁方法
        }
        else if (this.destroyMethodName != null) {
            Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
            if (methodToInvoke != null) {
                invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
            }
        }
    }

其中，第21行调用了DisposableBean接口实现类的destroy()方法，第36行调用了destroy-method指定的销毁方法。

四、拓展

在spring中我们可以手动调用xxApplicationContext.close()或xxBeanFactory.destroySingletons()来销毁单例的bean，但是如果在web容器或EJB容器中该如何销毁这些bean呢？直接调用xxApplicationContext.close()或xxBeanFactory.destroySingletons()，这可不够丝滑。

javax.servlet-api包已经为web容器准备好了，实现ServletContextListener接口：

public interface ServletContextListener extends EventListener {

    public void contextInitialized(ServletContextEvent sce);

    public void contextDestroyed(ServletContextEvent sce);

}

可见，该接口只提供了两个方法：

contextInitialized():完成context初始化

contextDestroyed():完成context销毁

其中，context.close操作可以封装在contextDestroyed()方法的实现中。

在spring-web包中，已经提供了实现类ContextLoaderListener感兴趣的小伙伴可以看看具体实现。

public class ContextLoaderListener extends ContextLoader implements ServletContextListener {

    public ContextLoaderListener() {
    }

    public ContextLoaderListener(WebApplicationContext context) {
        super(context);
    }

    @Override
    public void contextInitialized(ServletContextEvent event) {
        initWebApplicationContext(event.getServletContext());
    }


    /**
     * Close the root web application context.
     */
    @Override
    public void contextDestroyed(ServletContextEvent event) {
        closeWebApplicationContext(event.getServletContext());
        ContextCleanupListener.cleanupAttributes(event.getServletContext());
    }

}

 

注：文中spring源码基于5.2.8.RELEASE