模板模式

定义

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

适用场景：

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

案例

NetworkCourse 抽象类：

public abstract class NetworkCourse {

    public 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 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 类：

public class JavaCourse extends NetworkCourse {
    void checkHomework() {
        System.out.println("检查 Java 的架构课件");
    }
}

创建 BigDataCourse 类：

public class BigDataCourse extends NetworkCourse {

    private boolean needHomeworkFlag=false;

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

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

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

客户端测试代码：

public class Test {
    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();
    }
}

利用模板模式重构 JDBC 操作业务场景

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

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

public interface RowMapper<T> {

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

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

public abstract class JdbcTemplate {
    private DataSource dataSource;

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

    public List<?> executeQuery(String sql, RowMapper<?> rowMapper, Object[] values) {
        //1、获取连接
        try {
            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 {
        //数据库连接池，我们不是关闭
        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<Object>();
        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 类：

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：

public class MemberDao extends JdbcTemplate {

    private MemberDao(DataSource dataSource) {
        super(dataSource);
    }

    public List<?> selectAll() {
        String sql = "select * from t_member";
        return super.executeQuery(sql, new RowMapper<Member>() {
            public Member 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);
    }
}

模板模式在源码中的体现

先来看 JDK 中的 AbstractList，来看代码：

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
...
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 var1, Object var2) throws SQLException;

    protected abstract List<BatchResult> doFlushStatements(boolean var1) throws SQLException;

    protected abstract <E> List<E> doQuery(MappedStatement var1, Object var2, RowBounds var3, ResultHandler var4, BoundSql var5) throws SQLException;

    protected abstract <E> Cursor<E> doQueryCursor(MappedStatement var1, Object var2, RowBounds var3, BoundSql var4) throws SQLException;
...

模板模式的优缺点

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

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