關注微信公眾號【
Java之言】，更多干貨文章和學習資料，助你放棄編程之路！
文章目錄
- 一、Bean 的生命周期
- 二、InitializingBean 介面說明
- 三、DisposableBean 介面說明
- 四、Bean 初始化
- 五、Bean 銷毀
- 六、原始碼分析
- 七、使用誤區
一、Bean 的生命周期
我們知道，一個 bean （物件）的生命周期，指的是 bean 從創建，初始化，一系列使用，銷毀的程序，只不過，在 Spring 中，bean 的生命周期是由Spring容器管理的，Spring 這種優秀強大的框架，其中一個核心功能就是提供了許多擴展支持，既然 Srping 容器管理了所有的 Spring bean，那肯定也會開放一些擴展點讓我們進行自定義擴展，今天來講講 bean 的初始化和銷毀的方法，Spring 開放了擴展介面，允許我們自定義 bean 的初始化和銷毀方法，即當 Spring 容器在 bean 進行到相應的生命周期階段時，會自動呼叫我們自定義的初始化和銷毀方法，這兩個擴展介面即是 InitializingBean 和 DisposableBean ，
二、InitializingBean 介面說明
InitializingBean 介面為 bean 提供了 bean 屬性初始化后的處理方法，它只有 afterPropertiesSet 一個方法，凡是實作此介面的類，在 bean 的屬性初始化后都會執行該方法，
package org.springframework.beans.factory;
public interface InitializingBean {
void afterPropertiesSet() throws Exception;
}
例如 UserServiceImpl 這個類實作 InitializingBean 介面，并重寫 afterPropertiesSet 方法，
public class UserServiceImpl implements InitializingBean {
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("--- afterPropertiesSet 方法");
}
}
三、DisposableBean 介面說明
DisposableBean 介面為單例 bean 提供了在容器銷毀 bean 時的處理方法，它只有 destroy 一個方法，凡是實作此介面的類，在 bean 被銷毀時都會執行該方法，
package org.springframework.beans.factory;
public interface DisposableBean {
void destroy() throws Exception;
}
例如 UserServiceImpl 這個類實作 DisposableBean 介面，并重寫 destroy 方法，
public class UserServiceImpl implements DisposableBean {
@Override
public void destroy() throws Exception {
System.out.println("--- destroy 方法");
}
}
四、Bean 初始化
使用實作 InitializingBean 介面，重寫 afterPropertiesSet 方法的方式，會讓代碼和 Spring 緊耦合，如果你不想代碼和 Spring 耦合，那不推薦使用此種方式，
另外一種方式是，配置 bean 的時候通過配置 initMethod 指定 bean 的初始化方法，它也是在 bean 屬性初始化之后需要執行的初始化方法，
第一種方式是將 bean 強制轉換成 InitializingBean 介面型別，然后直接呼叫 afterPropertiesSet 方法，速度更快，第二種方式是通過反射來執行 initMethod 方法，效率相對較低，
afterPropertiesSet 和 initMethod 可以同時存在，但是 afterPropertiesSet 方法是在 initMethod 方法之前執行的，
所以一個 bean 從創建到初始化的程序可以總結為：
- 通過構造器創建 bean
- 屬性注入
- 執行 afterPropertiesSet 方法
- 執行 initMethod 方法
定義一個 UserService 介面，規范問題，面向介面編程，
public interface UserService {
void test();
}
定義一個 bean 類，實作 InitializingBean 介面，
public class UserServiceImpl implements UserService, InitializingBean {
private UserDao userDao;
public UserServiceImpl() {
System.out.println("--- UserServiceImpl 構造方法");
}
@Autowired
public void setUserDao(UserDao userDao) {
System.out.println("--- setUserDao 屬性注入方法");
this.userDao = userDao;
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("--- afterPropertiesSet 方法");
}
public void initMethod() {
System.out.println("--- initMethod 方法");
}
@Override
public void test() {
}
}
配置 bean，生成 UserServiceImpl 類的 bean，交由 Spring 容器管理，
@Configuration
public class UserServiceImplConfig {
// 通過 initMethod 屬性指定初始化方法
@Bean(initMethod = "initMethod")
public UserServiceImpl userServiceImpl() {
return new UserServiceImpl();
}
}
啟動服務，會在啟動日志看到如下日志，表示在 bean 按指定順序創建和初始化了，
--- UserServiceImpl 構造方法
--- setUserDao 屬性注入方法
--- afterPropertiesSet 方法
--- initMethod 方法
五、Bean 銷毀
使用實作 DisposableBean 介面，重寫 destroy 方法的方式，同樣也會讓代碼和 Spring 緊耦合，如果你不想代碼和 Spring 耦合，那不推薦使用此種方式，
另外一種方式是，配置 bean 的時候通過配置 destroyMethod 指定 bean 的銷毀方法，它也是在 bean 被銷毀時需要執行的方法，
第一種方式是將 bean 強制轉換成 DisposableBean 介面型別，然后直接呼叫 destroy 方法，速度更快，第二種方式是通過反射來執行 destroyMethod 方法，效率相對較低，
destroy 和 destroyMethod 可以同時存在，但是 destroy 方法是在 destroyMethod 方法之前執行的，
我們將上面 UserServiceImpl 類修改如下，使之實作 介面，重寫 destroy 方法，
public class UserServiceImpl implements UserService, InitializingBean, DisposableBean {
private UserDao userDao;
public UserServiceImpl() {
System.out.println("--- UserServiceImpl 構造方法");
}
@Autowired
public void setUserDao(UserDao userDao) {
System.out.println("--- setUserDao 屬性注入方法");
this.userDao = userDao;
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("--- afterPropertiesSet 方法");
}
public void initMethod() {
System.out.println("--- initMethod 方法");
}
@Override
public void destroy() throws Exception {
System.out.println("--- destroy 方法");
}
public void destroyMethod() {
System.out.println("--- destroyMethod 方法");
}
@Override
public void test() {
}
}
配置 bean，同時指定 destroyMethod 方法，生成 UserServiceImpl 類的 bean，交由 Spring 容器管理，
@Configuration
public class UserServiceImplConfig {
// 通過 initMethod 屬性指定初始化方法，通過 destroyMethod 屬性指定銷毀時執行的方法
@Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
public UserServiceImpl userServiceImpl() {
return new UserServiceImpl();
}
}
啟動服務成功之后，停掉服務，會在后臺日志看到如下日志，表示在 bean 按指定順序創建，初始化和銷毀了，
--- UserServiceImpl 構造方法
--- setUserDao 屬性注入方法
--- afterPropertiesSet 方法
--- initMethod 方法
2021-02-19 22:42:28.926 INFO 5844 --- [ main] o.s.s.concurrent.ThreadPoolTaskExecutor : Initializing ExecutorService 'applicationTaskExecutor'
2021-02-19 22:42:29.748 INFO 5844 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path ''
2021-02-19 22:42:29.782 INFO 5844 --- [ main] com.nobody.Application : Started Application in 20.12 seconds (JVM running for 25.131)
2021-02-19 22:42:43.932 INFO 5844 --- [extShutdownHook] o.s.s.concurrent.ThreadPoolTaskExecutor : Shutting down ExecutorService 'applicationTaskExecutor'
--- destroy 方法
--- destroyMethod 方法
六、原始碼分析
我們已經知道實作了 InitializingBean 和 DisposableBean 介面的 bean，會在 bean 初始化和銷毀的時候分別執行這兩個方法，那么具體是如何執行的呢？那我們從 Spring 原始碼分析一探究竟，
看過 Spring 原始碼的同學肯定知道，InitializingBean 的 afterPropertiesSet 呼叫，其實奧妙就在 Spring 加載 bean 時的 AbstractAutowireCapableBeanFactory 類，其中有個方法 invokeInitMethods 如下：
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
// 判斷該 bean 是否實作了 InitializingBean 介面，如果是，則會呼叫 bean 的 afterPropertiesSet 方法
boolean isInitializingBean = bean instanceof InitializingBean;
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged(() -> {
// 呼叫 afterPropertiesSet 方法
((InitializingBean)bean).afterPropertiesSet();
return null;
}, this.getAccessControlContext());
} catch (PrivilegedActionException var6) {
throw var6.getException();
}
} else {
// 呼叫afterPropertiesSet 方法
((InitializingBean)bean).afterPropertiesSet();
}
}
if (mbd != null && bean.getClass() != NullBean.class) {
// 獲取 initMethod 方法名
String initMethodName = mbd.getInitMethodName();
// 如果指定了 initMethod 方法，并且不是 afterPropertiesSet 方法，則執行 initMethod
if (StringUtils.hasLength(initMethodName) && (!isInitializingBean || !"afterPropertiesSet".equals(initMethodName))
&& !mbd.isExternallyManagedInitMethod(initMethodName)) {
// 通過反射方式，呼叫 initMethod 指定的方法
this.invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
那 bean 被銷毀時，執行的 destroy 方法又是在哪里呼叫的呢？ 其實當 Spring 容器銷毀時，會將容器中的所有單例 bean 先全部銷毀，在 AbstractApplicationContext 中的 destroyBeans() 方法就是用來處理銷毀bean的，原始碼如下：
protected void destroyBeans() {
this.getBeanFactory().destroySingletons();
}
public void destroySingleton(String beanName) {
// 從三級快取中將 bean 洗掉
this.removeSingleton(beanName);
DisposableBean disposableBean;
synchronized(this.disposableBeans) {
// 如果實作了 DisposableBean 介面，強制轉為 DisposableBean 物件
disposableBean = (DisposableBean)this.disposableBeans.remove(beanName);
}
// 執行 destroy 方法
this.destroyBean(beanName, disposableBean);
}
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
// 省略代碼
// 如果 DisposableBean bean物件不為空，則執行 destroy 方法，
if (bean != null) {
try {
bean.destroy();
} catch (Throwable var13) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", var13);
}
}
}
// 省略代碼
}
七、使用誤區
如果 bean 不是交由 Spring 管理的，是我們自己手動創建（new）出來的，是不會自動呼叫我們定義的初始化和銷毀方法的，例如如下：
@GetMapping("find")
public String find() {
UserService userService1 = new UserServiceImpl();
return "ok";
}
呼叫此介面，只會呼叫它的構造器方法，
--- UserServiceImpl 構造方法
其二，如果 bean 不是單例的，而是 prototype 的，那每次從 Spring 容器獲取創建 bean 時，會呼叫初始化方法，在銷毀 bean 物件時，不會執行銷毀方法，因為 prototype 型別的 bean，創建是 Spring 創建的，但是創建之后它就不進行維護了，
此演示專案已上傳到Github，如有需要可自行下載，歡迎 Star ，
https://github.com/LucioChn/spring-annotation
關注微信公眾號【
Java之言】，更多干貨文章和學習資料，助你放棄編程之路！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/261717.html
標籤：java