模板模式通常又叫模板方法模式（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(); } }创建一个模板类 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、继承关系自身缺点，如果父类添加新的抽象方法，所有子类都要改一遍。
