Spring源码学习笔记：经典设计模式之模板模式

1、博客内容均出自于咕泡学院架构师第三期
2、架构师系列内容：架构师学习笔记（持续更新）

0、模板模式 || 模板方法模式（Template Method Pattern）

指定义一个算法的骨架，并且允许子类为一个或者多个步骤提供实现方法。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法的某些步骤。属于行为型设计模式。

适用场景：

1. 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。
2. 各子类中公共的行为被提取出来并集中到一个公共的父类中，从而避免代码重复。

体现：
入职流程：填写入职登记表–>打印简历–>复印学历–>复印身份证–>签订劳动合同–>建立花名册–>办理工牌–>安排工位等。
炒菜流程：洗锅–>点火–>热锅–>上油–>下原料–>翻炒–>放调料–>出锅等。
网课流程： 发布预习资料–>制作课件 PPT–>在线直播–> 提 交 课 堂 笔 记 --> 提 交 源 码 --> 布 置 作 业 --> 检 查 作 业等。

优缺点：
优点：

1. 利用模板方法将相同处理逻辑的代码放到抽象父类中，可以提高代码的复用性。
2. 将不同的代码不同的子类中，通过对子类的扩展增加新的行为，提高代码的扩展性。
3. 把不变的行为写在父类上，去除子类的重复代码，提供了一个很好的代码复用平台，符合开闭原则。

缺点：

1. 类数目的增加，每一个抽象类都需要一个子类来实现，这样导致类的个数增加。
2. 类数量的增加，间接地增加了系统实现的复杂度。
3. 继承关系自身缺点，如果父类添加新的抽象方法，所有子类都要改一遍。

1、简单例子

以网课流程： 发布预习资料–>制作课件 PPT–>在线直播–> 提 交 课 堂 笔 记 --> 提 交 源 码 --> 布 置 作 业 --> 检 查 作 业为例子，用代码实现这个流程

首先创建NetworkCourse抽象类：
此类定义了网课的流程，实现了公共方法。设计了是否需要检查作业的钩子方法已经默认实现为和布置作业的抽象方法

package com.jarvisy.demo.pattern.template.course;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/19 21:57
* @description ：模板会有一个或者多个未现实方法，而且这几个未实现方法有固定的执行循序
*/
public abstract class NetworkCourse {


    protected final void createCourse() {
        //1、发布预习资料
        this.postPreResource();


        //2、制作PPT课件
        this.createPPT();


        //3、在线直播
        this.liveVideo();


        //4、提交课件、课堂笔记
        this.postNote();


        //5、提交源码
        this.postSource();


        //6、布置作业，有些课是没有作业，有些课是有作业的
        //如果有作业的话，检查作业，如果没作业，完成了
        if (needHomework()) {
            checkHomework();
        }




    }


    abstract void checkHomework();


    //钩子方法：实现流程的微调
    protected boolean needHomework() {
        return false;
    }


    //加上final 是不想子类去实现改变它的逻辑 ，如果需要子类改变它的逻辑也可以不加
    final void postSource() {
        System.out.println("提交源代码");
    }


    final void postNote() {
        System.out.println("提交课件和笔记");
    }


    final void liveVideo() {
        System.out.println("直播授课");
    }


    final void createPPT() {
        System.out.println("创建备课PPT");
    }


    final void postPreResource() {
        System.out.println("分发预习资料");
    }


}

钩子方法主要目的是用来干预 执行流程，使得我们控制行为流程更加灵活，更符合实际业务的需求。 钩子方法的返回值一般为适合条件分支语句的返回值（如 boolean、int 等）。

然后创建课程类JavaCourse，BigDataCourse：

package com.jarvisy.demo.pattern.template.course;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/19 22:02
* @description ：
*/
public class JavaCourse extends NetworkCourse {
    @Override
    void checkHomework() {
        System.out.println("检查Java的架构课件");
    }
}

package com.jarvisy.demo.pattern.template.course;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/19 22:02
* @description ：
*/
public class BigDataCourse extends NetworkCourse {


    private boolean needHomeworkFlag = false;


    public BigDataCourse(boolean needHomeworkFlag) {
        this.needHomeworkFlag = needHomeworkFlag;
    }


    @Override
    void checkHomework() {
        System.out.println("检查大数据的课后作业");
    }


    @Override
    protected boolean needHomework() {
        return needHomeworkFlag;
    }
}

BigDataCourse 我们定义一个私有的needHomeworkFlag属性，通过构造方法传入给这个属性进行赋值，然后重写needHomework方法，返回needHomeworkFlag属性，达到控制是否需要检查作业的这一操作。

创建测试类：

package com.jarvisy.demo.pattern.template.course;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/19 22:05
* @description ：
*/
public class NetworkCourseTest {
    public static void main(String[] args) {
        System.out.println("---Java架构师课程---");
        NetworkCourse javaCourse = new JavaCourse();
        javaCourse.createCourse();


        System.out.println("---大数据课程---");
        NetworkCourse bigDataCourse = new BigDataCourse(true);
        bigDataCourse.createCourse();
    }
}

2、利用模板模式简单实现JDBC操作业务场景。

创建一个模板类 JdbcTemplate，封装所有的 JDBC 操作。
以查询为例，每次查询的表不同，返回的数据结构也就不一样。我们针对不同的数据，都要封装成不同的实体对象。而每个实体封装的逻辑都是不一样的，但封装前和封装后的处理流程是不变的，因此，我们可以使用模板方法模式来设计这样的业务场景。

首先创建约束 ORM 逻辑的接口RowMapper：

package com.jarvisy.demo.pattern.template.jdbc;


import java.sql.ResultSet;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/19 22:29
* @description ：ORM映射定制化的接口
*/
public interface RowMapper<T> {


    T mapRow(ResultSet rs, int rowNum) throws Exception;
}

创建封装了所有处理流程的抽象类JdbcTemplate：

package com.jarvisy.demo.pattern.template.jdbc;


import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/19 22:31
* @description ：
*/
public abstract class JdbcTemplate {
    private DataSource dataSource;


    public JdbcTemplate(DataSource dataSource) {
        this.dataSource = dataSource;
    }


    public List<?> executeQuery(String sql, RowMapper<?> rowMapper, Object[] values) {
        try {
            //1、获取连接
            Connection conn = this.getConnection();


            //2、创建语句集
            PreparedStatement pstm = this.createPrepareStatement(conn, sql);


            //3、执行语句集
            ResultSet rs = this.executeQuery(pstm, values);


            //4、处理结果集
            List<?> result = this.paresResultSet(rs, rowMapper);


            //5、关闭结果集
            this.closeResultSet(rs);


            //6、关闭语句集
            this.closeStatement(pstm);


            //7、关闭连接
            this.closeConnection(conn);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    protected void closeConnection(Connection conn) throws Exception {
        // 如果是数据库连接池，则这里就不是close了,可以重新这个方法 这里默认实现关闭
        conn.close();
    }


    protected void closeStatement(PreparedStatement pstm) throws Exception {
        pstm.close();
    }


    protected void closeResultSet(ResultSet rs) throws Exception {
        rs.close();
    }


    protected List<?> paresResultSet(ResultSet rs, RowMapper<?> rowMapper) throws Exception {
        List<Object> result = new ArrayList<>();
        int rowNum = 1;
        while (rs.next()){
            result.add(rowMapper.mapRow(rs,rowNum++));
        }
        return result;
    }


    protected ResultSet executeQuery(PreparedStatement pstm, Object[] values) throws Exception {
        for (int i = 0; i < values.length; i++) {
            pstm.setObject(i,values[i]);
        }
        return pstm.executeQuery();


    }


    protected PreparedStatement createPrepareStatement(Connection conn, String sql) throws Exception {
        return conn.prepareStatement(sql);
    }


    public Connection getConnection() throws Exception {
        return this.dataSource.getConnection();


    }
}

创建实体对象Member类：

package com.jarvisy.demo.pattern.template.jdbc;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/19 22:58
* @description ：
*/
public class Member {


    private String username;
    private String password;
    private String nickname;
    private int age;
    private String addr;


    public String getUsername() {
        return username;
    }


    public void setUsername(String username) {
        this.username = username;
    }


    public String getPassword() {
        return password;
    }


    public void setPassword(String password) {
        this.password = password;
    }


    public String getNickname() {
        return nickname;
    }


    public void setNickname(String nickname) {
        this.nickname = nickname;
    }


    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }


    public String getAddr() {
        return addr;
    }


    public void setAddr(String addr) {
        this.addr = addr;
    }
}

创建数据库操作类MemberDao:

package com.jarvisy.demo.pattern.template.jdbc.dao;


import com.jarvisy.demo.pattern.template.jdbc.JdbcTemplate;
import com.jarvisy.demo.pattern.template.jdbc.Member;
import com.jarvisy.demo.pattern.template.jdbc.RowMapper;


import javax.sql.DataSource;
import java.sql.ResultSet;
import java.util.List;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/19 23:00
* @description ：
*/
public class MemberDao extends JdbcTemplate {


    public MemberDao(DataSource dataSource) {
        super(dataSource);
    }
    public List<?> selectAll() {
        String sql = "select * from t_member";
        return super.executeQuery(sql, new RowMapper<Object>() {
            @Override
            public Object mapRow(ResultSet rs, int rowNum) throws Exception {
                Member member = new Member();
                //字段过多，原型模式
                member.setUsername(rs.getString("username"));
                member.setPassword(rs.getString("password"));
                member.setAge(rs.getInt("age"));
                member.setAddr(rs.getString("addr"));
                return member;
            }
        }, null);
    }
}

测试代码：

package com.jarvisy.demo.pattern.template.jdbc;


import com.jarvisy.demo.pattern.template.jdbc.dao.MemberDao;


import java.util.List;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/19 23:45
* @description ：
*/
public class MemberDaoTest {


    public static void main(String[] args) {
        MemberDao memberDao = new MemberDao(null);
        List<?> result = memberDao.selectAll();
        System.out.println(result);
    }
}

3、模板模式在源码中的体现

先看JDK中的AbstractList

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    
    /**
     * {@inheritDoc}
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    abstract public E get(int index);
}

里面有一个get方法 ，是一个抽象方法，那么它的逻辑就是交给子类来实现，我们大家所熟知的ArrayList 就 是 AbstractList 的 子 类 。 同理，有 AbstractList 就 有 AbstractSet 和AbstractMap。

还有一个每天都在用的HttpServlet，有三个方法 service()和 doGet()、doPost()方法，都是模板方法的抽象实现。

在 MyBatis 框架也有一些经典的应用，我们来一下 BaseExecutor 类，它是一个基础的SQL 执行类，实现了大部分的 SQL 执行逻辑，然后把几个方法交给子类定制化完成，源码如下

public abstract class BaseExecutor implements Executor {    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;
}

如doUpdate、doFlushStatements、doQuery、doQueryCursor 这几个方法就是交由子类来实现，那么 BaseExecutor 有哪些子类呢？我们来看一下它的类图：

看一下 SimpleExecutor 的 doUpdate 实现:

public class SimpleExecutor extends BaseExecutor {


  public SimpleExecutor(Configuration configuration, Transaction transaction) {
    super(configuration, transaction);
  }


  @Override
  public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.update(stmt);
    } finally {
      closeStatement(stmt);
    }
  }
}

对比一下BatchExecutor 的doUpate实现：

public class BatchExecutor extends BaseExecutor {

  @Override
  public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {
    final Configuration configuration = ms.getConfiguration();
    final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);
    final BoundSql boundSql = handler.getBoundSql();
    final String sql = boundSql.getSql();
    final Statement stmt;
    if (sql.equals(currentSql) && ms.equals(currentStatement)) {
      int last = statementList.size() - 1;
      stmt = statementList.get(last);
      applyTransactionTimeout(stmt);
     handler.parameterize(stmt);//fix Issues 322
      BatchResult batchResult = batchResultList.get(last);
      batchResult.addParameterObject(parameterObject);
    } else {
      Connection connection = getConnection(ms.getStatementLog());
      stmt = handler.prepare(connection, transaction.getTimeout());
      handler.parameterize(stmt);    //fix Issues 322
      currentSql = sql;
      currentStatement = ms;
      statementList.add(stmt);
      batchResultList.add(new BatchResult(ms, sql, parameterObject));
    }
  // handler.parameterize(stmt);
    handler.batch(stmt);
    return BATCH_UPDATE_RETURN_VALUE;
  }
}

很明显这两个方法存在差异，不同的实现逻辑。