設計模式之（13）--模板方法模式

今天我們來學習下模板方法設計模式。模板方法(Template Method Pattern)：抽象的父類中定義一個操作中演算法的骨架，而將一些步驟延遲到子類中。使得子類可以不改變一個演算法的結構，即可重新定義該演算法的某些特定步驟。簡單地講，就是“父類的模板方法定義不變的流程，子類重寫流程中的方法”。 ...

　　今天我們來學習下模板方法設計模式。

　　模板方法(Template Method Pattern)：抽象的父類中定義一個操作中演算法的骨架，而將一些步驟延遲到子類中。使得子類可以不改變一個演算法的結構，即可重新定義該演算法的某些特定步驟。簡單地講，就是“父類的模板方法定義不變的流程，子類重寫流程中的方法”。

　　類圖如下所示：

　　在上面UML類圖中我們定義了兩種角色：

　　1、抽象模板（AbstractSuperClass）：抽象模板類，定義了一套演算法框架/流程；

　　2、具體實現（ConcreteClass）：具體實現類，對演算法框架/流程的某些步驟進行了實現。

　　我們在上面兩種角色中定義的方法可以分為兩類：

　　第一類：諸如baseOperation()或者customOperation()方法，我們認為是基本操作方法，定義類演算法的某些步驟，可以交由子類去實現，按照“迪米特法則”，這些方法應根據需要保持最小的可見性，通常我們將不需要重寫的方法許可權定義為private，而需要重寫的方法訪問許可權設置為protected。

　　第一類：templateMethod()，我們稱之為模板方法，可以有一個或多個，定義演算法的骨架，實現對基本方法的調用，完成固定的邏輯。為了防止惡意操作，這些方法通常定義為final，不容許子類去重寫。

　　這裡有個小技巧：我們儘量不要將這些需要子類實現基本操作方法設置為抽象方法，這是因為有些具體子類實現並不需要重寫這種方法，在抽象模板類中將這些基本方法定義為abstract強迫所有子類去實現就有點強人所難了。但是有些基本操作的方法，在某些特定的模板方法中去調用必須交由子類去實現，我們可以在這個方法定義中拋出一個異常，強迫子類去實現。這類設計在JDK源碼中很常見，如AbstractQueuedSynchronizer類中的acquire(int)、acquireShared(int)、release(int)、releaseShared(int)就是定義的模板方法，而tryAcquire()、tryAcquireShared()、tryReleaseShared()就是基本方法，在AQS中都沒有提供具體的實現邏輯，只是拋出了UnsupportedOperationException()異常，這就需要類似ReentrantLock.Sync、Semaphore.Sync這些子類去按需實現了。

　　故事背景：我司有款產品，被幾個第三方開發商看中，與我司簽訂協議，需要使用他們自身的帳號體系登錄我們的產品直接使用，我司領導為了拿下這些單子，給我們部門下達了這項任務。經過雙方的友好協商，第三方提供用戶的驗證介面，我們只需要去對接就行了。系統用戶登錄驗證的流程基本都是一致的，只是不同的對接方提供的用戶驗證介面和返回結果不同，我們只需要將用戶驗證的骨架流程定義出來，然後針對不同對接渠道定製開發某些特定的步驟就可以了，這也符合程式設計的“開閉原則”。通過上面分析，我腦子裡迅速地過了下，就想到了模版方法設計模式。

　　以下就是一個簡單的測試demo：

 1 package cn.com.pep.model.template;
 2 /**
 3  * @ClassName: AbstractSuperClass
 4  * @Description: 驗證用戶的模版類
 5  * @author: wwh
 6  * @date: 2023年2月24日 下午1:45:06
 7  */
 8 public abstract class AbstractUserCheck {
 9     
10     /**
11      * @Title: domainCheck
12      * @Description: 檢測第三方提供的功能變數名稱是否可用
13      * @param domain
14      * @return 
15      * String 返回類型
16      */
17     private String domainCheck(Object domain){
18         //偽代碼
19         System.err.println("功能變數名稱可訪問...");
20         return "ok";
21     };
22     
23     /**
24      * @Title: tryCheckUser
25      * @Description: 不同渠道用戶驗證的邏輯，強制子類趨勢線
26      * @param obj
27      * @return Object 返回類型
28      */
29     protected Object tryCheckUser(Object ...obj) {
30         throw new UnsupportedOperationException();
31     }
32     
33     /**
34      * @Title: wrapperResult
35      * @Description: 對各個渠道的驗證結果進行轉換，包裝為系統的響應結果
36      * @param response
37      * @return 
38      * Map<String,Object> 返回類型
39      */
40     protected Object wrapperResult(Object ...obj) {
41         throw new UnsupportedOperationException();
42     }
43     
44     /**
45      * 
46      * @Title: userCheck
47      * @Description: 用戶驗證的核心流程（模版方法），定義演算法的骨架
48      * @param domain
49      * @param userInfo
50      * @return 
51      * Map<String,Object> 返回類型
52      */
53     public final Object userCheck(Object...obj) {
54         //1、驗證第三方功能變數名稱是否可用
55         domainCheck(obj);
56         //2、向第三方發起http請求，驗證用戶帳號信息是否合法
57         Object response = tryCheckUser(obj);
58         //3、將第三方響應的信息包裝成我們系統的標準信息
59         return wrapperResult(response);
60     }
61 }

 1 package cn.com.pep.model.template;
 2 /**
 3  * @ClassName: UserCheck4ClientA
 4  * @Description: 渠道A用戶的認證實現
 5  * @author: wwh
 6  * @date: 2023年2月24日 下午2:17:44
 7  */
 8 public class UserCheck4ClientA extends AbstractUserCheck {
 9 
10     /**
11      * @Title: wrapperResult
12      * @Description: 包裝渠道B的認證結果
13      * @param obj
14      * @return
15      * @see cn.com.pep.model.template.AbstractUserCheck#wrapperResult(java.lang.Object[])
16      */
17     @Override
18     protected Object wrapperResult(Object...obj) {
19         //偽代碼
20         System.err.println("包裝渠道到A的返回的認證結果...");
21         return "OK";
22     }
23 
24     /**
25      * @Title: tryCheckUser
26      * @Description: 渠道A的具體的用戶認證邏輯
27      * @param obj
28      * @return
29      * @see cn.com.pep.model.template.AbstractUserCheck#tryCheckUser(java.lang.Object[])
30      */
31     @Override
32     protected Object tryCheckUser(Object ...obj) {
33         //偽代碼
34         System.err.println("****【組織渠道A的請求參數...】****");
35         System.err.println("****【向渠道A開發的功能變數名稱介面發起用戶認證...】");
36         System.err.println("****【將渠道A的認證結果返回...】****");
37         return "OK";
38     }
39 }

 1 package cn.com.pep.model.template;
 2 /**
 3  * @ClassName: UserCheck4ClientB
 4  * @Description: 渠道B的用戶認證實現
 5  * @author: wwh
 6  * @date: 2023年2月24日 下午2:20:09
 7  */
 8 public class UserCheck4ClientB extends AbstractUserCheck{
 9     
10     /**
11      * @Title: wrapperResult
12      * @Description: 包裝渠道B的認證結果
13      * @param obj
14      * @return
15      * @see cn.com.pep.model.template.AbstractUserCheck#wrapperResult(java.lang.Object[])
16      */
17     @Override
18     protected Object wrapperResult(Object ...obj) {
19         //偽代碼
20         System.err.println("包裝渠道到B的返回的認證結果...");
21         return "OK";
22     }
23 
24     /**
25      * @Title: tryCheckUser
26      * @Description: 渠道B的用戶的具體的認證邏輯
27      * @param obj
28      * @return
29      * @see cn.com.pep.model.template.AbstractUserCheck#tryCheckUser(java.lang.Object[])
30      */
31     @Override
32     protected Object tryCheckUser(Object ...obj) {
33         //偽代碼
34         System.err.println("****【組織渠道B的請求參數...】****");
35         System.err.println("****【向渠道B開發的功能變數名稱介面發起用戶認證...】****");
36         System.err.println("****【將渠道B的認證結果返回...】****");
37         return "OK";
38     }
39 }

 1 package cn.com.pep.model.template;
 2 /**
 3  * 
 4  * @ClassName: Client
 5  * @Description: 調用類
 6  * @author: wwh
 7  * @date: 2023年2月24日 下午2:49:34
 8  */
 9 public class Client {
10     
11     public static void main(String[] args) {
12         //1、登錄端登錄，傳入渠道標識
13         AbstractUserCheck userCheck = null;
14         if ("渠道A") {
15             userCheck = new UserCheck4ClientA();
16         }else if ("渠道B") {
17             userCheck = new UserCheck4ClientB();
18         }
19         userCheck.userCheck("用戶輸入的信息...");
20         System.err.println("用戶驗證成功...");
21     }
22 }

　　模版方法的優點：

　　1、把一個演算法中認為是不可變的方法封裝到父類中實現，並禁止繼承，而可變的部分可以通過子類繼承來進行重寫，簡單來講就是“封裝不可變、擴展可變”，符合程式設計的開閉原則；

　　2、提取公共部分代碼，便於後期維護，基本方法是由子類來實現的，因此可以通過擴展子類的方式來增加響應的功能；

　　模版方法的缺點：

　　1、子類的執行結果影響了父類，可能會造成閱讀上的難度；

·　 2、每一個不同的實現都需要一個子類來實現，導致類的個數增加，使得系統更加龐大；

　　註意事項：

　　為了防止模版方法被惡意重寫，一般模版方法加上final修飾。

　　JDK源碼中模版方法的應用：

　　1、上面提到的AQS中的模版方法acquire(int)、acquireShared(int)、release(int)、releaseShared(int)等；

　　2、JDK1.8中Map介面中的putIfAbsent(K key, V value)方法就是一個模版方法，其中調用了get(K key)和put(K key,V value)基本操作方法，但是這兩個方法在Map介面中並沒有實現，而是交由它的實現類去實現。

　　3、JDK1.8中HashMap中的putVal()方法就是一個模版方法，而afterNodeAccess()、afterNodeInsertion()、afterNodeRemoval()都是基本操作方法，需要具體的子類去按需實現。

本文來自博客園，作者：一隻烤鴨朝北走，僅用於技術學習，所有資源都來源於網路，部分是轉發，部分是個人總結。歡迎共同學習和轉載，轉載請在醒目位置標明原文。如有侵權，請留言告知，及時撤除。轉載請註明原文鏈接：https://www.cnblogs.com/wha6239/p/17133046.html