詳解Spring 中 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 的生命周期
如上圖所示，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/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 的生命周期的資料請關註WalkonNet其它相關文章！
推薦閱讀：
- Spring BeanPostProcessor(後置處理器)的用法
- 使用spring容器在初始化Bean時前和後的操作
- Java Spring中Bean的作用域及生命周期
- Spring項目中使用Junit單元測試並配置數據源的操作
- Spring IOC容器Bean管理XML註入集合類型屬性