折騰Java設計模式之模板方法模式

博客原文地址：折騰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.

翻譯過來就是，把算法的框架定義好，可以將某些步抽象出來放到子類去實現(xiàn)。模板方法允許子類在不改變算法框架的情況下重新實現(xiàn)算法的某些步驟。

模板方法模式UML圖

UML圖

cdn.xitu.io/2019/4/1/169d676374d89d71?w=500&h=240&f=jpeg&s=12703">

抽象類AbstractClass定義了算法框架templateMethod()方法，其中有2個方法primitve1()和primitve2()被抽象出來，子類SubClass1繼承了抽象類AbstractClass，從而實現(xiàn)了primitve1()和primitve2()。

模板方法模式角色

抽象類(AbstractClass)： 定義了算法核心框架，同時把局部的算法行為封裝成步驟，讓子類去實現(xiàn)。

子類(SubClass): 繼承了抽象類，實現(xiàn)抽象類中的抽象方法，具體實現(xiàn)了算法部分邏輯。

模板方法模式源碼示例

源碼地址：Template-method

抽象方法

先定義抽象類，抽象類AbstractProcessor中核心算法handle方法中大體分3部，第一先校驗參數(shù)具體怎么校驗放在子類中實現(xiàn)，第二獲取結果也放在子類實現(xiàn)，第三獲取結果后的操作也放在子類實現(xiàn)。

@Slf4j
public abstract class AbstractProcessor<P extends Request, R extends Response> {

    /**
     * 邏輯處理
     *
     * @param request
     * @return
     */
    public R handle(P request) {
        // 1.校驗參數(shù)
        log.info("開始處理, 請求參數(shù)={}", request);
        validRequest(request);

        // 2.獲取結果
        R response = getResponse(request);
        log.info("獲取結果, 響應結果={}", response);

        // 3.結果之后的處理
        afterHandle(response);
        return response;
    }

    /**
     * 結果之后的處理 可以更新其他業(yè)務或者處理緩存
     *
     * @param response
     */
    protected abstract void afterHandle(R response);

    /**
     * 校驗請求參數(shù)
     *
     * @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);
    }

    /**
     * 校驗請求真正的參數(shù)
     * @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;

}

子類實現(xiàn)

第一個子類實現(xiàn)

@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參數(shù)...省略......");
    }

    @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;

}

第二個子類實現(xiàn)

@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參數(shù)...省略......");
    }

    @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中，后續(xù)只需要根據(jù)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);
    }

}

執(zhí)行程序

@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);

    }
}

結果

總體上來講，抽象類中定義了算法的框架，然后把部分算法步驟抽象出來供子類實現(xiàn)，有的時候有些方法只有個別子類會去實現(xiàn)，我們可以在抽象類中實現(xiàn)為空實現(xiàn)，在有需要的子類中我們可以覆蓋抽象類的實現(xiàn)，這樣避免了所有的子類都去實現(xiàn)，其實不關心的話都是空實現(xiàn)了。本示例用到了lombok的@SuperBuilder特性，可能在下載完完整的代碼后會出現(xiàn)編譯錯誤，這是因為Lombok的插件暫時還不支持@SuperBuilder。

模板方法模式總結

模板方法經(jīng)常和其他模式混合使用，比如工廠、策略等等。其實在Spring中大量使用了模板方法模式，其實也不光在Spring中，像平時jdbcTemplate或者RedisTemplate，像這種帶有Template的。

優(yōu)點 1、封裝不變部分，擴展可變部分。 2、提取公共代碼，便于維護。 3、行為由父類控制，子類實現(xiàn)。

缺點 每一個不同的實現(xiàn)都需要一個子類來實現(xiàn)，導致類的個數(shù)增加，使得系統(tǒng)更加龐大。

使用場景 1、有多個子類共有的方法，且邏輯相同。 2、重要的、復雜的方法，可以考慮作為模板方法。

注意事項 為防止惡意操作，一般模板方法都加上 final 關鍵詞。

參考

模板模式|菜鳥教程

Template method pattern

歡迎關注我的微信公眾號