折騰Java設計模式之模板方法模式
Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.
翻譯過來就是，把演算法的框架定義好，可以將某些步抽象出來放到子類去實現。模板方法允許子類在不改變演算法框架的情況下重新實現演算法的某些步驟。
模板方法模式UML圖
UML圖
抽象類 AbstractClass 定義了演算法框架 templateMethod() 方法，其中有2個方法 primitve1() 和 primitve2() 被抽象出來，子類 SubClass1 繼承了抽象類 AbstractClass ，從而實現了 primitve1() 和 primitve2() 。
模板方法模式角色
抽象類(AbstractClass)：定義了演算法核心框架，同時把區域性的演算法行為封裝成步驟，讓子類去實現。
子類(SubClass):繼承了抽象類，實現抽象類中的抽象方法，具體實現了演算法部分邏輯。
模板方法模式原始碼示例
原始碼地址： Template-method
抽象方法
先定義抽象類，抽象類 AbstractProcessor 中核心演算法 handle 方法中大體分3部，第一先校驗引數具體怎麼校驗放在子類中實現，第二獲取結果也放在子類實現，第三獲取結果後的操作也放在子類實現。
@Slf4j
public abstract class AbstractProcessor<P extends Request, R extends Response> {
/**
* 邏輯處理
*
* @param request
* @return
*/
public R handle(P request) {
// 1.校驗引數
log.info("開始處理, 請求引數={}", request);
validRequest(request);
// 2.獲取結果
R response = getResponse(request);
log.info("獲取結果, 響應結果={}", response);
// 3.結果之後的處理
afterHandle(response);
return response;
}
/**
* 結果之後的處理 可以更新其他業務或者處理快取
*
* @param response
*/
protected abstract void afterHandle(R response);
/**
* 校驗請求引數
*
* @param request
*/
protected void validRequest(P request) {
if (Objects.isNull(request.getToken())) {
throw new RuntimeException("token不能為空");
}
if (Objects.isNull(request.getVersion())) {
throw new RuntimeException("version不能為空");
}
validRequestParam(request);
}
/**
* 校驗請求真正的引數
* @param request
*/
protected abstract void validRequestParam(P request);
/**
* 獲取到結果
* @param request
* @return
*/
protected abstract R getResponse(P request);
}
複製程式碼
基本請求
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class Request {
private String version;
private String token;
}
複製程式碼
基本響應
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class Response {
private String msg;
private int code;
private boolean success;
}
複製程式碼
子類實現
第一個子類實現
@Slf4j
public class OneProcessor extends AbstractProcessor<OneRequest, OneResponse> {
public OneProcessor() {
ProcessorFactory.putProcess("two", this);
}
@Override
protected void afterHandle(OneResponse response) {
log.info("處理One結果： {}", response.getOne());
}
@Override
protected void validRequestParam(OneRequest request) {
log.info("校驗one引數...省略......");
}
@Override
protected OneResponse getResponse(OneRequest request) {
String name = request.getName();
return OneResponse.builder()
.one(name + "one")
.success(true)
.code(0)
.msg("成功")
.build();
}
}
複製程式碼
第一個子類的請求
@Data
@ToString(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class OneRequest extends Request {
private String name;
@Builder.Default
private int a = 0;
}
複製程式碼
第一個子類的響應
@Data
@ToString(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class OneResponse extends Response {
private String one;
}
複製程式碼
第二個子類實現
@Slf4j
public class TwoProcessor extends AbstractProcessor<TwoRequest, TwoResponse> {
public TwoProcessor() {
ProcessorFactory.putProcess("two", this);
}
@Override
protected void afterHandle(TwoResponse response) {
log.info("處理結果TWO, {}", response);
}
@Override
protected void validRequestParam(TwoRequest request) {
log.info("校驗TWO引數...省略......");
}
@Override
protected TwoResponse getResponse(TwoRequest request) {
Long id = request.getId();
return TwoResponse.builder()
.two("id為"+id)
.success(true)
.code(0)
.msg("成功")
.build();
}
}
複製程式碼
第二個子類的請求
@Data
@ToString(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class TwoRequest extends Request {
private Long id;
}
複製程式碼
第二個子類的響應
@Data
@ToString(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class TwoResponse extends Response {
private String two;
}
複製程式碼
擴充套件為工廠
有的時候我們定義的子類在Spring容器的時候由Spring定義好後，我們其實可以借用工廠模式方法，在子類初始化的時候就把子類放置在 ProcessorFactory 中，後續只需要根據key從中拿取即可，實際專案中用這種方式還是比較多的。
public class ProcessorFactory {
private static Map<String, AbstractProcessor> factories = new HashMap();
public static void putProcess(String key, AbstractProcessor process) {
factories.put(key, process);
}
public static AbstractProcessor selectProcess(String key) {
return factories.get(key);
}
}
複製程式碼
執行程式
@Slf4j
public class TemplateMethodApplication {
public static void main(String[] args) {
OneRequest oneRequest = OneRequest.builder()
.version("2312312")
.token("23423")
.name("張三")
.build();
new OneProcessor().handle(oneRequest);
log.info("--------------------------");
TwoRequest twoRequest = TwoRequest.builder()
.version("2312312")
.token("23423")
.id(23456L)
.build();
new TwoProcessor().handle(twoRequest);
}
}
複製程式碼
結果
總體上來講，抽象類中定義了演算法的框架，然後把部分演算法步驟抽象出來供子類實現，有的時候有些方法只有個別子類會去實現，我們可以在抽象類中實現為空實現，在有需要的子類中我們可以覆蓋抽象類的實現，這樣避免了所有的子類都去實現，其實不關心的話都是空實現了。本示例用到了 lombok 的 @SuperBuilder 特性，可能在下載完完整的程式碼後會出現編譯錯誤，這是因為 Lombok 的外掛暫時還不支援 @SuperBuilder 。
模板方法模式總結
模板方法經常和其他模式混合使用，比如工廠、策略等等。其實在Spring中大量使用了模板方法模式，其實也不光在Spring中，像平時jdbcTemplate或者RedisTemplate，像這種帶有Template的。
優點1、封裝不變部分，擴充套件可變部分。 2、提取公共程式碼，便於維護。 3、行為由父類控制，子類實現。
缺點每一個不同的實現都需要一個子類來實現，導致類的個數增加，使得系統更加龐大。
使用場景1、有多個子類共有的方法，且邏輯相同。 2、重要的、複雜的方法，可以考慮作為模板方法。
注意事項為防止惡意操作，一般模板方法都加上 final 關鍵詞。