作者：小傅哥
部落格：https://bugstack.cn
沉澱、分享、成長，讓自己和他人都能有所收穫！?
一、前言
有什麼方式，能給程式碼留條活路？
有人說：人人都是產品經理，那你知道嗎，人人也都可以是碼農程式設計師！就像：
- 程式設計就是；定義屬性、建立方法、呼叫展示
- Java 和 PHP 就像男人和女人，前者在乎架構化模組後，後者在乎那個顏色我喜歡
- 用心寫，但不要不做格式化
- 初次和產品對接的三個寶：磚頭、鐵鍬、菜刀，分別保證有用、可用、好用
- 從一行程式碼到一噸程式碼，開發越來越難，壁壘也越來越高
其實學會寫程式碼並不難，但學會寫好程式碼卻很難。從易閱讀上來說你的程式碼要有準確的命名和清晰的註釋、從易使用上來說你的程式碼要具備設計模式的包裝讓對外的服務呼叫更簡單、從易擴充套件上來說你的程式碼要做好業務和功能的實現分層。在易閱讀、易使用、易擴充套件以及更多編碼規範的約束下，還需要在開發完成上線後的交付結果上滿足；高可用、高效能、高併發，與此同時你還會接到現有專案中層出不窮來自產品經理新增的需求。
?怎麼辦？知道你在碼磚，不知道你在蓋哪個豬圈！
就算碼的磚是蓋的豬圈，也得因為豬多擴面積、改水槽、加飼料呀，所以根本沒法保證你寫完的程式碼就不會加需求。那麼新加的需求如果是以破壞了你原有的封裝了非常完美500行的 ifelse 咋辦，拆了重蓋嗎？
兄嘚，給程式碼留條活路吧！你的程式碼用上了定義介面嗎、介面繼承介面嗎、介面由抽象類實現嗎、類繼承的類實現了介面方法嗎，而這些操作都是為了讓你的程式邏輯做到分層、分割槽、分塊，把核心邏輯層和業務封裝層做好隔離，當有業務變化時候，只需要做在業務層完成裝配，而底層的核心邏輯服務並不需要頻繁變化，它們所增加的介面也更原子化，不具備業務語意。所以這樣的實現方式才能給你的程式碼留條活路。如果還不是太理解，可以多看看《重學Java設計模式》和現在編寫的《手擼Spring》，這裡面都有大量的設計模式應用實踐
二、目標
當我們的類建立的 Bean 物件，交給 Spring 容器管理以後，這個類物件就可以被賦予更多的使用能力。就像我們在上一章節已經給類物件新增了修改註冊Bean定義未例項化前的屬性資訊修改和例項化過程中的前置和後置處理，這些額外能力的實現，都可以讓我們對現有工程中的類物件做相應的擴充套件處理。
那麼除此之外我們還希望可以在 Bean 初始化過程，執行一些操作。比如幫我們做一些資料的載入執行，連結註冊中心暴漏RPC介面以及在Web程式關閉時執行連結斷開，記憶體銷燬等操作。如果說沒有Spring我們也可以通過建構函式、靜態方法以及手動呼叫的方式實現，但這樣的處理方式終究不如把諸如此類的操作都交給 Spring 容器來管理更加合適。 因此你會看到到 spring.xml 中有如下操作：
- 需要滿足使用者可以在 xml 中配置初始化和銷燬的方法，也可以通過實現類的方式處理，比如我們在使用 Spring 時用到的 InitializingBean, DisposableBean 兩個介面。
-其實還可以有一種是註解的方式處理初始化操作，不過目前還沒有實現到註解的邏輯，後續再完善此類功能。
三、設計
可能面對像 Spring 這樣龐大的框架，對外暴露的介面定義使用或者xml配置，完成的一系列擴充套件性操作，都讓 Spring 框架看上去很神祕。其實對於這樣在 Bean 容器初始化過程中額外新增的處理操作，無非就是預先執行了一個定義好的介面方法或者是反射呼叫類中xml中配置的方法，最終你只要按照介面定義實現，就會有 Spring 容器在處理的過程中進行呼叫而已。整體設計結構如下圖：
- 在 spring.xml 配置中新增
init-method、destroy-method兩個註解，在配置檔案載入的過程中，把註解配置一併定義到 BeanDefinition 的屬性當中。這樣在 initializeBean 初始化操作的工程中，就可以通過反射的方式來呼叫配置在 Bean 定義屬性當中的方法資訊了。另外如果是介面實現的方式，那麼直接可以通過 Bean 物件呼叫對應介面定義的方法即可，((InitializingBean) bean).afterPropertiesSet()，兩種方式達到的效果是一樣的。 - 除了在初始化做的操作外，
destroy-method和DisposableBean介面的定義，都會在 Bean 物件初始化完成階段，執行註冊銷燬方法的資訊到 DefaultSingletonBeanRegistry 類中的 disposableBeans 屬性裡，這是為了後續統一進行操作。這裡還有一段介面卡的使用，因為反射呼叫和介面直接呼叫，是兩種方式。所以需要使用介面卡進行包裝，下文程式碼講解中參考 DisposableBeanAdapter 的具體實現
-關於銷燬方法需要在虛擬機器執行關閉之前進行操作，所以這裡需要用到一個註冊鉤子的操作，如：Runtime.getRuntime().addShutdownHook(new Thread(() -> System.out.println("close！")));這段程式碼你可以執行測試，另外你可以使用手動呼叫 ApplicationContext.close 方法關閉容器。
四、實現
1. 工程結構
small-spring-step-07
└── src
├── main
│ └── java
│ └── cn.bugstack.springframework
│ ├── beans
│ │ ├── factory
│ │ │ ├── factory
│ │ │ │ ├── AutowireCapableBeanFactory.java
│ │ │ │ ├── BeanDefinition.java
│ │ │ │ ├── BeanFactoryPostProcessor.java
│ │ │ │ ├── BeanPostProcessor.java
│ │ │ │ ├── BeanReference.java
│ │ │ │ ├── ConfigurableBeanFactory.java
│ │ │ │ └── SingletonBeanRegistry.java
│ │ │ ├── support
│ │ │ │ ├── AbstractAutowireCapableBeanFactory.java
│ │ │ │ ├── AbstractBeanDefinitionReader.java
│ │ │ │ ├── AbstractBeanFactory.java
│ │ │ │ ├── BeanDefinitionReader.java
│ │ │ │ ├── BeanDefinitionRegistry.java
│ │ │ │ ├── CglibSubclassingInstantiationStrategy.java
│ │ │ │ ├── DefaultListableBeanFactory.java
│ │ │ │ ├── DefaultSingletonBeanRegistry.java
│ │ │ │ ├── DisposableBeanAdapter.java
│ │ │ │ ├── InstantiationStrategy.java
│ │ │ │ └── SimpleInstantiationStrategy.java
│ │ │ ├── support
│ │ │ │ └── XmlBeanDefinitionReader.java
│ │ │ ├── BeanFactory.java
│ │ │ ├── ConfigurableListableBeanFactory.java
│ │ │ ├── DisposableBean.java
│ │ │ ├── HierarchicalBeanFactory.java
│ │ │ ├── InitializingBean.java
│ │ │ └── ListableBeanFactory.java
│ │ ├── BeansException.java
│ │ ├── PropertyValue.java
│ │ └── PropertyValues.java
│ ├── context
│ │ ├── support
│ │ │ ├── AbstractApplicationContext.java
│ │ │ ├── AbstractRefreshableApplicationContext.java
│ │ │ ├── AbstractXmlApplicationContext.java
│ │ │ └── ClassPathXmlApplicationContext.java
│ │ ├── ApplicationContext.java
│ │ └── ConfigurableApplicationContext.java
│ ├── core.io
│ │ ├── ClassPathResource.java
│ │ ├── DefaultResourceLoader.java
│ │ ├── FileSystemResource.java
│ │ ├── Resource.java
│ │ ├── ResourceLoader.java
│ │ └── UrlResource.java
│ └── utils
│ └── ClassUtils.java
└── test
└── java
└── cn.bugstack.springframework.test
├── bean
│ ├── UserDao.java
│ └── UserService.java
└── ApiTest.java
工程原始碼：公眾號「bugstack蟲洞棧」，回覆：Spring 專欄，獲取完整原始碼
Spring 應用上下文和對Bean物件擴充套件機制的類關係，如圖 8-4
- 以上整個類圖結構描述出來的就是本次新增 Bean 例項化過程中的初始化方法和銷燬方法。
- 因為我們一共實現了兩種方式的初始化和銷燬方法，xml配置和定義介面，所以這裡既有 InitializingBean、DisposableBean 也有需要 XmlBeanDefinitionReader 載入 spring.xml 配置資訊到 BeanDefinition 中。
- 另外介面 ConfigurableBeanFactory 定義了 destroySingletons 銷燬方法，並由 AbstractBeanFactory 繼承的父類 DefaultSingletonBeanRegistry 實現 ConfigurableBeanFactory 介面定義的 destroySingletons 方法。這種方式的設計可能數程式設計師是沒有用過的，都是用的誰實現介面誰完成實現類，而不是把實現介面的操作又交給繼承的父類處理。所以這塊還是蠻有意思的，是一種不錯的隔離分層服務的設計方式
- 最後就是關於向虛擬機器註冊鉤子，保證在虛擬機器關閉之前，執行銷燬操作。
Runtime.getRuntime().addShutdownHook(new Thread(() -> System.out.println("close！")));
2. 定義初始化和銷燬方法的介面
cn.bugstack.springframework.beans.factory.InitializingBean
public interface InitializingBean {
/**
* Bean 處理了屬性填充後呼叫
*
* @throws Exception
*/
void afterPropertiesSet() throws Exception;
}
cn.bugstack.springframework.beans.factory.DisposableBean
public interface DisposableBean {
void destroy() throws Exception;
}
- InitializingBean、DisposableBean，兩個介面方法還是比較常用的，在一些需要結合 Spring 實現的元件中，經常會使用這兩個方法來做一些引數的初始化和銷燬操作。比如介面暴漏、資料庫資料讀取、配置檔案載入等等。
3. Bean屬性定義新增初始化和銷燬
cn.bugstack.springframework.beans.factory.config.BeanDefinition
public class BeanDefinition {
private Class beanClass;
private PropertyValues propertyValues;
private String initMethodName;
private String destroyMethodName;
// ...get/set
}
- 在 BeanDefinition 新增加了兩個屬性：initMethodName、destroyMethodName，這兩個屬性是為了在 spring.xml 配置的 Bean 物件中，可以配置
init-method="initDataMethod" destroy-method="destroyDataMethod"操作，最終實現介面的效果是一樣的。只不過一個是介面方法的直接呼叫，另外是一個在配置檔案中讀取到方法反射呼叫
4. 執行 Bean 物件的初始化方法
cn.bugstack.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
@Override
protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
Object bean = null;
try {
bean = createBeanInstance(beanDefinition, beanName, args);
// 給 Bean 填充屬性
applyPropertyValues(beanName, bean, beanDefinition);
// 執行 Bean 的初始化方法和 BeanPostProcessor 的前置和後置處理方法
bean = initializeBean(beanName, bean, beanDefinition);
} catch (Exception e) {
throw new BeansException("Instantiation of bean failed", e);
}
// ...
addSingleton(beanName, bean);
return bean;
}
private Object initializeBean(String beanName, Object bean, BeanDefinition beanDefinition) {
// 1. 執行 BeanPostProcessor Before 處理
Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
// 執行 Bean 物件的初始化方法
try {
invokeInitMethods(beanName, wrappedBean, beanDefinition);
} catch (Exception e) {
throw new BeansException("Invocation of init method of bean[" + beanName + "] failed", e);
}
// 2. 執行 BeanPostProcessor After 處理
wrappedBean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
return wrappedBean;
}
private void invokeInitMethods(String beanName, Object bean, BeanDefinition beanDefinition) throws Exception {
// 1. 實現介面 InitializingBean
if (bean instanceof InitializingBean) {
((InitializingBean) bean).afterPropertiesSet();
}
// 2. 配置資訊 init-method {判斷是為了避免二次執行銷燬}
String initMethodName = beanDefinition.getInitMethodName();
if (StrUtil.isNotEmpty(initMethodName)) {
Method initMethod = beanDefinition.getBeanClass().getMethod(initMethodName);
if (null == initMethod) {
throw new BeansException("Could not find an init method named '" + initMethodName + "' on bean with name '" + beanName + "'");
}
initMethod.invoke(bean);
}
}
}
- 抽象類 AbstractAutowireCapableBeanFactory 中的 createBean 是用來建立 Bean 物件的方法，在這個方法中我們之前已經擴充套件了 BeanFactoryPostProcessor、BeanPostProcessor 操作，這裡我們繼續完善執行 Bean 物件的初始化方法的處理動作。
- 在方法 invokeInitMethods 中，主要分為兩塊來執行實現了 InitializingBean 介面的操作，處理 afterPropertiesSet 方法。另外一個是判斷配置資訊 init-method 是否存在，執行反射呼叫 initMethod.invoke(bean)。這兩種方式都可以在 Bean 物件初始化過程中進行處理載入 Bean 物件中的初始化操作，讓使用者可以額外新增加自己想要的動作。
5. 定義銷燬方法介面卡(介面和配置)
cn.bugstack.springframework.beans.factory.support.DisposableBeanAdapter
public class DisposableBeanAdapter implements DisposableBean {
private final Object bean;
private final String beanName;
private String destroyMethodName;
public DisposableBeanAdapter(Object bean, String beanName, BeanDefinition beanDefinition) {
this.bean = bean;
this.beanName = beanName;
this.destroyMethodName = beanDefinition.getDestroyMethodName();
}
@Override
public void destroy() throws Exception {
// 1. 實現介面 DisposableBean
if (bean instanceof DisposableBean) {
((DisposableBean) bean).destroy();
}
// 2. 配置資訊 destroy-method {判斷是為了避免二次執行銷燬}
if (StrUtil.isNotEmpty(destroyMethodName) && !(bean instanceof DisposableBean && "destroy".equals(this.destroyMethodName))) {
Method destroyMethod = bean.getClass().getMethod(destroyMethodName);
if (null == destroyMethod) {
throw new BeansException("Couldn't find a destroy method named '" + destroyMethodName + "' on bean with name '" + beanName + "'");
}
destroyMethod.invoke(bean);
}
}
}
- 可能你會想這裡怎麼有一個介面卡的類呢，因為銷燬方法有兩種甚至多種方式，目前有
實現介面 DisposableBean、配置資訊 destroy-method，兩種方式。而這兩種方式的銷燬動作是由 AbstractApplicationContext 在註冊虛擬機器鉤子後看，虛擬機器關閉前執行的操作動作。 - 那麼在銷燬執行時不太希望還得關注都銷燬那些型別的方法，它的使用上更希望是有一個統一的介面進行銷燬，所以這裡就新增了適配類，做統一處理。
6. 建立Bean時註冊銷燬方法物件
cn.bugstack.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
@Override
protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
Object bean = null;
try {
bean = createBeanInstance(beanDefinition, beanName, args);
// 給 Bean 填充屬性
applyPropertyValues(beanName, bean, beanDefinition);
// 執行 Bean 的初始化方法和 BeanPostProcessor 的前置和後置處理方法
bean = initializeBean(beanName, bean, beanDefinition);
} catch (Exception e) {
throw new BeansException("Instantiation of bean failed", e);
}
// 註冊實現了 DisposableBean 介面的 Bean 物件
registerDisposableBeanIfNecessary(beanName, bean, beanDefinition);
addSingleton(beanName, bean);
return bean;
}
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, BeanDefinition beanDefinition) {
if (bean instanceof DisposableBean || StrUtil.isNotEmpty(beanDefinition.getDestroyMethodName())) {
registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, beanDefinition));
}
}
}
- 在建立 Bean 物件的例項的時候，需要把銷燬方法儲存起來，方便後續執行銷燬動作進行呼叫。
- 那麼這個銷燬方法的具體方法資訊，會被註冊到 DefaultSingletonBeanRegistry 中新增加的
Map<String, DisposableBean> disposableBeans屬性中去，因為這個介面的方法最終可以被類 AbstractApplicationContext 的 close 方法通過getBeanFactory().destroySingletons()呼叫。 - 在註冊銷燬方法的時候，會根據是介面型別和配置型別統一交給 DisposableBeanAdapter 銷燬介面卡類來做統一處理。實現了某個介面的類可以被 instanceof 判斷或者強轉後呼叫介面方法
7. 虛擬機器關閉鉤子註冊呼叫銷燬方法
cn.bugstack.springframework.context.ConfigurableApplicationContext
public interface ConfigurableApplicationContext extends ApplicationContext {
void refresh() throws BeansException;
void registerShutdownHook();
void close();
}
- 首先我們需要在 ConfigurableApplicationContext 介面中定義註冊虛擬機器鉤子的方法
registerShutdownHook和手動執行關閉的方法close。
cn.bugstack.springframework.context.support.AbstractApplicationContext
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
// ...
@Override
public void registerShutdownHook() {
Runtime.getRuntime().addShutdownHook(new Thread(this::close));
}
@Override
public void close() {
getBeanFactory().destroySingletons();
}
}
- 這裡主要體現了關於註冊鉤子和關閉的方法實現，上文提到過的
Runtime.getRuntime().addShutdownHook，可以嘗試驗證。在一些中介軟體和監控系統的設計中也可以用得到，比如監測伺服器當機，執行備機啟動操作。
五、測試
1. 事先準備
cn.bugstack.springframework.test.bean.UserDao
public class UserDao {
private static Map<String, String> hashMap = new HashMap<>();
public void initDataMethod(){
System.out.println("執行：init-method");
hashMap.put("10001", "小傅哥");
hashMap.put("10002", "八杯水");
hashMap.put("10003", "阿毛");
}
public void destroyDataMethod(){
System.out.println("執行：destroy-method");
hashMap.clear();
}
public String queryUserName(String uId) {
return hashMap.get(uId);
}
}
cn.bugstack.springframework.test.bean.UserService
public class UserService implements InitializingBean, DisposableBean {
private String uId;
private String company;
private String location;
private UserDao userDao;
@Override
public void destroy() throws Exception {
System.out.println("執行：UserService.destroy");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("執行：UserService.afterPropertiesSet");
}
// ...get/set
}
- UserDao，修改了之前使用 static 靜態塊初始化資料的方式，改為提供 initDataMethod 和 destroyDataMethod 兩個更優雅的操作方式進行處理。
- UserService，以實現介面 InitializingBean, DisposableBean 的兩個方法 destroy()、afterPropertiesSet()，處理相應的初始化和銷燬方法的動作。afterPropertiesSet，方法名字很好，在屬性設定後執行
2. 配置檔案
基礎配置，無BeanFactoryPostProcessor、BeanPostProcessor，實現類
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userDao" class="cn.bugstack.springframework.test.bean.UserDao" init-method="initDataMethod" destroy-method="destroyDataMethod"/>
<bean id="userService" class="cn.bugstack.springframework.test.bean.UserService">
<property name="uId" value="10001"/>
<property name="company" value="騰訊"/>
<property name="location" value="深圳"/>
<property name="userDao" ref="userDao"/>
</bean>
</beans>
- 配置檔案中主要是新增了，
init-method="initDataMethod" destroy-method="destroyDataMethod"，這樣兩個配置。從原始碼的學習中可以知道，這兩個配置是為了加入到 BeanDefinition 定義類之後寫入到類 DefaultListableBeanFactory 中的 beanDefinitionMap 屬性中去。
3. 單元測試
@Test
public void test_xml() {
// 1.初始化 BeanFactory
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring.xml");
applicationContext.registerShutdownHook();
// 2. 獲取Bean物件呼叫方法
UserService userService = applicationContext.getBean("userService", UserService.class);
String result = userService.queryUserInfo();
System.out.println("測試結果：" + result);
}
- 測試方法中新增加了一個，註冊鉤子的動作。
applicationContext.registerShutdownHook();
測試結果
執行：init-method
執行：UserService.afterPropertiesSet
測試結果：小傅哥,騰訊,深圳
執行：UserService.destroy
執行：destroy-method
Process finished with exit code 0
- 從測試結果可以看到，我們的新增加的初始和銷燬方法已經可以如期輸出結果了。
六、總結
- 本文主要完成了關於初始和銷燬在使用介面定義
implements InitializingBean, DisposableBean和在spring.xml中配置init-method="initDataMethod" destroy-method="destroyDataMethod"的兩種具體在AbstractAutowireCapableBeanFactory完成初始方法和AbstractApplicationContext處理銷燬動作的具體實現過程。 - 通過本文的實現內容，可以看到目前這個 Spring 框架對 Bean 的操作越來越完善了，可擴充套件性也不斷的增強。你既可以在Bean註冊完成例項化前進行 BeanFactoryPostProcessor 操作，也可以在Bean例項化過程中執行前置和後置操作，現在又可以執行Bean的初始化方法和銷燬方法。所以一個簡單的Bean物件，已經被賦予了各種擴充套件能力。
- 在學習和動手實踐 Spring 框架學習的過程中，特別要注意的是它對介面和抽象類的把握和使用，尤其遇到類似，A繼承B實現C時，C的介面方法由A繼承的父類B實現，這樣的操作都蠻有意思的。也是可以複用到通常的業務系統開發中進行處理一些複雜邏輯的功能分層，做到程式的可擴充套件、易維護等特性。