面試突擊80：説一下 Spring 中 Bean 的生命週期？_Java中文社羣

我報名參加金石計劃1期挑戰——瓜分10萬獎池，這是我的第1篇文章，點擊查看活動詳情

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（類命無所謂，可隨意指定），它的具體實現代碼如下：

```java 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 類（類命無所謂，可隨意指定），來實現初始化的前置方法和初始化的後置方法，具體實現代碼如下：

```java 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，具體實現代碼如下：

```java 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 的執行順序交換一下？答案是否定的。想象一個場景，如果在初始化方法中要用到被注入對象的某個方法，比如以下代碼：

```java @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.初始化： 1. 執行各種通知； 2. 執行初始化的前置方法； 3. 執行初始化方法； 4. 執行初始化的後置方法。 4.使用 Bean：在程序中使用 Bean 對象； 5.銷燬 Bean：將 Bean 對象進行銷燬操作。

總結

Bean 的生命週期指的是 Bean 在 Spring（IoC）中從創建到銷燬的整個過程。Bean 的生命週期主要包含以下 5 個流程： 1.實例化：為 Bean 分配內存空間； 2.設置屬性：將當前類依賴的 Bean 屬性，進行注入和裝配； 3.初始化： 1. 執行各種通知； 2. 執行初始化的前置方法； 3. 執行初始化方法； 4. 執行初始化的後置方法。 4.使用 Bean：在程序中使用 Bean 對象； 5.銷燬 Bean：將 Bean 對象進行銷燬操作。

是非審之於己，譭譽聽之於人，得失安之於數。

公眾號：Java面試真題解析

面試合集：http://gitee.com/mydb/interview