帶你徹底掌握Bean的生命週期

摘要：我們將深入研究Spring Framework的核心部分——Spring Bean的生命週期。

本文分享自華為雲社群《Spring高手之路5——徹底掌握Bean的生命週期》，作者：磚業洋__ 。

1. 理解Bean的生命週期

1.1 生命週期的各個階段

在Spring IOC容器中，Bean的生命週期大致如下：

範例化：當啟動Spring應用時，IOC容器就會為在組態檔中宣告的每個<bean>建立一個範例。
屬性賦值：範例化後，Spring就通過反射機制給Bean的屬性賦值。
呼叫初始化方法：如果Bean設定了初始化方法，Spring就會呼叫它。初始化方法是在Bean建立並賦值之後呼叫，可以在這個方法裡面寫一些業務處理程式碼或者做一些初始化的工作。
Bean執行期：此時，Bean已經準備好被程式使用了，它已經被初始化並賦值完成。
應用程式關閉：當關閉IOC容器時，Spring會處理設定了銷燬方法的Bean。
呼叫銷燬方法：如果Bean設定了銷燬方法，Spring會在所有Bean都已經使用完畢，且IOC容器關閉之前呼叫它，可以在銷燬方法裡面做一些資源釋放的工作，比如關閉連線、清除快取等。

這就是Spring IOC容器管理Bean的生命週期，幫助我們管理物件的建立和銷燬，以及在適當的時機做適當的事情。

我們可以將生命週期的觸發稱為回撥，因為生命週期的方法是我們自己定義的，但方法的呼叫是由框架內部幫我們完成的，所以可以稱之為「回撥」。

2. 理解init-method和destroy-method

讓我們先了解一種最容易理解的生命週期階段：初始化和銷燬方法。這些方法可以在Bean的初始化和銷燬階段起作用，我們通過範例來演示這種方式。

為了方便演示XML和註解的方式，接下來我們會建立兩個類來分別進行演示，分別為Lion和Elephant，讓我們一步一步對比觀察。

2.1 從XML設定建立Bean看生命週期

先建立一個類Lion

package com.example.demo.bean;
public class Lion {
 private String name;
 public void setName(String name) {
 this.name = name;
 }
 public void init() {
 System.out.println(name + " has been initialized...");
 }
 public void destroy() {
 System.out.println(name + " has been destroyed...");
 }
}

在XML中，我們使用<bean>標籤來註冊Lion：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 <bean class="com.example.demo.bean.Lion"
 init-method="init" destroy-method="destroy">
 <property name="name" value="simba"/>
 </bean>
</beans>

加上主程式

package com.example.demo.application;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.support.ClassPathXmlApplicationContext;
@ComponentScan("com.example")
public class DemoApplication {
 public static void main(String[] args) {
 System.out.println("Spring容器初始化開始");
 ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
 System.out.println("Spring容器初始化完成。");
 System.out.println("==================");
 System.out.println("Spring容器準備關閉");
 context.close();
 System.out.println("Spring容器已關閉。");
 }
}

執行結果

在<bean>標籤中，有兩個屬性：init-method和destroy-method，這兩個屬性用於指定初始化和銷燬方法。

這裡"simba has been initialized..."，證明init()方法被呼叫了。當context.close()被呼叫時，看到"simba has been destroyed..."，證明destroy()方法被呼叫了。

在 IOC 容器初始化之前，預設情況下 Bean 已經建立好了，而且完成了初始化動作；容器呼叫銷燬動作時，先銷燬所有 Bean ，最後 IOC 容器全部銷燬完成。

這個例子通過一個簡單的Spring應用程式顯示了Spring bean的生命週期。我們可以在建立bean時根據需要使用這些生命週期方法。

2.2 從設定類註解設定建立Bean看生命週期

這裡再建立一個類Elephant和上面對比

package com.example.demo.bean;
public class Elephant {
 private String name;
 public void setName(String name) {
 this.name = name;
 }
 public void init() {
 System.out.println(name + " has been initialized...");
 }
 public void destroy() {
 System.out.println(name + " has been destroyed...");
 }
}

對於註解，@Bean註解中也有類似的屬性：initMethod和destroyMethod，這兩個屬性的作用與XML設定中的相同。

package com.example.demo.configuration;
import com.example.demo.bean.Elephant;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
@Configuration
@ImportResource("classpath:applicationContext.xml")
public class AnimalConfig {
 @Bean(initMethod = "init", destroyMethod = "destroy")
 public Elephant elephant() {
 Elephant elephant = new Elephant();
 elephant.setName("Dumbo");
 return elephant;
 }
}

這裡用@ImportResource("classpath:applicationContext.xml")引入xml設定建立Bean進行對比。

主程式改為如下：

package com.example.demo.application;
import com.example.demo.configuration.AnimalConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan("com.example")
public class DemoApplication {
 public static void main(String[] args) {
 System.out.println("Spring容器初始化開始");
 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AnimalConfig.class);
 System.out.println("Spring容器初始化完成。");
 System.out.println("==================");
 System.out.println("Spring容器準備關閉");
 context.close();
 System.out.println("Spring容器已關閉。");
 }
}

執行結果

注意：在Spring中，如果在Java設定中定義了一個Bean，並在XML中定義了一個相同id或name的Bean，那麼最後註冊的那個Bean會覆蓋之前註冊的，這取決於組態檔載入順序，無論在Java設定中還是XML設定中定義的initMethod或destroyMethod，最後生效的總是後載入的設定中定義的。

「init-method」是指定初始化回撥方法的屬性的統稱，無論它是在XML設定還是Java設定中使用。同樣地，「destroy-method」是指定銷燬回撥方法的屬性的統稱。後文我們講解多種宣告週期共存的時候，將延續這種說法。

2.3 初始化和銷燬方法的特性

在Spring框架中設定Bean的初始化和銷燬方法時，需要按照Spring的規範來設定這些方法，否則Spring可能無法正確地呼叫它們。下面給每個特性提供一個解釋和範例：

1、方法的存取許可權無限制：這意味著無論方法是public、protected還是private，Spring都可以呼叫。Spring通過反射來呼叫這些方法，所以它可以忽略Java的存取許可權限制。範例：

public class MyBean {
 private void init() {
 // 初始化程式碼
 }
}

在上述程式碼中，即使init方法是private的，Spring也可以正常呼叫。

2、方法沒有引數：由於Spring不知道需要傳遞什麼引數給這些方法，所以這些方法不能有引數。範例：

public class MyBean {
 public void init() {
 // 初始化程式碼
 }
}

在上述程式碼中，init方法沒有引數，如果新增了引數，如public void init(String arg)，Spring將無法呼叫此方法。

3、方法沒有返回值：由於返回的值對Spring來說沒有意義，所以這些方法不應該有返回值。範例：

public class MyBean {
 public void init() {
 // 初始化程式碼
 }
}

在上述程式碼中，init方法是void的，如果讓此方法返回一個值，如public String init()，那麼Spring將忽略此返回值。

4、方法可以丟擲異常：如果在初始化或銷燬過程中發生錯誤，這些方法可以丟擲異常來通知Spring。範例：

public class MyBean {
 public void init() throws Exception {
 // 初始化程式碼
 if (somethingGoesWrong) {
 throw new Exception("Initialization failed.");
 }
 }
}

在上述程式碼中，如果在init方法中的初始化程式碼出錯，它會丟擲一個異常。Spring框架預設會停止Bean的建立，並丟擲異常。

2.4 探究Bean的初始化流程順序

在上面的程式碼中，我們可以看出Bean在IOC容器初始化階段就已經建立並初始化了，那麼每個Bean的初始化動作又是如何進行的呢？我們修改一下Lion，在構造方法和setName方法中加入控制檯列印，這樣在呼叫這些方法時，會在控制檯上得到反饋。

package com.example.demo.bean;
public class Lion {
 private String name;
 public Lion() {
 System.out.println("Lion's constructor is called...");
 }
 public void setName(String name) {
 System.out.println("setName method is called...");
 this.name = name;
 }
 public void init() {
 System.out.println(name + " has been initialized...");
 }
 public void destroy() {
 System.out.println(name + " has been destroyed...");
 }
}

我們重新執行主程式：

@ComponentScan("com.example")
public class DemoApplication {
 public static void main(String[] args) {
 System.out.println("Spring容器初始化開始");
 ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
 System.out.println("Spring容器初始化完成。");
 System.out.println("==================");
 System.out.println("Spring容器準備關閉");
 context.close();
 System.out.println("Spring容器已關閉。");
 }
}

執行結果

我們可以得出結論：在Bean的生命週期中，首先進行屬性賦值，然後執行init-method標記的方法。

3. @PostConstruct和@PreDestroy

在JSR250規範中，有兩個與Bean生命週期相關的註解，即@PostConstruct和@PreDestroy。這兩個註解對應了Bean的初始化和銷燬階段。

@PostConstruct註解標記的方法會在bean屬性設定完畢後（即完成依賴注入），但在bean對外暴露（即可以被其他bean參照）之前被呼叫，這個時機通常用於完成一些初始化工作。

@PreDestroy註解標記的方法會在Spring容器銷燬bean之前呼叫，這通常用於釋放資源。

3.1 範例：@PostConstruct和@PreDestroy的使用

我們這裡還是用Lion類來建立這個例子，將Lion類修改為使用@PostConstruct和@PreDestroy註解

package com.example.demo.bean;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Component
public class Lion {
 private String name;
 public void setName(String name) {
 this.name = name;
 }
 @PostConstruct
 public void init() {
 System.out.println("Lion is going through init.");
 }
 @PreDestroy
 public void destroy() {
 System.out.println("Lion is going through destroy.");
 }
 @Override
 public String toString() {
 return "Lion{" + "name=" + name + '}';
 }
}

給Lion類加上@Component註解，讓IOC容器去管理這個類，我們這裡就不把Elephant類加進來增加理解難度了。

被 @PostConstruct 和 @PreDestroy 註解標註的方法與 init-method / destroy-method 方法的初始化和銷燬的要求是一樣的，存取修飾符沒有限制，private也可以。

我們可以註釋掉之前的設定類和XML設定，因為和這裡的例子沒有關係，我們來看看主程式：

package com.example.demo.application;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
 public static void main(String[] args) {
 System.out.println("Spring容器初始化開始");
 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.example.demo.bean");
 System.out.println("Spring容器初始化完成。");
 System.out.println("==================");
 System.out.println("Spring容器準備關閉");
 context.close();
 System.out.println("Spring容器已關閉。");
 }
}

執行結果

這裡可以看到@PostConstruct和@PreDestroy註解正確地應用在了Lion的初始化和銷燬過程中。

3.2 初始化和銷燬——註解和init-method共存對比

@PostConstruct和@PreDestroy註解與init-method/destroy-method屬性如何共存呢？我們來看看

我們只用Lion類來舉例子，在Lion類中新增新的open()和close()方法

需要的全部程式碼如下：

Lion.java

package com.example.demo.bean;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class Lion {
 private String name;
 public Lion() {
 System.out.println("Lion構造器");
 }
 public void setName(String name) {
 System.out.println("Lion設定name");
 this.name = name;
 }
 public void open() {
 System.out.println("設定類initMethod - 開啟Lion。。。");
 }
 public void close() {
 System.out.println("設定類destroyMethod - 關閉Lion。。。");
 }
 @PostConstruct
 public void init() {
 System.out.println("@PostConstruct - Lion正在進行初始化。。。");
 }
 @PreDestroy
 public void destroy() {
 System.out.println("@PreDestroy - Lion正在進行銷燬。。。");
 }
 @Override
 public String toString() {
 return "Lion{" + "name=" + name + '}';
 }
}

設定類AnimalConfig.java

package com.example.demo.configuration;
import com.example.demo.bean.Lion;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AnimalConfig {
 @Bean(initMethod = "open", destroyMethod = "close")
 public Lion lion() {
 return new Lion();
 }
}

主程式

package com.example.demo.application;
import com.example.demo.configuration.AnimalConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
 public static void main(String[] args) {
 System.out.println("Spring容器初始化開始");
 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AnimalConfig.class);
 System.out.println("Spring容器初始化完成。");
 System.out.println("==================");
 System.out.println("Spring容器準備關閉");
 context.close();
 System.out.println("Spring容器已關閉。");
 }
}

執行結果

這裡可以看到@PostConstruct和@PreDestroy註解的優先順序始終高於設定類中@Bean註解的initMethod和destroyMethod屬性。

4. 實現InitializingBean和DisposableBean介面

這兩個介面是 Spring 預定義的兩個關於生命週期的介面。他們被觸發的時機與上文中的 init-method / destroy-method 以及 JSR250 規範的註解相同，都是在 Bean 的初始化和銷燬階段回撥的。下面演示如何使用這兩個介面。

4.1 範例：實現InitializingBean和DisposableBean介面

建立Bean，我們讓Lion類實現這兩個介面：

Lion.java

package com.example.demo.bean;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
@Component
public class Lion implements InitializingBean, DisposableBean {
 private Integer energy;
 @Override
 public void afterPropertiesSet() throws Exception {
 System.out.println("獅子已經充滿能量。。。");
 this.energy = 100;
 }
 @Override
 public void destroy() throws Exception {
 System.out.println("獅子已經消耗完所有能量。。。");
 this.energy = 0;
 }
 @Override
 public String toString() {
 return "Lion{" + "energy=" + energy + '}';
 }
}

InitializingBean介面只有一個方法：afterPropertiesSet()。在Spring框架中，當一個bean的所有屬性都已經被設定完畢後，這個方法就會被呼叫。也就是說，這個bean一旦被初始化，Spring就會呼叫這個方法。我們可以在bean的所有屬性被設定後，進行一些自定義的初始化工作。

DisposableBean介面也只有一個方法：destroy()。當Spring容器關閉並銷燬bean時，這個方法就會被呼叫。我們可以在bean被銷燬前，進行一些清理工作。

主程式：

package com.example.demo.application;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
 public static void main(String[] args) {
 System.out.println("Spring容器初始化開始");
 AnnotationConfigApplicationContext context
 = new AnnotationConfigApplicationContext("com.example.demo.bean");
 System.out.println("Spring容器初始化完成。");
 System.out.println("==================");
 System.out.println("Spring容器準備關閉");
 context.close();
 System.out.println("Spring容器已關閉。");
 }
}

執行結果：

4.2 三種生命週期並存

在Spring框架中，控制Bean生命週期的三種方式是：

使用Spring的init-method和destroy-method（在XML設定或者Java設定中自定義的初始化和銷燬方法）；
使用JSR-250規範的@PostConstruct和@PreDestroy註解；
實現Spring的InitializingBean和DisposableBean介面。

接下來我們測試一下，一個Bean同時定義init-method、destroy-method方法，使用@PostConstruct、@PreDestroy註解，以及實現InitializingBean、DisposableBean介面，執行順序是怎樣的。

我們建立一個新的類Lion2，並同時進行三種方式的生命週期控制：

需要執行的全部程式碼如下：

package com.example.demo.bean;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Component
public class Lion2 implements InitializingBean, DisposableBean {
 private Integer energy;
 public void open() {
 System.out.println("init-method - 獅子開始行動。。。");
 }
 public void close() {
 System.out.println("destroy-method - 獅子結束行動。。。");
 }
 @PostConstruct
 public void gainEnergy() {
 System.out.println("@PostConstruct - 獅子已經充滿能量。。。");
 this.energy = 100;
 }
 @PreDestroy
 public void loseEnergy() {
 System.out.println("@PreDestroy - 獅子已經消耗完所有能量。。。");
 this.energy = 0;
 }
 @Override
 public void afterPropertiesSet() throws Exception {
 System.out.println("InitializingBean - 獅子準備行動。。。");
 }
 @Override
 public void destroy() throws Exception {
 System.out.println("DisposableBean - 獅子行動結束。。。");
 }
}

接著，我們註冊Lion2：

package com.example.demo.configuration;
import com.example.demo.bean.Lion2;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AnimalConfig {
 @Bean(initMethod = "open", destroyMethod = "close")
 public Lion2 lion2() {
 return new Lion2();
 }
}

然後讓註解 IOC 容器驅動這個設定類，主程式如下：

package com.example.demo.application;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
 public static void main(String[] args) {
 System.out.println("Spring容器初始化開始");
 AnnotationConfigApplicationContext context
 = new AnnotationConfigApplicationContext("com.example.demo");
 System.out.println("Spring容器初始化完成。");
 System.out.println("==================");
 System.out.println("Spring容器準備關閉");
 context.close();
 System.out.println("Spring容器已關閉。");
 }
}

執行結果：

從上面的結果，我們可以得出以下結論，在Spring框架中單範例Bean的初始化和銷燬過程有這樣的執行順序：

初始化順序：@PostConstruct → InitializingBean → init-method
銷燬順序：@PreDestroy → DisposableBean → destroy-method

在初始化Bean時，@PostConstruct註解方法會首先被執行，然後是實現InitializingBean介面的afterPropertiesSet方法，最後是init-method指定的方法。

在銷燬Bean時，@PreDestroy註解方法會首先被執行，然後是實現DisposableBean介面的destroy方法，最後是destroy-method指定的方法

結合前面說過的屬性賦值(構造器方法和setter方法)，簡單總結一下Spring Bean生命週期的流程：

範例化（通過構造器方法）；
設定Bean的屬性（通過setter方法）；
呼叫Bean的初始化方法（@PostConstruct、afterPropertiesSet方法或者init-method指定的方法）；
Bean可以被應用程式使用；
當容器關閉時，呼叫Bean的銷燬方法（@PreDestroy、destroy方法或者destroy-method指定的方法）。

5. 原型Bean的生命週期

原型Bean的建立和初始化過程與單例Bean類似，但由於原型Bean的性質，其生命週期與IOC容器的生命週期並不相同。

這裡展示一下需要的全部程式碼。

Lion2.java

package com.example.demo.bean;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class Lion2 implements InitializingBean, DisposableBean {
 private Integer energy;
 public void roar() {
 System.out.println("The lion is roaring...");
 }
 public void rest() {
 System.out.println("The lion is resting...");
 }
 @PostConstruct
 public void gainEnergy() {
 System.out.println("@PostConstruct - 獅子已經充滿能量。。。");
 this.energy = 100;
 }
 @PreDestroy
 public void loseEnergy() {
 System.out.println("@PreDestroy - 獅子已經消耗完所有能量。。。");
 this.energy = 0;
 }
 @Override
 public void afterPropertiesSet() throws Exception {
 System.out.println("InitializingBean - 獅子準備行動。。。");
 }
 @Override
 public void destroy() throws Exception {
 System.out.println("DisposableBean - 獅子行動結束。。。");
 }
}

然後在Spring的Java設定中宣告並設定其為原型Bean

package com.example.demo.configuration;
import com.example.demo.bean.Lion2;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
@Configuration
public class PrototypeLifecycleConfiguration {
 @Bean(initMethod = "roar", destroyMethod = "rest")
 @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
 public Lion2 lion() {
 return new Lion2();
 }
}

如果我們只是啟動了IOC容器，但並未請求Lion2的範例，Lion Bean的初始化不會立刻發生。也就是說，原型Bean不會隨著IOC容器的啟動而初始化。以下是啟動容器但並未請求Bean的程式碼：

package com.example.demo.application;
import com.example.demo.configuration.PrototypeLifecycleConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
 public static void main(String[] args) {
 System.out.println("Spring容器初始化開始");
 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
 PrototypeLifecycleConfiguration.class);
 }
}

執行結果：

當我們明確請求一個Lion2的範例時，我們會看到所有的初始化方法按照預定的順序執行，這個順序跟單例Bean完全一致：

package com.example.demo.application;
import com.example.demo.bean.Lion2;
import com.example.demo.configuration.PrototypeLifecycleConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
 public static void main(String[] args) {
 System.out.println("Spring容器初始化開始");
 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
 PrototypeLifecycleConfiguration.class);
 System.out.println("Ready to get a Lion instance...");
 Lion2 lion = context.getBean(Lion2.class);
 System.out.println("A Lion instance has been fetched...");
 System.out.println("Lion instance is no longer needed, preparing to destroy...");
 context.getBeanFactory().destroyBean(lion);
 System.out.println("Lion instance has been destroyed...");
 }
}

執行結果：

將原型Bean和單例Bean的三種生命週期進行對比後發現，呼叫IOC容器的destroyBean()方法銷燬原型Bean時，只有@PreDestroy註解和DisposableBean介面的destroy方法會被觸發，而被destroy-method標記的自定義銷燬方法並不會被執行。

從這裡我們可以得出結論：在銷燬原型Bean時，Spring不會執行由destroy-method標記的自定義銷燬方法，所以原型Bean的destroy-method的也有侷限性。如果有重要的清理邏輯需要在Bean銷燬時執行，那麼應該將這部分邏輯放在@PreDestroy註解的方法或DisposableBean介面的destroy方法中。

6. Spring中控制Bean生命週期的三種方式總結

點選關注，第一時間瞭解華為雲新鮮技術~