一般生活中我们办理一件事需要一套指定的流水线。例如银行办事，需要先去营业厅取号、排队、办理业务、综合评分。这一套固有的流程，取号、排队、综合评分等都是固定的，不同的客户会办理不同的业务，只有这块是没个客户不同的。类似于这种有固定的流水线，在软件设计的过程中，也是时长被使用到的。
定义这条流水线的方法为模板方法，执行到每个环节在调取相应方法的函数。在设计模式中，此类的问题为模板方法模式，下面就通过案例来说一下模板方法的使用。

定义及结构特点

看下GOF《设计模式》一书中的定义：模板方法模式在一个方法中定义一个算法⻣架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。

1.模板模式的结构

• 抽象类模板方法 定义模板执行顺序，需要执行的函数

• 具体类 实现模板方法中的特定方法和钩子方法

抽象类中一般有三种类型方法：
1)、普通方法，定义固有的方法
2)、抽象方法，各子类对象需要自定义实现的方法，也就是定义中提到的，推迟到子类中实现的方法。
3)、钩子方法，一般是由子类决定是否重写，来决定模板方法中是否执行某块逻辑

2.模板方法结构图：

代码案例

1.案例1

• 抽象类 指定模板

//抽象类
public abstract class AbstractClass {//模板方法 算法骨架public void templateMethod() {method1();abstractMethod();method2();}public void method1(){System.out.println("模板方法1");}public void method2(){System.out.println("模板方法2");}// 抽象方法 推迟到子类执行的方法protected abstract void abstractMethod();
}

• 具体实现类1

public class ConcreteClass extends AbstractClass{@Overrideprotected void abstractMethod() {System.out.println("具体模板方法1");	}
}

• 具体实现类2

public class ConcreteClass2 extends AbstractClass{@Overrideprotected void abstractMethod() {System.out.println("具体模板方法2");	}
}

• 使用方

public class Client {public static void main(String[] args) {AbstractClass abstractClass = 	new ConcreteClass();abstractClass.templateMethod();System.out.println("----------------");AbstractClass abstractClass2 = 	new ConcreteClass2();abstractClass2.templateMethod();}
}

执行结果：

模板方法1
具体模板方法1
模板方法2
----------------
模板方法1
具体模板方法2
模板方法2

执行结果中，模板方法中的普通方法method1,method2，都是在抽象类中定义的，所有的子类对象执行模板方法时，都一样，自定义的部分在抽象方法中。这就是模板模式的基本骨架，很简单。

2.案例2

案例2，通过模拟网上购物的流程(选择商品、加入购物车、增加运费险、下单、付款)，来体会一下模板模式的使用。包括钩子函数的使用。

• 抽象类

//抽象流程
public abstract class AbstractFlow {// 购物流程模板public void shoppingTemplate() {choose();addShopStore();//钩子方法if (hook()) {freightInsurance();}order();pay();}// 商品选择public void choose() {System.out.println("商品选选择阶段");}// 加入购物车public void addShopStore() {System.out.println("加入购物车");}// 下单public void order() {System.out.println("下单...跳转付款页面");}// 运费险public void freightInsurance() {System.out.println("附加运费险");}//钩子函数public boolean hook() {return false;}// 付款protected abstract void pay();}

• 具体实现类1 买一双鞋子 （无需运费险）

public class ShopShoeFlow extends AbstractFlow{@Overrideprotected void pay() {System.out.println("购买鞋子花费：500元");}
}

-具体实现类2 买一件T-shirt (需要运费险)

public class ShopTshirtFlow extends AbstractFlow {public boolean hook() {// 衣服的尺寸因为每个品牌都不标准，这里重写钩子函数，方便增加运费险return true;}@Overrideprotected void pay() {System.out.println("购买 T-shirt 花费：300元");	}
}

• 使用方

public class Client {public static void main(String[] args) {// 购买鞋子AbstractFlow shopShoeFlow = new ShopShoeFlow();shopShoeFlow.shoppingTemplate();System.out.println("-----------");	// 购买一件T-shirtAbstractFlow shopTshirtFlow = new ShopTshirtFlow();shopTshirtFlow.shoppingTemplate();}
}

执行结果：

商品选选择阶段
加入购物车
下单...跳转付款页面
购买鞋子花费：500元
-----------
商品选选择阶段
加入购物车
附加运费险
下单...跳转付款页面
购买 T-shirt 花费：300元

案例2结构：

我们买东西其他的流程都是一样，只有在最后付款的时候，因为不同的商品最终付款的价格也是不同的。所有把付款的方法推迟到购买具体商品的子类中实现；钩子方法的使用，钩子方法是控制整个模板算法骨架中，某一部分不是必须要在整个流程中的部分。这里可以通过子类重写钩子函数的方式，来控制注册分功能是否要在整个流程中执行。

对于鞋子来说一般我们鞋码都是固定的，不同品牌之间有细微的差别，基本不会买错。但是衣服来说的话，差别就很大，不同款式（运动、休闲）不同品牌之间的尺码都不一致。买错有更大的风险，所以对买衣服增加个运费险，通过重写钩子函数来实现。

模板模式的优缺点及应用场景

优点：

• 它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
• 它在父类中提取了公共的部分代码，便于代码复用。
• 部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。

缺点：

• 对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象，间接地增加了系统实现的复杂度；
• 由于继承关系自身的缺点，如果父类添加新的抽象方法，则所有子类都要改一遍，增加了代码的耦合性。

应用场景

• 整个流程有固定的环境，但是其中某部分不同
• 当多个子类存在公共的行为时，可以将其提取出来并集中到
• 需要灵活的控制整个算法固件中各部分的执行流程（钩子函数）

模板模式在源码中的使用

1.Mybatis中模板模板方法的使用

列举一例，BaseExecutor提供了基本sql执行方法，实现了sql执行逻辑，骨架是定义好了，部分特定的实现是在子类的方法中实现的。如事务管理、缓存管理。

// 查询public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());if (closed) {throw new ExecutorException("Executor was closed.");}if (queryStack == 0 && ms.isFlushCacheRequired()) {clearLocalCache();}List<E> list;try {queryStack++;list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;if (list != null) {handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);} else {// 调用查询方法list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);}} finally {queryStack--;}if (queryStack == 0) {for (DeferredLoad deferredLoad : deferredLoads) {deferredLoad.load();}// issue #601deferredLoads.clear();if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {// issue #482clearLocalCache();}}return list;}// 修改@Overridepublic int update(MappedStatement ms, Object parameter) throws SQLException {ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());if (closed) {throw new ExecutorException("Executor was closed.");}clearLocalCache();// 调用修改return doUpdate(ms, parameter);}//...略// 抽象方法protected abstract int doUpdate(MappedStatement ms, Object parameter)throws SQLException;protected abstract List<BatchResult> doFlushStatements(boolean isRollback)throws SQLException;protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)throws SQLException;protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql)throws SQLException;

BaseExecutor类实现Executor接口中的query()、update()...等等，都是提供一个执行流程，最终调用了本类中的抽象方法，具体的实现是放在子类中实现。

子类的实现有四个，分别不同实现了抽象类中的方法，子类的功能：

• SimpleExecutor 是 Mybatis 执行 Mapper 语句时默认使用的 Executor，提供最基本的 Mapper 语句执行功能，没有过多的封装。
• ReuseExecutor 提供了 Statement 重用的功能，通过 statementMap 字段缓存使用过的 Statement 对象进行重用，可以减少 SQL 预编译以及创建和销毁 Statement 对象的开销，从而提高性能。
• BatchExecutor 实现了批处理多条 SQL 语句的功能，在客户端缓存多条 SQL 并在合适的时机将多条 SQL 打包发送给数据库执行，从而减少网络方面的开销，提升系统的性能。
• ClosedExecutor 是个类的一个内部类

2.Servlet中模式模式的使用

Servlet AIP是Java Servlet制定的标准， 可以使用 javax.servlet 和 javax.servlet.http 包创建. Java Servlet 是运行在Web服务器或应用服务器上的程序，它是作为来自Web浏览器或其他HTTP客户端的请求和HTTP服务器上的数据库或应用程序之间的中间层。
支持Http协议HttpServlet,HttpServlet 继承于 GenericServlet，实现了Servlet接口，HttpServlet提供了Http协议的请求。

//根据请求方式不同，调用不听方法
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {String method = req.getMethod();long lastModified;if (method.equals("GET")) {lastModified = this.getLastModified(req);if (lastModified == -1L) {this.doGet(req, resp);} else {long ifModifiedSince;try {ifModifiedSince = req.getDateHeader("If-Modified-Since");} catch (IllegalArgumentException var9) {ifModifiedSince = -1L;}if (ifModifiedSince < lastModified / 1000L * 1000L) {this.maybeSetLastModified(resp, lastModified);this.doGet(req, resp);} else {resp.setStatus(304);}}} else if (method.equals("HEAD")) {lastModified = this.getLastModified(req);this.maybeSetLastModified(resp, lastModified);this.doHead(req, resp);} else if (method.equals("POST")) {this.doPost(req, resp);} else if (method.equals("PUT")) {this.doPut(req, resp);} else if (method.equals("DELETE")) {this.doDelete(req, resp);} else if (method.equals("OPTIONS")) {this.doOptions(req, resp);} else if (method.equals("TRACE")) {this.doTrace(req, resp);} else {String errMsg = lStrings.getString("http.method_not_implemented");Object[] errArgs = new Object[]{method};errMsg = MessageFormat.format(errMsg, errArgs);resp.sendError(501, errMsg);}}
// httpServlet dogetprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {String protocol = req.getProtocol();String msg = lStrings.getString("http.method_get_not_supported");if (protocol.endsWith("1.1")) {resp.sendError(405, msg);} else {resp.sendError(400, msg);}}//... doPost doHead  doPut ..略

这里的模板方法就是Service(),根据不同的请求，调用HttpServlet中的指定方法，这里篇幅有限贴了 doGet()方法，发现没有任何实现。会报40*的错误，看下Httpservelet的子类。

这里具体的方法都由子类来实现，HttpServlet不能被实例化是个抽象类，具体的方法请求都由子类来实现，HttpServlet在这里充当模板模式的抽象类，不同子类的实现为具体的实现类，重新不同请求方法。

✨✨ 欢迎🔔订阅个人的微信公众号 享及时博文更新