2. 程式人生 > 程式設計 >詳解Spring 中 Bean 的生命週期

詳解Spring 中 Bean 的生命週期

阿新 • • 發佈：2021-01-14

前言

這其實是一道面試題，是我在面試百度的時候被問到的，當時沒有答出來(因為自己真的很菜)，後來在網上尋找答案，看到也是一頭霧水，直到看到了《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的構造過程

詳解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， 全部相關介面如下，上述已有的就不用著重標註，把額外的相關介面著重標註下

詳解Spring 中 Bean 的生命週期

​ 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(): 在銷燬之前將此BeanPostProcessor 應用於給定的bean例項。能夠呼叫自定義回撥，像是DisposableBean 的銷燬和自定義銷燬方法，這個回撥僅僅適用於工廠中的單例bean(包括內部bean)
實現了自定義的destory()方法

二、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-----------------

以上就是詳解Spring 中 Bean 的生命週期的詳細內容，更多關於Spring 中 Bean 的生命週期的資料請關注我們其它相關文章！

相關推薦

詳解Spring 中 Bean 的生命週期

前言 這其實是一道面試題，是我在面試百度的時候被問到的，當時沒有答出來(因為自己真的很菜)，後來在網上尋找答案，看到也是一頭霧水，直到看到了《Spring in action》這本書，書上有對Bean宣告週期的大致解釋，但

詳解spring中aop不生效的幾種解決辦法

先看下這個問題的背景：假設有一個spring應用，開發人員希望自定義一個註解@Log，可以加到指定的方法上，實現自動記錄日誌(入參、出參、響應耗時這些)

Spring-IoC-bean生命週期

Bean生命週期 1.生命週期：從物件的建立到物件銷燬的過程 2.bean的生命週期 （1）通過構造器建立bean例項（無參構造器）

Spring-IoC-bean生命週期（加上後置處理器）

bean生命週期（加上bean後置處理器） （1）通過構造器建立bean例項（無參構造器）

詳解Angular元件之生命週期(二)

一、view鉤子 view鉤子有2個，ngAfterViewInit和ngAfterViewChecked鉤子。 1、實現ngAfterViewInit和ngAfterViewChecked鉤子時注意事項

深入瞭解Spring中Bean的作用域和生命週期

作用域的種類 Spring 容器在初始化一個 Bean 的例項時，同時會指定該例項的作用域。Spring3 為 Bean 定義了五種作用域，具體如下。

如果你每次面試前都要去背一篇Spring中Bean的生命週期，請看完這篇文章

前言 當你準備去複習Spring中Bean的生命週期的時候，這個時候你開始上網找資料，很大概率會看到下面這張圖：

spring中bean的生命週期

準確的瞭解Spring Bean的生命週期是非常必要的。我們通常使用ApplicationContext作為Spring容器。這裡，我們講的也是 ApplicationContext中Bean的生命週期。而實際上BeanFactory也是差不多的，只不過處理器需要手動註

spring 中bean的生命週期 （以springboot 為演示）

說明：本文主要的參考為《精通spring 4.x企業開發應用實戰》陳雄華林開雄文建國編著

Spring中bean的初始化和銷燬幾種實現方式詳解

Bean的生命週期 ： 建立bean物件 – 屬性賦值 – 初始化方法呼叫前的操作 – 初始化方法 – 初始化方法呼叫後的操作 – …-- 銷燬前操作 – 銷燬方法的呼叫。

Spring中bean的生命週期（易懂版）

技術標籤：Spring5beanbean的生命週期 bean的生命週期 寫在前面的話bean的生命週期程式碼演示

一次性講清楚spring中bean的生命週期之二：FactoryBean的前世今生

前言 在《spring中FactoryBean是什麼bean》一文中，帶著小夥伴學習了spring中的FactoryBean，瞭解了到了FactoryBean其實是一種生產Bean的bean，也就是FactroyBean的前世是Bean，今生還是Bean，小夥伴要疑惑了都是Bea

一次性講清楚spring中bean的生命週期之三：bean是如何例項化的

在前面的兩篇博文《一次性講清楚spring中bean的生命週期之一：getSingleton方法》和《一次性講清楚spring中bean的生命週期之二：FactoryBean的前世今生》中分析了spring中bean生命週期的過程中的getSingleton方法和

深究Spring中Bean的生命週期

前言 這其實是一道面試題，是我在面試百度的時候被問到的，當時沒有答出來(因為自己真的很菜)，後來在網上尋找答案，看到也是一頭霧水，直到看到了《Spring in action》這本書，書上有對Bean宣告週期的大致解釋，但

Spring Bean 生命週期 （例項結合原始碼徹底講透）

前言 本篇文章主要是要介紹如何在Spring IoC 容器中 如何管理Spring Bean生命週期。

詳解Spring Security中的HttpBasic登入驗證模式

一、HttpBasic模式的應用場景 HttpBasic登入驗證模式是Spring Security實現登入驗證最簡單的一種方式，也可以說是最簡陋的一種方式。它的目的並不是保障登入驗證的絕對安全，而是提供一種“防君子不防小人”的登入驗

Spring bean生命週期配置過程解析

1.例項化bean AbstractAutowireCapableBeanFactory類中的 createBeanInstance(beanName,mbd,args); 2.為bean注入屬性

詳解Spring中介面的bean是如何注入的

Question： 這個問題困擾了我好久，一直疑問這個介面的bean是怎麼注入進去的？因為只看到使用@Service注入了實現類serviceImpl，使用時怎麼能獲取的介面，而且還能呼叫到實現類的方法，難道這個介面是在什麼時候自動

Spring Bean生命週期

Spring Bean生命週期 生命週期 從物件建立到物件銷燬的過程。 bean生命週期 通過構造器建立bean例項。

詳解Spring專案中的classpath路徑

在java專案中，你一定碰到過classpath，通常情況下，我們是用它來指定配置/資原始檔的路徑。在剛開始學習的時候，自己也糊里糊塗，但是現在，是時候弄清楚它到底是指什麼了。