前言

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

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

Spring啟動，查找并加載需要被Spring管理的bean，進行Bean的實例化 Bean實例化后對將Bean的引入和值注入到Bean的屬性中 如果Bean實現了BeanNameAware接口的話，Spring將Bean的Id傳遞給setBeanName()方法 如果Bean實現了BeanFactoryAware接口的話，Spring將調用setBeanFactory()方法，將BeanFactory容器實例傳入 如果Bean實現了ApplicationContextAware接口的話，Spring將調用Bean的setApplicationContext()方法，將bean所在應用上下文引用傳入進來 如果Bean實現了BeanPostProcessor接口，Spring就將調用他們的postProcessBeforeInitialization()方法。 如果Bean 實現了InitializingBean接口，Spring將調用他們的afterPropertiesSet()方法。類似的，如果bean使用init-method聲明了初始化方法，該方法也會被調用 如果Bean 實現了BeanPostProcessor接口，Spring就將調用他們的postProcessAfterInitialization()方法。 此時，Bean已經準備就緒，可以被應用程序使用了。他們將一直駐留在應用上下文中，直到應用上下文被銷毀。 如果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(): 在銷毀之前將此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/beanshttp://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 init-method='myPostConstruct' destroy-method='myPreDestory'> <!-- 注入bean 屬性名稱 --> <property name='bookName' value='thingking in java' /> </bean> <!--引入自定義的BeanPostProcessor--> <bean /></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/beanshttp://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 init-method='myPostConstruct' destroy-method='myPreDestory'> <property name='bookSystem' value='Java System' /> </bean> <bean /></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 的生命周期的資料請關注好吧啦網其它相關文章！