设计模式 | 模板方法模式及典型应用

悠悠 2022-05-08 10:08 194阅读 0赞

本文的主要内容：

*  介绍模板方法模式
 *  源码分析模板方法模式的典型应用
    
     *  Servlet 中的模板方法模式
     *  Mybatis BaseExecutor接口中的模板方法模式

### 模板方法模式 ###

在程序开发中，经常会遇到这种情况：某个方法要实现的算法需要多个步骤，但其中有一些步骤是固定不变的，而另一些步骤则是不固定的。为了提高代码的可扩展性和可维护性，模板方法模式在这种场景下就派上了用场。

譬如制作一节网课的步骤可以简化为4个步骤：

1.  制作PPT
2.  录制视频
3.  编写笔记
4.  提供课程资料

其中1、2、3的动作在所有课程中的固定不变的，步骤3可有可无，步骤4在每个课程都不同（有些课程需要提供源代码，有些需要提供图片文件等）

我们可以在父类中确定整个流程的循序，并实现固定不变的步骤，而把不固定的步骤留给子类实现。甚至可以通过一个钩子方法，让子类来决定流程中某个方法的执行与否

![示例.模板方法模式][.]

**模板方法模式**：定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。模板方法模式是一种基于继承的代码复用技术，它是一种类行为型模式。

#### 角色 ####

**AbstractClass（抽象类）**：在抽象类中定义了一系列基本操作(PrimitiveOperations)，这些基本操作可以是具体的，也可以是抽象的，每一个基本操作对应算法的一个步骤，在其子类中可以重定义或实现这些步骤。同时，在抽象类中实现了一个模板方法(Template Method)，用于定义一个算法的框架，模板方法不仅可以调用在抽象类中实现的基本方法，也可以调用在抽象类的子类中实现的基本方法，还可以调用其他对象中的方法。

**ConcreteClass（具体子类）**：它是抽象类的子类，用于实现在父类中声明的抽象基本操作以完成子类特定算法的步骤，也可以覆盖在父类中已经实现的具体基本操作。

一个模板方法是定义在抽象类中的、把基本操作方法组合在一起形成一个总算法或一个总行为的方法。这个模板方法定义在抽象类中，并由子类不加以修改地完全继承下来。模板方法是一个具体方法，它给出了一个顶层逻辑框架，而逻辑的组成步骤在抽象类中可以是具体方法，也可以是抽象方法。

基本方法是实现算法各个步骤的方法，是模板方法的组成部分。基本方法又可以分为三种：抽象方法(Abstract Method)、具体方法(Concrete Method)和钩子方法(Hook Method)。

*  抽象方法：一个抽象方法由抽象类声明、由其具体子类实现。
 *  具体方法：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承。
 *  钩子方法：可以与一些具体步骤 “挂钩” ，以实现在不同条件下执行模板方法中的不同步骤

### 示例 ###

所以我们通过模板方法模式，在抽象类中把整个流程固定下来，其中1、2、3的实现在抽象类中完成，3的执行与否则由子类通过钩子方法来控制，4则由子类来实现

抽象类定义如下：

public abstract class ACourse { 
    
        protected final void makeCourse() { 
            this.makePPT();
            this.makeVideo();
            if (needWriteArticle()) { 
                this.writeArticle();
            }
            this.packageCourse();
        }
    
        final void makePPT() { 
            System.out.println("1. 制作PPT");
        }
    
        final void makeVideo() { 
            System.out.println("2. 制作视频");
        }
    
        final void writeArticle() { 
            System.out.println("3. 编写课程笔记");
        }
    
        //钩子方法
        protected boolean needWriteArticle() { 
            return false;
        }
    
        abstract void packageCourse();
    }

其中的 `makeCourse` 方法是模板方法，它定义了制作网课的基本流程，`makePPT`、`makeVideo`、`writeArticle` 这三个步骤在所有课程中都是固定的，所以用 `final` 关键字修饰；`packageCourse` 方法在所有课程中都可能不一样，所以声明为抽象方法，由子类自行实现；钩子方法 `needWriteArticle` 返回一个 `boolean` 类型的值，控制是否编写课程笔记

子类 JavaCourse，实现了抽象方法 `packageCourse`，重写了钩子方法 `needWriteArticle`

public class JavaCourse extends ACourse { 
        @Override
        void packageCourse() { 
            System.out.println("4. 提供Java课程源代码");
        }
    
        @Override
        protected boolean needWriteArticle() { 
            return true;
        }
    }

子类 FECourse，实现了抽象方法 `packageCourse`，重写了钩子方法 `needWriteArticle`，其中把钩子方法的结果交给客户端确定

public class FECourse extends ACourse { 
        private boolean needWriteArticleFlag = false;
        @Override
        void packageCourse() { 
            System.out.println("4.1 提供课程的前端代码");
            System.out.println("4.2 提供课程的图片等多媒体素材");
        }
    
        public FECourse(boolean needWriteArticleFlag) { 
            this.needWriteArticleFlag = needWriteArticleFlag;
        }
    
        @Override
        protected boolean needWriteArticle() { 
            return this.needWriteArticleFlag;
        }
    }

客户端测试

public class Test { 
        public static void main(String[] args) { 
            System.out.println("Java课程start---");
            ACourse javaCourse = new JavaCourse();
            javaCourse.makeCourse();
            System.out.println("Java课程end---\n");
    
    
            System.out.println("前端课程start---");
            ACourse feCourse = new FECourse(false);
            feCourse.makeCourse();
            System.out.println("前端课程end---");
        }
    }

输出结果

Java课程start---
    1. 制作PPT
    2. 制作视频
    3. 编写笔记
    4. 提供Java课程源代码
    Java课程end---
    
    前端课程start---
    1. 制作PPT
    2. 制作视频
    4.1 提供课程的前端代码
    4.2 提供课程的图片等多媒体素材
    前端课程end---

它们的类图如下

![示例.模板方法模式][. 1]

### 模板方法模式总结 ###

模板方法模式的**主要优点**如下：

*  在父类中形式化地定义一个算法，而由它的子类来实现细节的处理，在子类实现详细的处理算法时并不会改变算法中步骤的执行次序。
 *  模板方法模式是一种代码复用技术，它在类库设计中尤为重要，它提取了类库中的公共行为，将公共行为放在父类中，而通过其子类来实现不同的行为，它鼓励我们恰当使用继承来实现代码复用。
 *  可实现一种反向控制结构，通过子类覆盖父类的钩子方法来决定某一特定步骤是否需要执行。
 *  在模板方法模式中可以通过子类来覆盖父类的基本方法，不同的子类可以提供基本方法的不同实现，更换和增加新的子类很方便，符合单一职责原则和开闭原则。

模板方法模式的**主要缺点**如下：

*  需要为每一个基本方法的不同实现提供一个子类，如果父类中可变的基本方法太多，将会导致类的个数增加，系统更加庞大，设计也更加抽象，此时，可结合桥接模式来进行设计。

**适用场景**：

*  对一些复杂的算法进行分割，将其算法中固定不变的部分设计为模板方法和父类具体方法，而一些可以改变的细节由其子类来实现。即：一次性实现一个算法的不变部分，并将可变的行为留给子类来实现。
 *  各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。
 *  需要通过子类来决定父类算法中某个步骤是否执行，实现子类对父类的反向控制。

### 源码分析模板方法模式的典型应用 ###

#### Servlet 中的模板方法模式 ####

`Servlet`（Server Applet）是Java Servlet的简称，用Java编写的服务器端程序，主要功能在于交互式地浏览和修改数据，生成动态Web内容。在每一个 `Servlet` 都必须要实现 `Servlet` 接口，`GenericServlet` 是个通用的、不特定于任何协议的Servlet，它实现了 `Servlet` 接口，而 `HttpServlet` 继承于 `GenericServlet`，实现了 `Servlet` 接口，为 `Servlet` 接口提供了处理HTTP协议的通用实现，所以我们定义的 `Servlet` 只需要继承 `HttpServlet` 即可。

![HttpServlet的继承关系][HttpServlet]

`HttpServlet` 的简要代码如下所示

public abstract class HttpServlet extends GenericServlet { 
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            // ...
        }
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            // ...
        }
        protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            // ...
        }
        protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            // ...
        }
        protected void doDelete(HttpServletRequest req,  HttpServletResponse resp) throws ServletException, IOException { 
            // ...
        }
        protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            // ...
        }
        protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            // ...
        }
        
        protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            String method = req.getMethod();
    
            if (method.equals(METHOD_GET)) { 
                long lastModified = getLastModified(req);
                if (lastModified == -1) { 
                    // servlet doesn't support if-modified-since, no reason
                    // to go through further expensive logic
                    doGet(req, resp);
                } else { 
                    long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                    if (ifModifiedSince < lastModified) { 
                        // If the servlet mod time is later, call doGet()
                        // Round down to the nearest second for a proper compare
                        // A ifModifiedSince of -1 will always be less
                        maybeSetLastModified(resp, lastModified);
                        doGet(req, resp);
                    } else { 
                        resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                    }
                }
    
            } else if (method.equals(METHOD_HEAD)) { 
                long lastModified = getLastModified(req);
                maybeSetLastModified(resp, lastModified);
                doHead(req, resp);
    
            } else if (method.equals(METHOD_POST)) { 
                doPost(req, resp);
                
            } else if (method.equals(METHOD_PUT)) { 
                doPut(req, resp);
                
            } else if (method.equals(METHOD_DELETE)) { 
                doDelete(req, resp);
                
            } else if (method.equals(METHOD_OPTIONS)) { 
                doOptions(req,resp);
                
            } else if (method.equals(METHOD_TRACE)) { 
                doTrace(req,resp);
                
            } else { 
                //
                // Note that this means NO servlet supports whatever
                // method was requested, anywhere on this server.
                //
    
                String errMsg = lStrings.getString("http.method_not_implemented");
                Object[] errArgs = new Object[1];
                errArgs[0] = method;
                errMsg = MessageFormat.format(errMsg, errArgs);
                
                resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
            }
        }
        
        // ...省略...
    }

在 `HttpServlet` 的 `service` 方法中，首先获得到请求的方法名，然后根据方法名调用对应的 `doXXX` 方法，比如说请求方法为GET，那么就去调用 `doGet` 方法；请求方法为POST，那么就去调用 `doPost` 方法

`HttpServlet` 相当于定义了一套处理 HTTP 请求的模板；`service` 方法为模板方法，定义了处理HTTP请求的基本流程；`doXXX` 等方法为基本方法，根据请求方法做相应的处理，子类可重写这些方法；`HttpServletRequest` 中的Method则起到钩子方法的作用.

在开发javaWeb应用时，自定义的Servlet类一般都扩展 `HttpServlet` 类，譬如我们实现一个输出 `Hello World!` 的 `Servlet` 如下

import java.io.*;
    import javax.servlet.*;
    import javax.servlet.http.*;
    
    // 扩展 HttpServlet 类
    public class HelloWorld extends HttpServlet { 
    
      public void init() throws ServletException { 
        // ...
      }
    
      public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
          response.setContentType("text/html");
          PrintWriter out = response.getWriter();
          out.println("<h1>Hello World!</h1>");
      }
      
      public void destroy() { 
          // ...
      }
    }

该自定义的 `Servlet` 重写了 `doGet` 方法，当客户端发起 GET 请求时将得到 `<h1>Hello World!</h1>`。

#### Mybatis BaseExecutor接口中的模板方法模式 ####

`Executor` 是 Mybatis 的核心接口之一，其中定义了数据库操作的基本方法，该接口的代码如下：

public interface Executor {
    
      ResultHandler NO_RESULT_HANDLER = null;
      // 执行 update、insert、delete 三种类型的SQL语句
      int update(MappedStatement ms, Object parameter) throws SQLException;
      // 执行selete类型的SQL语句，返回值分为结果对象列表或游标对象
      <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
      /
      <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
    
      <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException; 
      // 批量执行SQL语句
      List<BatchResult> flushStatements() throws SQLException;
      // 提交事务
      void commit(boolean required) throws SQLException;
      // 回滚事务
      void rollback(boolean required) throws SQLException;
      // 创建缓存中用到的CacheKey对象
      CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
      // 根据CacheKey对象查找缓存
      boolean isCached(MappedStatement ms, CacheKey key);
      // 清空一级缓存
      void clearLocalCache();
      // 延迟加载一级缓存中的数据
      void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);
      // 获取事务对象
      Transaction getTransaction();
      // 关闭Executor对象
      void close(boolean forceRollback);
      // 检测Executor是否已关闭
      boolean isClosed();
    
      void setExecutorWrapper(Executor executor);
    
    }

`Executor` 类的类图如下

![Executor与其子类的类图][Executor]

`BaseExecutor` 中主要提供了缓存管理和事务管理的基本功能，继承 `BaseExecutor` 的子类只需要实现四个基本方法来完成数据库的相关操作即可，这四个方法分别是：`doUpdate()` 方法、`doQuery()` 方法、`doQueryCursor()` 方法、`doFlushStatement()` 方法，其余功能都在 `BaseExecutor` 中实现。

`BaseExecutor`的部分代码如下，其中的 `query()` 方法首先会创建 `CacheKey` 对象，并根据 `CacheKey` 对象查找一级缓存，如果缓存命中则返回缓存中记录的结果对象，如果未命中则查询数据库得到结果集，之后将结果集映射成结果对象并保存到一级缓存中，同时返回结果对象。

public abstract class BaseExecutor implements Executor { 
      protected Transaction transaction;
      protected Executor wrapper;
    
      protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
      protected PerpetualCache localCache;
      protected PerpetualCache localOutputParameterCache;
      protected Configuration configuration;
    
      protected int queryStack = 0;
      private boolean closed;
      
      @Override
      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 #601
          deferredLoads.clear();
          if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { 
            // issue #482
            clearLocalCache();
          }
        }
        return list;
      }
      
      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` 的子类有四个分别是 `SimpleExecotor`、`ReuseExecutor`、`BatchExecutor`、`ClosedExecutor`，由于这里使用了模板方法模式，一级缓存等固定不变的操作都封装到了 `BaseExecutor` 中，因此子类就不必再关心一级缓存等操作，只需要专注实现4个基本方法的实现即可。

这里对这四个子类的功能做一个简要的介绍：

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

> 参考：  
> 刘伟：设计模式Java版  
> 慕课网java设计模式精讲 Debug 方式+内存分析  
> 徐郡明：Mybatis技术内幕 3.6 Executor

更多内容可访问我的个人博客：[http://laijianfeng.org][http_laijianfeng.org]

![关注【小旋锋】微信公众号][20180913_001328.png]

#### 推荐阅读 ####

[.]: http://image.laijianfeng.org/20181010_214705.jpg
[. 1]: http://image.laijianfeng.org/20181010_213837.png
[HttpServlet]: http://image.laijianfeng.org/20181010_214703.png
[Executor]: http://image.laijianfeng.org/20181010_214704.png
[http_laijianfeng.org]: http://laijianfeng.org
[20180913_001328.png]: http://image.laijianfeng.org/20180913_001328.png
[Link 1]: https://mp.weixin.qq.com/s?__biz=MzI1NDU0MTE1NA==&mid=2247483700&idx=1&sn=dd4d23f9400c8be248f5d125465ba941&chksm=e9c2ed39deb5642fb809eca1351f00995f06c9a4875f09986cc5005059eff74d6c20fc1118a3&scene=0#rd
[Link 2]: https://mp.weixin.qq.com/s?__biz=MzI1NDU0MTE1NA==&mid=2247483704&idx=1&sn=fa3ae947cebf22da35e6ac0a37f566f8&chksm=e9c2ed35deb564230a69e43d93a3b74618287c6ddd402a6f1dc6a5b14a896e99584985e7cf92&scene=0#rd
[Link 3]: https://mp.weixin.qq.com/s?__biz=MzI1NDU0MTE1NA==&mid=2247483708&idx=1&sn=9b8c155b86511ea6ec323dc6a72c52df&chksm=e9c2ed31deb56427b2a6bbcbad5bdd3a4ef68b52eb88cc47b5bcfc76773d3d983d8aaf57761c&scene=0#rd
[Link 4]: https://mp.weixin.qq.com/s?__biz=MzI1NDU0MTE1NA==&mid=2247483712&idx=1&sn=1ffd9837eb9413dde74ff509bf69ecc5&chksm=e9c2ed4ddeb5645b8cbf64c83d103a859ae49921c60e17fe8bebe63c26b04966be101d598848&scene=0#rd
[Link 5]: https://mp.weixin.qq.com/s?__biz=MzI1NDU0MTE1NA==&mid=2247483716&idx=1&sn=df00c297c8f32e10e277db8941839c14&chksm=e9c2ed49deb5645fa2586da358a8f0a00dd926f883637adebc59435f846c67c040ef759ba034&scene=0#rd
[Link 6]: https://mp.weixin.qq.com/s?__biz=MzI1NDU0MTE1NA==&mid=2247483721&idx=1&sn=721d0bce3bd516c10d4b6addbf3eced6&chksm=e9c2ed44deb56452395c94a0b150994b94aa26cae71149e6c030d0ac32f9c3c37e2bfe9685b6&scene=0#rd
[Link 7]: https://mp.weixin.qq.com/s?__biz=MzI1NDU0MTE1NA==&mid=2247483726&idx=1&sn=df583e5b297ddaff5e1ab822df762274&chksm=e9c2ed43deb56455d2a099f3c3e8622031027d6da00202e6a7d731eac691e4d87d673ca103b5&scene=0#rd
[Link 8]: https://mp.weixin.qq.com/s?__biz=MzI1NDU0MTE1NA==&mid=2247483730&idx=1&sn=859feab7f4632b7ba3d1b5a614d57bbe&chksm=e9c2ed5fdeb56449575995778573fa05a3730ac72792d70fc91e38e2d2f5238899f620481d16&scene=0#rd
[Link 9]: https://mp.weixin.qq.com/s?__biz=MzI1NDU0MTE1NA==&mid=2247483737&idx=1&sn=ed27a42a80b87ff74f1e1266d918ad5b&chksm=e9c2ed54deb56442aba5c95fbddd4c774eb39ebe7ab8c03471a62e3cf3979e303cef43417bac&scene=0#rd
[Link 10]: https://mp.weixin.qq.com/s?__biz=MzI1NDU0MTE1NA==&mid=2247483742&idx=1&sn=436670dc4793c6c9e7207ca6222e062c&chksm=e9c2ed53deb56445c7fb1aef89ab80b23bab96e6f9993618c98e1746209eec05f36b231cfaa8&scene=0#rd