比如我们项目中有很多调用第三方系统的功能(如支付宝或微信)，实际无非就是以下几步:
1.组装调用支付宝或微信需要的参数
2.请求支付宝或微信
3.解析支付宝或微信的响应参数
4.针对调用异常处理(非必须,子类可重写)
这是固定的流程或者模板。
接下来咱们以请求支付宝和微信为例：

先定义一个抽象类

package com.lifeng.patterns.templatemethod;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by lifeng on 2019/10/16.
 * 远程调用抽象类
 */
public abstract class AbstractRemoteCall {
    
    private static final Logger log = LoggerFactory.getLogger(AbstractRemoteCall.class);

    public Map<String,Object> execute(Map<String,Object> reqMap) throws Exception{
    
        Object vo = getBean(reqMap);
        Map<String, Object> rspMap = new HashMap<String, Object>();
        Object ret = null;
        try {
    
            log.debug("请求数据为："+vo);
            ret = executeBiz(vo);
            log.debug("返回数据为："+ret);
        } catch (Exception e) {
    
            exceptionHandle(e, rspMap);
        }
        rspMap=getRspMap(ret,rspMap);
        return rspMap;
    }

    /** 组装请求参数bean*/
    protected abstract Object getBean(Map<String, Object> reqMap);

    /** 执行业务*/
    public abstract Object executeBiz(Object obj) throws Exception;

    /** 解析转换响应参数*/
    public abstract Map<String, Object> getRspMap(Object ret,Map<String, Object> rspMap) throws Exception;

    /** 异常处理*/
    protected void exceptionHandle(Exception e,Map<String, Object> rspMap) throws Exception{
    
        if(e instanceof NullPointerException){
    
            log.error("参数异常",e);
            rspMap.put("code","423");
            rspMap.put("msg","参数异常");
        }else if(e instanceof Exception){
    
            log.error("系统异常",e);
            rspMap.put("code","500");
            rspMap.put("msg","异常异常");
        }
    }
}

抽象类定义了流程模板，在抽象类中定义了一系列的操作，每个操作可以使具体的，也可以是抽象的，每个操作对应一个算法的步骤，在子类中可以重新定义或实现这些步骤。execute这个方法用于定义一个算法结构，模板方法不仅可以调用在抽象类中实现的基本方法，也可以调用在抽象类的子类中实现的基本方法，还可以调用其他对象中的方法。

用于实现在父类中声明的抽象基本操作，也可以覆盖在父类中已经实现的具体基本操作

调用支付宝实现类

涉及到的支付宝和微信的Dto 略，自己写下哦。。。

/**
 * Created by lifeng on 2019/10/16.
 * 调用支付宝
 */
public class AliPayReromeCall extends AbstractRemoteCall{
    
    @Override
    protected Object getBean(Map<String, Object> reqMap) {
    
        AlipayDto alipayDto = new AlipayDto();
        alipayDto.setpId((String) reqMap.get("merid"));
        alipayDto.setOrderNo((String) reqMap.get("orderno"));
        alipayDto.setAmt((Long) reqMap.get("amt"));
        alipayDto.setBody((String) reqMap.get("body"));
        return alipayDto;
    }

    @Override
    public Object executeBiz(Object obj) throws Exception {
    
        //TODO 模拟调用远程
        AlipayDto alipayDto = new AlipayDto();
        alipayDto.setRetCode("200");
        alipayDto.setRetMsg("交易成功");
        alipayDto.setOrderNo("1111111111");
        return alipayDto;
    }

    @Override
    public Map<String, Object> getRspMap(Object ret, Map<String, Object> rspMap) throws Exception {
    
        AlipayDto alipayDto = (AlipayDto) ret;
        rspMap.put("orderno",alipayDto.getOrderNo());
        rspMap.put("rspcode",alipayDto.getRetCode());
        rspMap.put("rspmsg",alipayDto.getRetMsg());
        return rspMap;
    }
}

调用微信实现类

/**
 * Created by lifeng on 2019/10/16.
 * 调用微信
 */
public class WechatPayReromeCall extends AbstractRemoteCall{
    
    @Override
    protected Object getBean(Map<String, Object> reqMap) {
    
        WechatpayDto wechatpayDto = new WechatpayDto();
        wechatpayDto.setMchId((String) reqMap.get("merid"));
        wechatpayDto.setMerNo((String) reqMap.get("orderno"));
        wechatpayDto.setTranAmt((Long) reqMap.get("amt"));
        wechatpayDto.setGoodsName((String) reqMap.get("body"));
        return wechatpayDto;
    }

    @Override
    public Object executeBiz(Object obj) throws Exception {
    
        //TODO 模拟调用远程
        WechatpayDto wechatpayDto = new WechatpayDto();
        wechatpayDto.setCode("200");
        wechatpayDto.setMsg("交易成功");
        wechatpayDto.setMerNo("11111111111");
        return wechatpayDto;
    }

    @Override
    public Map<String, Object> getRspMap(Object ret, Map<String, Object> rspMap) throws Exception {
    
        WechatpayDto wechatpayDto = (WechatpayDto) ret;
        rspMap.put("orderno",wechatpayDto.getMerNo());
        rspMap.put("rspcode",wechatpayDto.getCode());
        rspMap.put("rspmsg",wechatpayDto.getMsg());
        return rspMap;
    }
}

客户端调用时：

public class MyClient {
    
    public static void main(String[] args) throws Exception {
    
        //请求支付宝
        AliPayReromeCall aliPayReromeCall = new AliPayReromeCall();
        Map<String,Object> payReqMap = new HashMap<String,Object>();
        payReqMap.put("merid","4543345454");
        payReqMap.put("orderno","20191012112312345");
        payReqMap.put("amt",1L);
        payReqMap.put("body","iphone11");
        Map<String,Object> resMap = aliPayReromeCall.execute(payReqMap);
        System.out.println("支付宝返回:"+resMap);

        //请求微信
        WechatPayReromeCall wechatPayReromeCall = new WechatPayReromeCall();
        Map<String,Object> wresMap = wechatPayReromeCall.execute(payReqMap);
        System.out.println("微信返回:"+resMap);
    }
}

假如某天又对接了银联云闪付,流程还一样的，只需实现抽象类，实现父类的方法。也符合

开闭原则(OCP)：是5大设计原则中最基础的设计原则，指的是一个软件实体如类、接口等应该对扩展开放，对修改关闭。
模板方法：定义一个操作算法中的框架，而将这些步骤延迟加载到子类中

优点:
1.让父类控制子类方法的调用顺序。只需要考虑方法的实现
2.不需要考虑方法在何种情况下被调用。实现代码复用。
3.模板类，将核心算法与具体子类相分离，子类只需要覆写具体的某几步流程即可
常用场景：
1.一次性实现一个算法的不变部分，并将可变的行为留给子类来实现；
2.各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复

是不是很简单，你可能平时开发也使用这是设计，只是不知道它原来是模板设计模式。哈哈
使用了模板方法的地方：servlet中HttpServlet的父类GenericServlet的service方法，HttpServlet重写了service，这段代码流程是固定的，子类需要重写doGet 或者doPost等

还有RedisTemplate JdbcTemplate都使用了模板方法。
代码参考码云gitee https://gitee.com/lifengit/javapatterns