JAVA设计模式之模板方法设计模式

模板模式：在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

主要解决：一些方法通用，却在每一个子类都重新写了这一方法。

何时使用：有一些通用的方法。

如何解决：将这些通用算法抽象出来。

关键代码：在抽象类实现，其他步骤在子类实现。

应用实例：1、在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异。 2、西游记里面菩萨定好的 81 难，这就是一个顶层的逻辑骨架。 3、spring 中对 Hibernate 的支持，将一些已经定好的方法封装起来，比如开启事务、获取 Session、关闭 Session 等，程序员不重复写那些已经规范好的代码，直接丢一个实体就可以保存。

优点：1、封装不变部分，扩展可变部分。 2、提取公共代码，便于维护。 3、行为由父类控制，子类实现。

缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

使用场景：1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。

注意事项：为防止恶意操作，一般模板方法都加上 final 关键词。

核心点：

1、AbstractClass：抽象类，定义并实现一个模板方法。定义了算法的骨架，逻辑组成步骤在相应的抽象操作中，在子类中实现。

2、ConcreteClass：实现父类所定义的一个或多个抽象方法。

废话不多说，直接上手：

项目背景：聚合支付平台，涉及到多种支付方式选择，不同的支付会有不同的支付回调， 在这里，各个支付的回调就是我们共同的行为！

环境准备：JDK8、springboot2.0.x、idea工具、mysql数据库...

异步回调流程：

1、报文解析：签名验证

2、共同的记录操作：如日志记录

3、根据解析报文，修改支付状态，返回支付结果

先定义AbstractClass抽象类：

/**
 * 支付回调抽象类
 *
 * @author zhoumin
 * @create 2020-03-18 22:16
 */
public abstract class AbstractPayCallbackTemplate {

    /**
     * 异步回调共同核心骨架
     * @return
     */
    public String asynCallBack(){
        //报文解析：签名验证
        Map<String,String> verifySignature = verifySignature();
        //日志记录
        addPayLog(verifySignature);
        //判断是否成功
        String result = verifySignature.get("resultCode");
        //根据解析报文，修改支付状态，返回支付结果
        return asyncService(verifySignature);

    }

    /**
     * 支付回调验证参数
     *
     * @return
     */
    protected abstract Map<String, String> verifySignature();


    /**
     * 写入日志：共同行为，不需要定义为 abstract
     *
     */
    private void addPayLog(Map<String, String> verifySignatureMap) {
        //将记录添加至日志表....
        //addLogInfo();
        System.out.println("我把自己写入日志.....");
    }

    /**
     * 每个子类各自实现，处理各自任务
     *
     * @return
     */
    protected abstract String asyncService(Map<String, String> verifySignatureMap);


    /**
     * 子类各自实现成功结果
     *
     * @return
     */
    protected abstract String resultSuccess();

    /**
     * 子类各自实现失败结果
     *
     * @return
     */
    protected abstract String resultFail();

假设现在有一个阿里支付回调的应用：

/**
 * 支付宝回调实现
 *
 * @author zhoumin
 * @create 2020-03-18 22:45
 */
@Component
public class AliPayCallbackTemplate extends AbstractPayCallbackTemplate {


    /**
     * 支付回调验证参数
     *
     * @return
     */
    @Override
    protected Map<String, String> verifySignature() {
        //>>>>假设以下为支付宝回调报文处理>>>>>>>>>>>>>>>>
        System.out.println(" >>>>>解析支付宝据报文.....verifySignature()");
        Map<String, String> verifySignature = new HashMap<>();
        verifySignature.put("receiptAmount", "111");
        verifySignature.put("buyerPayAmount", "110");
        verifySignature.put("tradeStatus", "TRADE_SUCCESS");
        verifySignature.put("tradeNo", "202003182245");
        // 根据状态设置成功或失败，成功- code=200
        verifySignature.put("resultCode", "200");
        return verifySignature;

    }

    /**
     * 每个子类各自实现，处理各自任务
     *
     * @param verifySignatureMap
     * @return
     */
    @Override
    protected String asyncService(Map<String, String> verifySignatureMap) {
        System.out.println(">>>>>处理各自任务，asyncService()verifySignatureMap:" + verifySignatureMap);
        String tradeStatus = verifySignatureMap.get("tradeStatus");
        if (tradeStatus.equals("TRADE_SUCCESS")) {
            String tradeNo = verifySignatureMap.get("tradeNo");
            //找到数据库对应支付数据，修改状态等信息
            System.out.println(">>>>流水号为'"+tradeNo+"'订单，支付成功，修改订单状态为已经支付...");
        }
        return resultSuccess();

    }

    /**
     * 子类各自实现成功结果
     *
     * @return
     */
    @Override
    protected String resultSuccess() {
        System.out.println(">>>>>>>>>>>>>>成功");
        return "success";
    }

    /**
     * 子类各自实现失败结果
     *
     * @return
     */
    @Override
    protected String resultFail() {
        System.out.println(">>>>>>>>>>>>>>失败");
        return "fail";
    }
}

注：其他如微信、银联等，可根据需要增减

定义好之后我们这里同样使用工厂启动：

/**
 * 创建模板方法对应工厂
 *
 * @author zhoumin
 * @create 2020-03-19 21:30
 */
public class TemplateFactory {

    /**
     * 使用工厂模式获取模板(根据beanId获取具体事例）
     * @param templateId
     * @return
     */
    public static AbstractPayCallbackTemplate getPayCallbackTemplate(String templateId){
        AbstractPayCallbackTemplate payCallbackTemplate = (AbstractPayCallbackTemplate) SpringUtils.getBean(templateId);
        return payCallbackTemplate;
    }
}

至此，代码开发完毕，是不是so easy~~

可以写个demo试下是否成功

@RestController
public class TemplateController {

    @RequestMapping("/asynCallBack")
    public String asynCallBack(String templateId){
        AbstractPayCallbackTemplate payCallbackTemplate = TemplateFactory.getPayCallbackTemplate(templateId);
        return payCallbackTemplate.asynCallBack();
    }
}

地址栏输入url： http://localhost :8080/asynCallBack?templateId=aliPayCallbackTemplate

返回结果：

控制打印信息：

在上面代码中，如日志记录等可以添加异步处理等优化

/**
     * 写入日志：共同行为，不需要定义为 abstract
     *
     */
    @Async
    public void addPayLog(Map<String, String> verifySignatureMap) {
        //将记录添加至日志表....
        //addLogInfo();
        System.out.println("我把自己写入日志.....");
    }

与此同时，启动类上别忘记使用 @EnableAsync 注解，开启异步开关。

优点：通过把共同行为放在超类，减少了代码冗余。利用子类实现算法，方便扩展。通过父类调用子类实现操作，通过子类扩展不同的行为，符合“开闭原则”。

缺点：不同的实现都需要定义一个子类，增加子类个数。

那么策略模式和模板模式有什么区别呢？

答：策略对应的是不同的方法，不同的骨架，主要解决多重if；而模板对应的是相同骨架，将不同实现交给子类。

在常用代码中，Servlet就是这一模型很好的应用实例，感兴趣的可以自己打开源码查看，在HttpServlet的service方法中，区分不同的请求类型，完成不同处理！

完~