模板方法模式

最新推荐文章于 2024-05-28 11:31:41 发布
最新推荐文章于 2024-05-28 11:31:41 发布
阅读量132 收藏
点赞数
分类专栏： 设计模式 java后端 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zengqingfa123/article/details/120518170
版权

1、概述

在面向对象程序设计过程中，程序员常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。

例如，去银行办理业务一般要经过以下4个流程：取号、排队、办理具体业务、对银行工作人员进行评分等，其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的，可以在父类中实现，但是办理具体业务却因人而异，它可能是存款、取款或者转账等，可以延迟到子类中实现。

2、定义

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

3、结构

模板方法（Template Method）模式包含以下主要角色：

3.1 抽象类（Abstract Class）

负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。

1）模板方法

定义了算法的骨架，按某种顺序调用其包含的基本方法。

2）基本方法

是实现算法各个步骤的方法，是模板方法的组成部分。
基本方法又可以分为三种：

a）抽象方法(Abstract Method)

一个抽象方法由抽象类声明、由其具体子类实现。

b）具体方法(Concrete Method)
一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承。

c）钩子方法(Hook Method)

在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。

一般钩子方法是用于判断的逻辑方法，这类方法名一般为isXxx，返回值类型为boolean类型。

3.2 具体子类（Concrete Class）

实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的组成步骤。

4、实现

4.1 普通模式

抽象类：com.zengqingfa.designpattern.template.common.AbstractTemplate

package com.zengqingfa.designpattern.template.common;

public abstract class AbstractTemplate {

    /**
     * 模板方法:final修饰，防止重写
     */
    public final void templateMethod() {
        //调用子类的方法
        abstractMethod();
        //父类实现的方法
        commonMethod();
    }

    /**
     * 抽象方法：由子类去实现
     */
    protected abstract void abstractMethod();

    /**
     * 基本方法(抽象类已经实现，子类拥有的共同代码)
     */
    private final void commonMethod() {
        //业务相关的代码
        System.out.println("模板类中的方法：AbstractTemplate#commonMethod");
    }
}

实现类：

public class ConcreteTemplate1 extends AbstractTemplate {

    @Override
    protected void abstractMethod() {
        System.out.println("子类ConcreteTemplate1实现了abstractMethod方法");
    }
}


public class ConcreteTemplate2 extends AbstractTemplate {

    @Override
    protected void abstractMethod() {
        System.out.println("子类ConcreteTemplate2实现了abstractMethod方法");
    }
}

测试：

public class Client {

    public static void main(String[] args) {
        AbstractTemplate template1 = new ConcreteTemplate1();
        template1.templateMethod();

        AbstractTemplate template2 = new ConcreteTemplate2();
        template2.templateMethod();

        //匿名内部类的形式
        AbstractTemplate template3 = new AbstractTemplate() {
            @Override
            protected void abstractMethod() {
                System.out.println("template3 abstractMethod");
            }
        };
        template3.templateMethod();
    }
}

结果：

子类ConcreteTemplate1实现了abstractMethod方法
模板类中的方法：AbstractTemplate#commonMethod
子类ConcreteTemplate2实现了abstractMethod方法
模板类中的方法：AbstractTemplate#commonMethod
template3 abstractMethod
模板类中的方法：AbstractTemplate#commonMethod

4.2 钩子模式

抽象类：com.zengqingfa.designpattern.template.hook.AbstractTemplate

package com.zengqingfa.designpattern.template.hook;

/**
 *
 * @fileName: AbstractTemplate
 * @author: zengqf3
 * @date: 2021-4-9 15:10
 * @description:
 */
public abstract class AbstractTemplate {

    /**
     * 模板方法:final修饰，防止重写
     */
    public final void templateMethod() {
        //调用子类的方法
        abstractMethod();
        if (hook()) {
            doHookMethod();
        }
        //父类实现的方法
        commonMethod();
    }

    /**
     * 抽象方法：由子类去实现
     */
    protected abstract void abstractMethod();

    /**
     * 基本方法(抽象类已经实现，子类拥有的共同代码)
     */
    private final void commonMethod() {
        //业务相关的代码
        System.out.println("模板类中的方法：AbstractTemplate#commonMethod");
    }

    /**
     * 钩子方法(空方法)：子类根据实际情况是否重写,
     * 默认钩子方法
     *一个钩子方法常常由抽象类给出一个空实现作为此方法的默认实现。这种空的钩子方法叫做“Do Nothing Hook”。
     *显然，这种默认钩子方法在缺省适配模式里面已经见过了，一个缺省适配模式讲的是一个类为一个接口提供一个默认的空实现，
     *从而使得缺省适配类的子类不必像实现接口那样必须给出所有方法的实现，因为通常一个具体类并不需要所有的方法。
     * 　　
     *  命名规则
     * 钩子方法的名字应当以do开始，这是熟悉设计模式的Java开发人员的标准做法。在上面的例子中，
     * 钩子方法hookMethod()应当以do开头；在HttpServlet类中，也遵从这一命名规则，如doGet()、doPost()等方法。
     */
    protected void doHookMethod() {

    }

    /**
     * 默认返回true
     * @return
     */
    protected boolean hook() {
        return false;
    }
}

实现类：

public class ConcreteTemplate1 extends AbstractTemplate {

    @Override
    protected void abstractMethod() {
        System.out.println("子类ConcreteTemplate1实现了abstractMethod方法");
    }

    /**
     * 钩子方法重写
     */
    @Override
    protected void doHookMethod() {
        System.out.println("执行ConcreteTemplate1的钩子方法doHookMethod");
    }

    @Override
    protected boolean hook() {
        return true;
    }
}

public class ConcreteTemplate2 extends AbstractTemplate {

    @Override
    protected void abstractMethod() {
        System.out.println("子类ConcreteTemplate2实现了abstractMethod方法");
    }
}

测试：

public class Client {

    public static void main(String[] args) {
        AbstractTemplate template1 = new ConcreteTemplate1();
        template1.templateMethod();
        System.out.println("====================");
        AbstractTemplate template2 = new ConcreteTemplate2();
        template2.templateMethod();
    }
}

结果：

子类ConcreteTemplate1实现了abstractMethod方法
执行ConcreteTemplate1的钩子方法doHookMethod
模板类中的方法：AbstractTemplate#commonMethod
====================
子类ConcreteTemplate2实现了abstractMethod方法
模板类中的方法：AbstractTemplate#commonMethod

4.3 回调模式

回调接口：

public interface ICallBack {

    void callBack();
}

模板类：

class Template {

    /**
     * 模板方法:final修饰，防止重写
     */
    public final void templateMethod(ICallBack callBack) {
        callBack.callBack();
        //父类实现的方法
        commonMethod();
    }

    /**
     * 基本方法(抽象类已经实现，子类拥有的共同代码)
     */
    private final void commonMethod() {
        //业务相关的代码
        System.out.println("模板类中的方法：AbstractTemplate#commonMethod");
    }
}

回调接口实现：

public class ConcreteCallBack1 implements ICallBack {

    @Override
    public void callBack() {
        System.out.println("子类ConcreteTemplate1实现了callBack方法");
    }
}


public class ConcreteCallBack2 implements ICallBack {

    @Override
    public void callBack() {
        System.out.println("子类ConcreteTemplate2实现了callBack方法");
    }
}

测试：

public class Client {

    public static void main(String[] args) {
		Template template = new Template();
        template.templateMethod(new ConcreteCallBack1());
        System.out.println("=====================");
        template.templateMethod(new ConcreteCallBack2());
        System.out.println("=====================");
        //匿名内部类
        template.templateMethod(new ICallBack() {
            @Override
            public void callBack() {
                System.out.println("匿名内部类实现了方法");
            }
        });
}

结果：

子类ConcreteTemplate1实现了callBack方法
模板类中的方法：AbstractTemplate#commonMethod
=====================
子类ConcreteTemplate2实现了callBack方法
模板类中的方法：AbstractTemplate#commonMethod
=====================
匿名内部类实现了方法
模板类中的方法：AbstractTemplate#commonMethod

5、模板方法模式总结

5.1 模板方法模式的主要优点

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

5.2 模板方法模式的主要缺点

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

5.3 适用场景

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

6、源码中的模板方法模式

6.1 Servlet 中的模板方法模式

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

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

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

public interface Executor {

  ResultHandler NO_RESULT_HANDLER = null;

  int update(MappedStatement ms, Object parameter) throws SQLException;

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

  List<BatchResult> flushStatements() throws SQLException;

  void commit(boolean required) throws SQLException;

  void rollback(boolean required) throws SQLException;

  CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);

  boolean isCached(MappedStatement ms, CacheKey key);

  void clearLocalCache();

  void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);

  Transaction getTransaction();

  void close(boolean forceRollback);

  boolean isClosed();

  void setExecutorWrapper(Executor executor);

}

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

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

public abstract class BaseExecutor implements Executor {
    
  // ....
      
  @Override
  public 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);
  }


  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
  }

  @SuppressWarnings("unchecked")
  @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;
  }

  @Override
  public <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    return doQueryCursor(ms, parameter, rowBounds, boundSql);
  }

  @Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // mimic DefaultParameterHandler logic
    for (ParameterMapping parameterMapping : parameterMappings) {
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) {
          value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
        cacheKey.update(value);
      }
    }
    if (configuration.getEnvironment() != null) {
      // issue #176
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }

  @Override
  public boolean isCached(MappedStatement ms, CacheKey key) {
    return localCache.getObject(key) != null;
  }

  @Override
  public void commit(boolean required) throws SQLException {
    if (closed) {
      throw new ExecutorException("Cannot commit, transaction is already closed");
    }
    clearLocalCache();
    flushStatements();
    if (required) {
      transaction.commit();
    }
  }

  @Override
  public void rollback(boolean required) throws SQLException {
    if (!closed) {
      try {
        clearLocalCache();
        flushStatements(true);
      } finally {
        if (required) {
          transaction.rollback();
        }
      }
    }
  }

  @Override
  public void clearLocalCache() {
    if (!closed) {
      localCache.clear();
      localOutputParameterCache.clear();
    }
  }

  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个基本方法的实现即可。

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

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

6.3 spring中的JdbcTemplate

Spring 提供了很多 Template 类，比如，JdbcTemplate、RedisTemplate、RestTemplate。尽管都叫作 xxxTemplate，但它们并非基于模板模式来实现的，而是基于回调来实现的，确切地说应该是同步回调。而同步回调从应用场景上很像模板模式，所以，在命名上，这些类使用 Template（模板）这个单词作为后缀。
正常情况下使用原生jdbc查询数据库：

package com.zengqingfa.designpattern.template;

import java.sql.*;

public class JdbcDemo {
    
    public User queryUser(long id) {
        Connection conn = null;
        Statement stmt = null;
        try {
            //1.加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/template", "root", "root");
            //2.创建statement类对象，用来执行SQL语句
            stmt = conn.createStatement();
            //3.ResultSet类，用来存放获取的结果集
            String sql = "select * from user where id=" + id;
            ResultSet resultSet = stmt.executeQuery(sql);
            String eid = null, ename = null, price = null;

            while (resultSet.next()) {
                User user = new User();
                user.setId(resultSet.getLong("id"));
                user.setName(resultSet.getString("name"));
                user.setTelephone(resultSet.getString("telephone"));
                return user;
            }
        } catch (ClassNotFoundException e) {
            // TODO: log...
        } catch (SQLException e) {
            // TODO: log...
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    // TODO: log...
                }
            }

            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    // TODO: log...
                }
            }
        }
        return null;
    }
}

queryUser() 函数包含很多流程性质的代码，跟业务无关，比如，加载驱动、创建数据库连接、创建 statement、关闭连接、关闭 statement、处理异常。针对不同的 SQL 执行请求，这些流程性质的代码是相同的、可以复用的

针对这个问题，Spring 提供了 JdbcTemplate，对 JDBC 进一步封装，来简化数据库编程。使用 JdbcTemplate 查询用户信息，我们只需要编写跟这个业务有关的代码，其中包括，查询用户的 SQL 语句、查询结果与 User 对象之间的映射关系。其他流程性质的代码都封装在了 JdbcTemplate 类中，不需要我们每次都重新编写。

package com.zengqingfa.designpattern.template;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;

public class JdbcTemplateDemo {
    
    private JdbcTemplate jdbcTemplate;

    public User queryUser(long id) {
        String sql = "select * from user where id=" + id;
        return jdbcTemplate.query(sql, new UserRowMapper()).get(0);
    }

    class UserRowMapper implements RowMapper<User> {
        @Override
        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
            User user = new User();
            user.setId(rs.getLong("id"));
            user.setName(rs.getString("name"));
            user.setTelephone(rs.getString("telephone"));
            return user;
        }
    }
}

JdbcTemplate 通过回调的机制，将不变的执行流程抽离出来，放到模板方法 execute() 中，将可变的部分设计成回调 StatementCallback，由用户来定制。query() 函数是对 execute() 函数的二次封装，让接口用起来更加方便。
org.springframework.jdbc.core.JdbcTemplate

	@Override
	public <T> List<T> query(String sql, RowMapper<T> rowMapper) throws DataAccessException {
		return result(query(sql, new RowMapperResultSetExtractor<>(rowMapper)));
	}

	@Override
	@Nullable
	public <T> T query(final String sql, final ResultSetExtractor<T> rse) throws DataAccessException {
		Assert.notNull(sql, "SQL must not be null");
		Assert.notNull(rse, "ResultSetExtractor must not be null");
		if (logger.isDebugEnabled()) {
			logger.debug("Executing SQL query [" + sql + "]");
		}

		/**
		 * Callback to execute the query.
		 */
		class QueryStatementCallback implements StatementCallback<T>, SqlProvider {
			@Override
			@Nullable
			public T doInStatement(Statement stmt) throws SQLException {
				ResultSet rs = null;
				try {
					rs = stmt.executeQuery(sql);
					return rse.extractData(rs);
				}
				finally {
					JdbcUtils.closeResultSet(rs);
				}
			}
			@Override
			public String getSql() {
				return sql;
			}
		}

		return execute(new QueryStatementCallback());
	}

	@Override
	@Nullable
	public <T> T execute(StatementCallback<T> action) throws DataAccessException {
		Assert.notNull(action, "Callback object must not be null");

		Connection con = DataSourceUtils.getConnection(obtainDataSource());
		Statement stmt = null;
		try {
			stmt = con.createStatement();
			applyStatementSettings(stmt);
			T result = action.doInStatement(stmt);
			handleWarnings(stmt);
			return result;
		}
		catch (SQLException ex) {
			// Release Connection early, to avoid potential connection pool deadlock
			// in the case when the exception translator hasn't been initialized yet.
			String sql = getSql(action);
			JdbcUtils.closeStatement(stmt);
			stmt = null;
			DataSourceUtils.releaseConnection(con, getDataSource());
			con = null;
			throw translateException("StatementCallback", sql, ex);
		}
		finally {
			JdbcUtils.closeStatement(stmt);
			DataSourceUtils.releaseConnection(con, getDataSource());
		}
	}

	@Override
	@Nullable
	public <T> T execute(StatementCallback<T> action) throws DataAccessException {
		Assert.notNull(action, "Callback object must not be null");

		Connection con = DataSourceUtils.getConnection(obtainDataSource());
		Statement stmt = null;
		try {
			stmt = con.createStatement();
			applyStatementSettings(stmt);
			T result = action.doInStatement(stmt);
			handleWarnings(stmt);
			return result;
		}
		catch (SQLException ex) {
			// Release Connection early, to avoid potential connection pool deadlock
			// in the case when the exception translator hasn't been initialized yet.
			String sql = getSql(action);
			JdbcUtils.closeStatement(stmt);
			stmt = null;
			DataSourceUtils.releaseConnection(con, getDataSource());
			con = null;
			throw translateException("StatementCallback", sql, ex);
		}
		finally {
			JdbcUtils.closeStatement(stmt);
			DataSourceUtils.releaseConnection(con, getDataSource());
		}
	}

lback object must not be null");

	Connection con = DataSourceUtils.getConnection(obtainDataSource());
	Statement stmt = null;
	try {
		stmt = con.createStatement();
		applyStatementSettings(stmt);
		T result = action.doInStatement(stmt);
		handleWarnings(stmt);
		return result;
	}
	catch (SQLException ex) {
		// Release Connection early, to avoid potential connection pool deadlock
		// in the case when the exception translator hasn't been initialized yet.
		String sql = getSql(action);
		JdbcUtils.closeStatement(stmt);
		stmt = null;
		DataSourceUtils.releaseConnection(con, getDataSource());
		con = null;
		throw translateException("StatementCallback", sql, ex);
	}
	finally {
		JdbcUtils.closeStatement(stmt);
		DataSourceUtils.releaseConnection(con, getDataSource());
	}
}
神龙飞仙
关注
专栏目录
设计模式之模板方法模式
wang0907的博客
02-14 7851
java程序的设计原则 6大原则： 单一职责：一个类和方法只做一件事。 开闭原则：对修改关闭，对扩展开发。 里氏替换原则：子类可扩展新方法，但不可修改父类已有方法（父类已提供了具体实现的方法）。 依赖倒置：依赖于抽象，而非具体实现，即面向接口编程（如方法参数，类属性使用接口声明，这样可接收任何子类）。 接口隔离：使用多个隔离的接口定义抽象，降低耦合。 最少知道/迪米特原则：降低类之间的依赖，聚合，组合等。 1：模板方法设计模式 模板方法设计模式是行为型设计模式中的一种，用在一个功能的完成需要经过一系列步骤
java设计模式(五)
jasnet_u的博客
12-11 389
设计模式中的行为型模式共11种 分别为： 策略、模板方法、观察者、责任链、 迭代子、备忘录、状态、命令、解释器、访问者、调停者 本篇介绍其前4种  策略、模板方法、观察者、责任链。 Strategy 策略模式 1 策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有公共接口的独立类中，使得它们可以相互替换。策略模式可以在不影响客户端的情况下独立     地发
Java-23个设计模式 Template Method
weixin_42321815的博客
03-22 131
Template Method ① 模板方法：在抽象类中定义一个稳定的算法骨架（如一个方法中有固定业务逻辑） public abstract class AbstractTemplate { // 稳定的骨架 public void getChampion(){ // 固定逻辑 dohookMethod(); System.o...
设计模式：模板方法
qq_29860591的博客
01-25 231
模板方法模式 概述 在面向对象程序设计过程中，程序员常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。 例如，去银行办理业务一般要经过以下4个流程：取号、排队、办理具体业务、对银行工作人员进行评分等，其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的，可以在父类中实现，但...
Spring里的模板方法设计模式，JdbcTemplate、RedisTemplate、RestTemplate源码分析
zhangweiocp的专栏
04-07 2621
前言：设计模式是阅读源码的一项极其重要的内功心法，而其中模板方法设计模式的套路在JDK、Spring、Mybatis、Maven中被广泛使用，如：Spring中的各种Template，有JdbcTemplate、RedisTemplate、RestTemplate皆是这种老把戏，假如您对该内功心法了如指掌，那么阅读它们的源码简直快地飞起，甚至能依葫芦画瓢，设计出HttpTemplate、FtpTemplate根本不在话下。 模板方法设计模式简介：在一个方法里定义了做事的流程，该流程中的某些步骤的实现逻辑是
设计模式(行为型)之模板方法模式(Template Method Pattern)
工匠若水
05-05 4844
模板方法模式是一种基于继承的代码复用，它是一种类行为型模式；是结构最简单的行为型设计模式，在其结构中只存在父类与子类之间的继承关系。通过使用模板方法模式，可以将一些复杂流程的实现步骤封装在一系列基本方法中，在抽象父类中提供一个称之为模板方法的方法来定义这些基本方法的执行次序，而通过其子类来覆盖某些步骤，从而使得相同的算法框架可以有不同的执行结果。模板方法模式提供了一个模板方法来定义算法框架，而某些具体步骤的实现可以在
C++模板方法模式
最新发布
qqrrjj2011的博客
05-28 1134
C++模板方法模式
模板方法模式--钩子方法
2301_79963818的博客
04-22 1107
分享一些系统的面试题，大家可以拿去刷一刷，准备面试涨薪。
抽象类、模板方法模式
daqi1983的博客
03-01 1352
在Java中abstract是抽象的意思，如果一个类中的某个方法的具体实现不能确定，就可以申明成abstract修饰的抽象方法（不能写方法体了），这个类必须用abstract修饰，被称为抽象类。
模板方法模式深度解析
03-04
在现实生活中，很多事情都包含几个实现步骤，例如请客吃饭，无论吃什么，一般都...为了提高代码的复用性和系统的灵活性，可以使用一种称之为模板方法模式的设计模式来对这类情况进行设计，在模板方法模式中，将实现功能
设计模式（十一）之模板方法模式.zip
02-17
模板方法模式是面向对象设计中的一种行为设计模式，它在软件工程中扮演着重要的角色，尤其是在需要维护代码的可扩展性和可复用性时。这个模式的核心思想是封装不变的部分，将可变部分抽象出来，让子类进行扩展。通过...
Python设计模式之模板方法模式实例详解
12-24
本文实例讲述了Python设计模式之模板方法模式。分享给大家供大家参考，具体如下： 模板方法模式(Template Method Pattern):定义一个操作中的算法骨架，将一些步骤延迟至子类中.模板方法使得子类可以不改变一个算法的...
springboot项目-多线程查询示例
zengqingfa123的博客
09-09 5926
对于多线程，使用到项目的场景并不是多，但是多线程查询算是一个。 以多线程查询人员列表为例： pom.xml文件：maven依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3...
mybatis-plus学习
zengqingfa123的博客
02-18 437
mybatis-plus 一、简介 官网：https://mp.baomidou.com/ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-155EWNFK-1613658092306)(…/image/image-20200719110124543.png)] MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 特性 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝
eureka注册中心
zengqingfa123的博客
02-18 126
eureka 注册中心 解决问题： 服务之间的调用关系：维护服务的地址，如果有集群，服务如何维护？ 一、简介 Spring Cloud Eureka，使用Netflix Eureka 来实现服务的注册与发现， 他既包含了服务端组件，也包含了客户端组件，并且服务端与客户端均采用Java编写，所以Eureka主要适用于通过Java编写的分布式系统，或是与JVM兼容语言构建的系统。 ​ Eureka服务端，我们也称为服务注册中心，它同其他服务注册中心一样，支持高可用配置。它依托于强一致性提供良好的服务实例可
SSH整合
zengqingfa123的博客
07-24 95
SSH项目整合 一、maven工程 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:sch...
深入理解C++模板方法模式
资源摘要信息:"设计模式C++学习之模板方法模式（Template Method）" 设计模式是软件工程中的一套被广泛认可的最佳实践，它能够帮助开发者编写可复用、可维护、灵活且清晰的代码。在众多设计模式中，模板方法模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值