设计模式-模板

一、模板模式的应用场景

我们平时办理入职流程填写入职登记表-->打印简历-->复印学历-->复印身份证-->签订劳动合同-->建立花名册-->办理工牌-->安排工位等；再比如，我平时在家里炒菜：洗锅-->点火-->热锅-->上油-->下原料-->翻炒-->放调料-->出锅；再比如赵本山问宋丹丹: “如何把大象放进冰箱？”宋丹丹回答：“第一步：打开冰箱门，第二步：把大象塞进冰箱，第三步：关闭冰箱门”。赵本山再问：“怎么把长劲鹿放进冰箱？”宋丹丹答：

“第一步：打开冰箱门，第二步：把大象拿出来，第三步：把长劲鹿塞进去，第四步：关闭冰箱门”（如下图所示），这些都是模板模式的体现。

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

1. 一次性实现一个算法不变的部分，并将可变的部分留给子类进行实现。

2. 各子类中公共的行为被提取出来并集中到一个公共的父类中，从而避免代码重复。

我们以一个网络直播课程创建流程为例：发布预习资料-->制作课件PPT-->在线直播-->提交课堂笔记-->布置作业-->检查作业。

首先我们来创建一个NetWorkCourse类：

/**
* 模板会有一个或者多个未现实方法，
* 而且这几个未实现方法有固定的执行循序
*/
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 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("分发预习资料");
  }
}

接下来创建javaCourse类：

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

创建BigDataSource类：

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 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();}}

　　

通过这个案例，相信大家对模板模式已经有了一个初步的印象，那么我们再来看一个非常常用的例子。利用模板模式重构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){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 {//数据库连接池，我们不是关闭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 {public 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);}}
测试代码：

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

　　

二、模板模式的优缺点

优点：

1、利用模板方法将相同处理逻辑的代码放到抽象父类中，可以提高代码的复用性。

2、将不同的代码不同的子类中，通过对子类的扩展增加新的行为，提高代码的扩展性。

3、把不变的行为写在父类上，去除子类的重复代码，提供了一个很好的代码复用平台，

符合开闭原则。

缺点：

1、类数目的增加，每一个抽象类都需要一个子类来实现，这样导致类的个数增加。

2、类数量的增加，间接地增加了系统实现的复杂度。

3、继承关系自身缺点，如果父类添加新的抽象方法，所有子类都要改一遍。

三、总结

模板模式比较简单，也比较容易理解，就是对于一些长期不变的流程，我们可以将公共的部分提取出来放在父类中，需要变化的一些流程留给子类去继承重写，提高代码复用性。