1. 适用场景

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

模板模式可以帮助我们规范执行流程和执行逻辑，下面演示一个小demo

课程模板类：NetworkSource

  1. public abstract class NetworkCourse {
  3.     protected final void createCourse(){
  4.         //1. 发布预习资料
  5.         this.postPreResource();
  7.         //2. 制作ppt课件
  8.         this.createPPT();
  10.         //3. 在线直播
  11.         this.liveVideo();
  13.         //4. 提交课件 提交笔记
  14.         this.postNote();
  16.         //5. 提交源码
  17.         this.postSource();
  19.         //6. 布置作业 有些课没有作业 有些课有作业
  20.         //如果有作业的话需要检查作业 如果没有作业 完成了
  21.         if (needHomework()){
  22.             checkHomework();
  23.         }
  25.     }
  27.     abstract void checkHomework();
  29.     //钩子方法 流程微调
  30.     protected boolean needHomework(){ return false; }
  32.     final void postSource(){
  33.         System.out.println("提交源代码！");
  34.     }
  36.     final void postNote(){
  37.         System.out.println("提交课件和笔记");
  38.     }
  40.     final void liveVideo(){
  41.         System.out.println("在线授课！");
  42.     }
  44.     final void createPPT(){
  45.         System.out.println("创建备课PPT");
  46.     }
  48.     final void postPreResource(){
  49.         System.out.println("发布预习资料");
  50.     }
  51. }

课程模板类是一个抽象类，为什么要用抽象类，主要是为了定义一些固定的流程，还有一些方法写成抽象方法可以作为个性化需求的使用，可以润色，可以自由编写，但是核心的模块是不能动的，这也是为什么不使用接口的原因！可以看到这里面流程化的步骤一共分为六大步，前五步都是固定的final不可变，只有第六步布置作业可以叫它钩子函数，可以选择！

java课程：JavaCourse

  1. public class JavaCourse extends NetworkCourse{
  3.     @Override
  4.     void checkHomework() {
  5.         System.out.println("检查java的架构课件");
  6.     }
  8. }

java课程类这里写的是没有布置作业，默认返回的needHomework为false

大数据课程类：BigDataSource

  1. public class BigDataSource extends NetworkCourse{
  3.     private boolean needHomeworkFlag = false;
  5.     public BigDataSource(boolean needHomeworkFlag) {
  6.         this.needHomeworkFlag = needHomeworkFlag;
  7.     }
  9.     @Override
  10.     void checkHomework() {
  11.         System.out.println("检查大数据的课后作业！");
  12.     }
  14.     @Override
  15.     protected boolean needHomework() {
  16.         return this.needHomeworkFlag;
  17.     }
  18. }

大数据课程类做了一些更改，布置了作业需要检查，所以这里重写了needHomework方法，我们后面可以传入true

NetworkSourceTest课程验证

  1. public class NetworkCourseTest {
  2.     public static void main(String[] args) {
  3.         System.out.println("----java架构师课程----");
  4.         NetworkCourse javaCourse = new JavaCourse();
  5.         javaCourse.createCourse();
  7.         System.out.println("----大数据架构师课程----");
  8.         NetworkCourse bigDataSource = new BigDataSource(true);
  9.         bigDataSource.createCourse();
  10.     }
  11. }

可以看到在大数据传值的时候，传入了是否需要布置作业为true！
运行结果：

  1. ----java架构师课程----
  2. 发布预习资料
  3. 创建备课PPT
  4. 在线授课！
  5. 提交课件和笔记
  6. 提交源代码！
  7. ----大数据架构师课程----
  8. 发布预习资料
  9. 创建备课PPT
  10. 在线授课！
  11. 提交课件和笔记
  12. 提交源代码！
  13. 检查大数据的课后作业！

这样流程化的东西并没有被改变，针对于不同的课程做一些微调，实现了模板的效果，想想如果换成接口的话，所有的流程全部重写，那么也就不是模板了！另外提醒一下钩子方法：提供对流程的微调

2. JDBC模板

jdbc我们已经很熟悉了，其实底层使用了模板模式进行sql语句的增删改查，只不过对部分入参进行了过滤！
下面我们尝试着编写模拟的jdbc模板，从数据库连接到存入数据库，它主要分为几个步骤：

  1. 获取数据库连接
  2. 编写sql
  3. 执行sql语句
  4. 处理结果集
  5. 关闭结果集
  6. 关闭语句集
  7. 关闭连接

JdbcTemplate模板

  1. public abstract class JdbcTemplate {
  3.     private DataSource dataSource;
  5.     public JdbcTemplate(DataSource dataSource){
  6.         this.dataSource = dataSource;
  7.     }
  9.     public List<?> execteQuery(String sql,RowMapper<?> rowMapper,Object[] values){
  10.         try {
  11.             //1.获取链接
  12.             Connection conn = this.getConnection();
  13.             //2.创建语句集
  14.             PreparedStatement pm = this.createPrepareStatement(conn,sql);
  15.             //3.执行语句
  16.             ResultSet rs = this.execteQuery(pm,values);
  17.             //4.处理结果集
  18.             List<?> result = this.pareseResultSet(rs,rowMapper);
  19.             //5.关闭结果集
  20.             this.closeResultSet(rs);
  21.             //6.关闭语句集
  22.             this.closeStatement(pm);
  23.             //7.关闭链接
  24.             this.closeConnection(conn);
  25.             return result;
  27.         } catch (Exception e) {
  28.             e.printStackTrace();
  29.         }
  31.         return null;
  32.     }
  34.     protected void closeConnection(Connection conn) throws SQLException {
  35.         //数据库连接池 不关闭
  36.         conn.close();
  37.     };
  39.     protected void closeStatement(PreparedStatement pm) throws SQLException {
  40.         pm.close();;
  41.     };
  43.     protected void closeResultSet(ResultSet rs) throws SQLException {
  44.         rs.close();
  45.     };
  47.     protected  List<?> pareseResultSet(ResultSet rs, RowMapper<?> rowMapper) throws Exception {
  48.         //迭代
  49.         List<Object> result = new ArrayList<>();
  50.         int rowNum = 1;
  52.         while (rs.next()){
  53.             result.add(rowMapper.mapRow(rs,rowNum++));
  54.         }
  55.         return result;
  56.     };
  58.     private ResultSet execteQuery(PreparedStatement pm, Object[] values) throws SQLException {
  59.         for (int i=0;i< values.length;i++){
  60.             pm.setObject(i,values);
  61.         }
  62.         return pm.executeQuery();
  63.     }
  65.     protected PreparedStatement createPrepareStatement(Connection conn, String sql) throws SQLException {
  66.         return conn.prepareStatement(sql);
  67.     }
  69.     public Connection getConnection() throws SQLException {
  70.         return this.dataSource.getConnection();
  71.     };
  72. }

jdbc模板中核心方法为execteQuery，里面包含了几个核心步骤！几个参数需要注意一下
sql：核心执行sql
rowMapper：这个用于对象封装传入的参数，这个对象会从rs中取出，完成rowMapper封装
values：默认为null，可传入参数

RowMapper<T> _orm映射定制化的接口_

  1. public interface RowMapper<T> {
  2.     T mapRow(ResultSet rs,int rowNum) throws Exception;
  4. }

定制化映射的接口，很明显是对结果集进行一对一的映射，方便后续的对象一对一复制转化！

Member属性类

  1. public class Member {
  2.     private String username;
  3.     private String password;
  4.     private String nickName;
  5.     private int age;
  6.     private String addr;
  8.     public String getUsername() {
  9.         return username;
  10.     }
  12.     public void setUsername(String username) {
  13.         this.username = username;
  14.     }
  16.     public String getPassword() {
  17.         return password;
  18.     }
  20.     public void setPassword(String password) {
  21.         this.password = password;
  22.     }
  24.     public String getNickName() {
  25.         return nickName;
  26.     }
  28.     public void setNickName(String nickName) {
  29.         this.nickName = nickName;
  30.     }
  32.     public int getAge() {
  33.         return age;
  34.     }
  36.     public void setAge(int age) {
  37.         this.age = age;
  38.     }
  40.     public String getAddr() {
  41.         return addr;
  42.     }
  44.     public void setAddr(String addr) {
  45.         this.addr = addr;
  46.     }
  48.     @Override
  49.     public String toString() {
  50.         return "Member{" +
  51.                 "username='" + username + '\'' +
  52.                 ", password='" + password + '\'' +
  53.                 ", nickName='" + nickName + '\'' +
  54.                 ", age=" + age +
  55.                 ", addr='" + addr + '\'' +
  56.                 '}';
  57.     }
  58. }

Member不用多说，测试用例的属性类

dao层的MemberDao

  1. public class MemberDao extends JdbcTemplate {
  3.     public MemberDao(DataSource dataSource) {
  4.         super(dataSource);
  5.     }
  7.     public List<?> selectAll(){
  8.         String sql = "select* from t_member";
  9.         return super.execteQuery(sql, new RowMapper<Member>() {
  11.             @Override
  12.             public Member mapRow(ResultSet rs, int rowNum) throws Exception {
  13.                 Member member = new Member();
  14.                 member.setUsername(rs.getString("username"));
  15.                 member.setPassword(rs.getString("password"));
  16.                 member.setAge(rs.getInt("age"));
  17.                 member.setAddr(rs.getString("addr"));
  18.                 member.setNickName(rs.getString("nickName"));
  19.                 return member;
  20.             }
  21.         },null);
  22.     }
  24. }

这个核心dao就是我们平常使用的调用数据库层的接口，其实这里也就是对数据包括参数和对象的封装，然后传给jdbc模板进行数据库查询，返回结果集！这样一个jdbc模板我们就差不多写完了，可能我们平常写模板类的场景确实很少，大多数我们所看到的都是业务之间的问题，只有一些底层实现会注重模板的编写，了解并看清本质。

3. 模板模式的缺点

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