搞懂這道百度面試題:Spring 中 Bean 的生命週期 前言 一、Bean 的完整生命週期 Bean 完整的生命週期 二、Bean 的生命週期驗證

前言

這其實是一道面試題,是我在面試百度的時候被問到的,當時沒有答出來(因爲自己真的很菜),後來在網上尋找答案,看到也是一頭霧水,直到看到了《Spring in action》這本書,書上有對Bean聲明週期的大致解釋,但是沒有代碼分析,所以就自己上網尋找資料,一定要把這個Bean生命週期弄明白!

​ 網上大部分都是驗證的Bean 在面試問的生命週期,其實查閱JDK還有一個完整的Bean生命週期,這同時也驗證了書是具有片面性的,最fresh 的資料還是查閱原始JDK!!!

一、Bean 的完整生命週期

​ 在傳統的Java應用中,bean的生命週期很簡單,使用Java關鍵字 new 進行Bean 的實例化,然後該Bean 就能夠使用了。一旦bean不再被使用,則由Java自動進行垃圾回收。

​ 相比之下,Spring管理Bean的生命週期就複雜多了,正確理解Bean 的生命週期非常重要,因爲Spring對Bean的管理可擴展性非常強,下面展示了一個Bean的構造過程

如上圖所示,Bean 的生命週期還是比較複雜的,下面來對上圖每一個步驟做文字描述:

  1. Spring啓動,查找並加載需要被Spring管理的bean,進行Bean的實例化
  2. Bean實例化後對將Bean的引入和值注入到Bean的屬性中
  3. 如果Bean實現了BeanNameAware接口的話,Spring將Bean的Id傳遞給setBeanName()方法
  4. 如果Bean實現了BeanFactoryAware接口的話,Spring將調用setBeanFactory()方法,將BeanFactory容器實例傳入
  5. 如果Bean實現了ApplicationContextAware接口的話,Spring將調用Bean的setApplicationContext()方法,將bean所在應用上下文引用傳入進來
  6. 如果Bean實現了BeanPostProcessor接口,Spring就將調用他們的postProcessBeforeInitialization()方法。
  7. 如果Bean 實現了InitializingBean接口,Spring將調用他們的afterPropertiesSet()方法。類似的,如果bean使用init-method聲明瞭初始化方法,該方法也會被調用
  8. 如果Bean 實現了BeanPostProcessor接口,Spring就將調用他們的postProcessAfterInitialization()方法。
  9. 此時,Bean已經準備就緒,可以被應用程序使用了。他們將一直駐留在應用上下文中,直到應用上下文被銷燬。
  10. 如果bean實現了DisposableBean接口,Spring將調用它的destory()接口方法,同樣,如果bean使用了destory-method 聲明銷燬方法,該方法也會被調用。

上面是Spring 中Bean的核心接口和生命週期,面試回答上述過程已經足夠了。但是翻閱JavaDoc文檔發現除了以上接口外,還有另外的初始化過程涉及的接口:

摘自org.springframework.beans.factory.BeanFactory, 全部相關接口如下,上述已有的就不用着重標註,把額外的相關接口着重標註下

​ Bean 完整的生命週期

文字解釋如下:

————————————初始化————————————

  • BeanNameAware.setBeanName() 在創建此bean的bean工廠中設置bean的名稱,在普通屬性設置之後調用,在InitializinngBean.afterPropertiesSet()方法之前調用
  • BeanClassLoaderAware.setBeanClassLoader() : 在普通屬性設置之後,InitializingBean.afterPropertiesSet()之前調用
  • BeanFactoryAware.setBeanFactory() : 回調提供了自己的bean實例工廠,在普通屬性設置之後,在InitializingBean.afterPropertiesSet()或者自定義初始化方法之前調用
  • EnvironmentAware.setEnvironment() : 設置environment在組件使用時調用
  • EmbeddedValueResolverAware.setEmbeddedValueResolver() : 設置StringValueResolver 用來解決嵌入式的值域問題
  • ResourceLoaderAware.setResourceLoader() : 在普通bean對象之後調用,在afterPropertiesSet 或者自定義的init-method 之前調用,在 ApplicationContextAware 之前調用。
  • ApplicationEventPublisherAware.setApplicationEventPublisher() : 在普通bean屬性之後調用,在初始化調用afterPropertiesSet 或者自定義初始化方法之前調用。在 ApplicationContextAware 之前調用。
  • MessageSourceAware.setMessageSource() : 在普通bean屬性之後調用,在初始化調用afterPropertiesSet 或者自定義初始化方法之前調用,在 ApplicationContextAware 之前調用。
  • ApplicationContextAware.setApplicationContext(): 在普通Bean對象生成之後調用,在InitializingBean.afterPropertiesSet之前調用或者用戶自定義初始化方法之前。在ResourceLoaderAware.setResourceLoader,ApplicationEventPublisherAware.setApplicationEventPublisher,MessageSourceAware之後調用。
  • ServletContextAware.setServletContext() : 運行時設置ServletContext,在普通bean初始化後調用,在InitializingBean.afterPropertiesSet之前調用,在 ApplicationContextAware 之後調用 注:是在WebApplicationContext 運行時
  • BeanPostProcessor.postProcessBeforeInitialization() : 將此BeanPostProcessor 應用於給定的新bean實例 在任何bean初始化回調方法(像是InitializingBean.afterPropertiesSet或者自定義的初始化方法)之前調用。這個bean將要準備填充屬性的值。返回的bean示例可能被普通對象包裝,默認實現返回是一個bean。
  • BeanPostProcessor.postProcessAfterInitialization() : 將此BeanPostProcessor 應用於給定的新bean實例 在任何bean初始化回調方法(像是InitializingBean.afterPropertiesSet或者自定義的初始化方法)之後調用。這個bean將要準備填充屬性的值。返回的bean示例可能被普通對象包裝
  • InitializingBean.afterPropertiesSet(): 被BeanFactory在設置所有bean屬性之後調用(並且滿足BeanFactory 和 ApplicationContextAware)。

————————————銷燬————————————

在BeanFactory 關閉的時候,Bean的生命週期會調用如下方法:

DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()

二、Bean 的生命週期驗證

爲了驗證Bean生命週期的過程,有兩種形式:一種是爲面試而準備的,一種是爲了解全過程而準備的,下面來看代碼:

  • Book.class
public class Book implements BeanNameAware,BeanFactoryAware,
        ApplicationContextAware,InitializingBean,DisposableBean {

    private String bookName;
    public Book(){
        System.out.println("Book Initializing ");
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("Book.setBeanFactory invoke");
    }

    public void setBeanName(String name) {
        System.out.println("Book.setBeanName invoke");
    }

    public void destroy() throws Exception {
        System.out.println("Book.destory invoke");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("Book.afterPropertiesSet invoke");
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("Book.setApplicationContext invoke");
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
        System.out.println("setBookName: Book name has set.");
    }

    public void myPostConstruct(){
        System.out.println("Book.myPostConstruct invoke");
    }

     // 自定義初始化方法
    @PostConstruct
    public void springPostConstruct(){
        System.out.println("@PostConstruct");
    }

    public void myPreDestory(){
        System.out.println("Book.myPreDestory invoke");
        System.out.println("---------------destroy-----------------");
    }

    // 自定義銷燬方法
    @PreDestroy
    public void springPreDestory(){
        System.out.println("@PreDestory");
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("------inside finalize-----");
    }
}
  • 自定義實現BeanPostProcessor 的MyBeanPostProcessor:
public class MyBeanPostProcessor implements BeanPostProcessor {

    // 容器加載的時候會加載一些其他的bean,會調用初始化前和初始化後方法
    // 這次只關注book(bean)的生命週期
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if(bean instanceof Book){
            System.out.println("MyBeanPostProcessor.postProcessBeforeInitialization");
        }
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if(bean instanceof Book){
            System.out.println("MyBeanPostProcessor.postProcessAfterInitialization");
        }
        return bean;
    }
}
  • 在resources 目錄下新建Bean-Lifecycle.xml
<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
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 掃描bean -->
    <context:component-scan base-package="com.bean.lifecycle"/>

    <!-- 實現了用戶自定義初始化和銷燬方法 -->
    <bean id="book" class="com.bean.lifecycle.Book" init-method="myPostConstruct" destroy-method="myPreDestory">
        <!-- 注入bean 屬性名稱 -->
        <property name="bookName" value="thingking in java" />
    </bean>

    <!--引入自定義的BeanPostProcessor-->
    <bean class="com.bean.lifecycle.MyBeanPostProcessor"/>

</beans>
  • 做一個啓動類的測試,新建SpringBeanLifecycleApplication
public class SpringBeanLifecycleApplication {

    public static void main(String[] args) throws InterruptedException {
        // 爲面試而準備的Bean生命週期加載過程
        ApplicationContext context = new ClassPathXmlApplicationContext("Bean-Lifecycle.xml");
        Book book = (Book)context.getBean("book");
        System.out.println("Book name = " + book.getBookName());
        ((ClassPathXmlApplicationContext) context).destroy();

    }

}

啓動測試,輸出結果如下:

Book Initializing setBookName: Book name has set. Book.setBeanName invoke Book.setBeanFactory invoke Book.setApplicationContext invoke MyBeanPostProcessor.postProcessBeforeInitialization @PostConstruct Book.afterPropertiesSet invoke Book.myPostConstruct invoke MyBeanPostProcessor.postProcessAfterInitialization Book name = thingking in java

@PreDestory Book.destory invoke Book.myPreDestory invoke ---------------destroy-----------------

  • 爲了驗證Bean完整的生命週期,需要新建一個SubBookClass 繼承Book類
public class SubBookClass extends Book implements BeanClassLoaderAware,
        EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware,
        ApplicationEventPublisherAware,MessageSourceAware{

    private String bookSystem;

    public String getBookSystem() {
        return bookSystem;
    }

    public void setBookSystem(String bookSystem) {
        System.out.println("設置BookSystem 的屬性值");
        this.bookSystem = bookSystem;
    }

    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("SubBookClass.setBeanClassLoader() 方法被調用了");
    }

    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        System.out.println("SubBookClass.setApplicationEventPublisher() 方法被調用了");
    }

    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        System.out.println("SubBookClass.setEmbeddedValueResolver() 方法被調用了");
    }

    public void setEnvironment(Environment environment) {
        System.out.println("SubBookClass.setEnvironment() 方法被調用了");
    }

    public void setMessageSource(MessageSource messageSource) {
        System.out.println("SubBookClass.setMessageSource() 方法被調用了");
    }

    public void setResourceLoader(ResourceLoader resourceLoader) {
        System.out.println("SubBookClass.setResourceLoader() 方法被調用了");
    }

}

上述SubBookClass類與Book是 互補 關係。

  • 新建一個SubBean-Lifecycle.xml,注入SubBookClass
<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
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="bookClass" class="com.bean.lifecycle.SubBookClass" init-method="myPostConstruct" destroy-method="myPreDestory">
        <property name="bookSystem" value="Java System" />
    </bean>

    <bean class="com.bean.lifecycle.MyBeanPostProcessor"/>

</beans>
  • 完整的SpringBeanLifecycleApplication 如下:
public class SpringBeanLifecycleApplication {

    public static void main(String[] args) throws InterruptedException {
        // 爲面試而準備的Bean生命週期加載過程
        ApplicationContext context = new ClassPathXmlApplicationContext("Bean-Lifecycle.xml");
        Book book = (Book)context.getBean("book");
        System.out.println("Book name = " + book.getBookName());
        ((ClassPathXmlApplicationContext) context).destroy();

        // 完整的加載過程,當然瞭解的越多越好
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("SubBean-Lifecycle.xml");
        SubBookClass subBookClass = (SubBookClass) applicationContext.getBean("bookClass");
        System.out.println("BookSystemName = " + subBookClass.getBookSystem());
        ((ClassPathXmlApplicationContext) applicationContext).registerShutdownHook();
    }

}

輸出完整的結果:

Book Initializing setBookName: Book name has set. Book.setBeanName invoke Book.setBeanFactory invoke Book.setApplicationContext invoke MyBeanPostProcessor.postProcessBeforeInitialization @PostConstruct Book.afterPropertiesSet invoke Book.myPostConstruct invoke MyBeanPostProcessor.postProcessAfterInitialization Book name = thingking in java @PreDestory Book.destory invoke Book.myPreDestory invoke ---------------destroy-----------------

Book Initializing 設置BookSystem 的屬性值 Book.setBeanName invoke SubBookClass.setBeanClassLoader() 方法被調用了 Book.setBeanFactory invoke SubBookClass.setEnvironment() 方法被調用了 SubBookClass.setEmbeddedValueResolver() 方法被調用了 SubBookClass.setResourceLoader() 方法被調用了 SubBookClass.setApplicationEventPublisher() 方法被調用了 SubBookClass.setMessageSource() 方法被調用了 Book.setApplicationContext invoke MyBeanPostProcessor.postProcessBeforeInitialization Book.afterPropertiesSet invoke Book.myPostConstruct invoke MyBeanPostProcessor.postProcessAfterInitialization BookSystemName = Java System Book.destory invoke Book.myPreDestory invoke ---------------destroy-----------------

來源:https://www.tuicool.com/articles/vQ3aymQ

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章