设计模式-模板

一、模板模式的应用场景

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

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

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

三、总结

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