面試突擊80：說一下 Spring 中 Bean 的生命週期？
Java 中的公共類稱之為 Bean 或 Java Bean，而 Spring 中的 Bean 指的是將物件的生命週期，交個 Spring IoC 容器來管理的物件。所以 Spring 中的 Bean 物件在使用時，無需通過 new 來建立物件，只需要通過 DI（依賴注入），從 Spring 中取出要使用的物件即可。
那麼 Spring 中，Bean 的生命週期又有哪些呢？接下來，我們一起來看。
1.Bean 生命週期
Spring 中 Bean 的生命週期是指：Bean 在 Spring（IoC）中從建立到銷燬的整個過程。
Spring 中 Bean 的生命週期主要包含以下 5 部分：
- 範例化：為 Bean 分配記憶體空間；
- 設定屬性：將當前類依賴的 Bean 屬性，進行注入和裝配；
- 初始化：
- 執行各種通知；
- 執行初始化的前置方法；
- 執行初始化方法；
- 執行初始化的後置方法。
- 使用 Bean：在程式中使用 Bean 物件；
- 銷燬 Bean：將 Bean 物件進行銷燬操作。
以上生命週期中，需要注意的是：「範例化」和「初始化」是兩個完全不同的過程，千萬不要搞混，範例化只是給 Bean 分配了記憶體空間，而初始化則是將程式的執行權，從系統級別轉換到使用者級別，並開始執行使用者新增的業務程式碼。
2.程式碼演示
接下來我們使用程式碼的方式在 Spring Boot 中，給大家演示一下 Bean 的生命週期。
PS：因為 Spring Boot 是基於 Spring 建立的，所以 Bean 在 Spring 或 Spring Boot 中的行為都是一致的，而 Spring Boot 又是目前主流的框架，所以本文使用 Spring Boot 來演示 Bean 的生命週期。
首先，我們建立一個 Bean 物件，起名為 BeanLifeComponent（類命無所謂，可隨意指定），它的具體實現程式碼如下：
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Component
public class BeanLifeComponent implements BeanNameAware {
public void setBeanName(String s) {
System.out.println("執行 BeanName 的通知方法");
}
@PostConstruct
public void postConstruct() {
System.out.println("執行初始化方法");
}
public void use() {
System.out.println("使用 Bean");
}
@PreDestroy
public void preDestroy() {
System.out.println("執行銷燬方法");
}
}
然後，我們再建立一個 MyBeanPostProcessor 類（類命無所謂，可隨意指定），來實現初始化的前置方法和初始化的後置方法，具體實現程式碼如下：
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (beanName.equals("beanLifeComponent")) {
System.out.println("執行初始化前置方法");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (beanName.equals("beanLifeComponent")) {
System.out.println("執行初始化後置方法");
}
return bean;
}
}
為什麼要建立一個單獨的類來執行初始化的前置方法和初始化的後置方法呢？
這是因為初始化的前置方法和後置方法是為所有 Bean 服務的，而非為某一個 Bean 服務的，所以這兩個方法不能寫在某個具體的 Bean 中，否則（這兩個方法）不會執行。
最後，在 Spring Boot 的啟動類中獲取 Bean，具體實現程式碼如下：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
// 得到上下文物件，並啟動 Spring Boot 專案
ConfigurableApplicationContext context =
SpringApplication.run(DemoApplication.class, args);
// 獲取 Bean
BeanLifeComponent component = context.getBean(BeanLifeComponent.class);
// 使用 Bean
component.use();
// 停止 Spring Boot 專案
context.close();
}
}
以上程式最終的執行結果如下圖所示：
從上面的執行結果可以看出，程式碼執行順序符合 Bean 生命週期的執行順序：
- 範例化：為 Bean 分配記憶體空間；
- 設定屬性：將當前類依賴的 Bean 屬性，進行注入和裝配；
- 初始化：
- 執行各種通知；
- 執行初始化的前置方法；
- 執行初始化方法；
- 執行初始化的後置方法。
- 使用 Bean：在程式中使用 Bean 物件；
- 銷燬 Bean：將 Bean 物件進行銷燬操作。
那麼問題來了，能不能先執行初始化再執行設定屬性呢？也就是將生命週期中的步驟 2 和步驟 3 的執行順序交換一下？
答案是否定的。想象一個場景，如果在初始化方法中要用到被注入物件的某個方法，比如以下程式碼：
@Controller
public class UserController {
@Resource
private UserService userService;
@PostConstruct // 初始化方法
public void postConstruct() {
userService.sayHi();
}
}
此時如果先執行步驟 2，先將 UserService 注入到當前類，再呼叫步驟 3 執行初始化，那麼程式的執行是正常的。然而如果將互動步驟 2 和步驟 3 的執行順序，那麼程式執行就會報錯（空指標異常），所以 Bean 的生命週期的順序必須是：
1.範例化：為 Bean 分配記憶體空間；
2.設定屬性：將當前類依賴的 Bean 屬性，進行注入和裝配；
3.初始化：
- 執行各種通知；
- 執行初始化的前置方法；
- 執行初始化方法；
- 執行初始化的後置方法。
4.使用 Bean：在程式中使用 Bean 物件；
5.銷燬 Bean：將 Bean 物件進行銷燬操作。
總結
Bean 的生命週期指的是 Bean 在 Spring（IoC）中從建立到銷燬的整個過程。Bean 的生命週期主要包含以下 5 個流程：
1.範例化：為 Bean 分配記憶體空間；
2.設定屬性：將當前類依賴的 Bean 屬性，進行注入和裝配；
3.初始化：
- 執行各種通知；
- 執行初始化的前置方法；
- 執行初始化方法；
- 執行初始化的後置方法。
4.使用 Bean：在程式中使用 Bean 物件；
5.銷燬 Bean：將 Bean 物件進行銷燬操作。
是非審之於己，譭譽聽之於人，得失安之於數。
公眾號：Java面試真題解析
