一、模版方法模式的简介

原型模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤
归类：行为型

二、代码实例

反面例子我就不举了，就举一个常用的JDBC封装吧；
创建实体类 BookDO.java


package com.demo.template.entity;
import lombok.Data;
/**
 * 书籍DO
 */
@Data
public class BookDO {
    private Long id;
    private String name;
}

创建SQL常量帮助类 SQLCommon.java


package com.demo.template.common;
public class SQLCommon{
    public static final String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT";
    public static final String driver = "com.mysql.cj.jdbc.Driver";
    public static final String user = "root";
    public static final String password = "root";
}

创建数据库链接抽象类 JdbcTemplate.java


package com.demo.template.common;
import com.demo.template.entity.BookDO;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public abstract class JdbcTemplate {
    private Connection conn = null;
    private PreparedStatement pst = null;
    private ResultSet rst = null;
    /**
     * 1、加载驱动
     * 2、获取连接
     * @return 数据库连接
     */
    private Connection getConnection() {
        try {
            // 加载数据库驱动程序
            try {
                Class.forName(SQLCommon.driver);
            } catch (ClassNotFoundException e) {
                System.out.println("加载驱动错误");
            }
            // 获取连接
            conn = DriverManager.getConnection(SQLCommon.url, SQLCommon.user, SQLCommon.password);
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
        return conn;
    }
    /**
     * 3、获得PreparedStatement
     * @return 数据库连接
     */
    private PreparedStatement getStatement(String sql) {
        try {
            pst = conn.prepareStatement(sql);
        } catch (SQLException e) {
            System.out.println("创建语句集错误");
        }
        return pst;
    }
    /**
     * 4.1 ----->insert update delete SQL语句的执行的统一方法
     * @param sql SQL语句
     * @return 执行是否成功
     */
    public boolean executeUpdate(String sql) {
        try {
            conn = this.getConnection();
            pst = conn.prepareStatement(sql);
            return pst.executeUpdate() > 0;
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        } finally {
            // 释放资源
            close();
        }
        return false;
    }
    /**
     * 4.2---->SQL 查询将查询结果：一行
     * @param sql SQL语句
     * @return 结果集
     */
    public <T> T findOne(String sql) {
        try {
            conn = this.getConnection();
            pst = conn.prepareStatement(sql);
            rst = pst.executeQuery();
            T t = null;
            if(rst.next()){
                t=rowMapper(rst);
            }
            return t;
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        } finally {
            close();
        }
        return null;
    }
    /**
     * 4.3---->返回一个List
     * @param <T>
     * @param sql
     * @return
     */
    public <T> List<T> list(String sql) {
        try {
            conn = this.getConnection();
            pst = conn.prepareStatement(sql);
            rst = pst.executeQuery();
            T t = null;
            List<T> list = new ArrayList<T>();
            while (rst.next()) {
                t = rowMapper(rst);
                list.add(t);
            }
            return list;
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        } finally {
            close();
        }
        return null;
    }
    /**
     * 5.关闭结果集、关闭语句集、关闭连接
     */
    private void close() {
        // 关闭结果集对象
        if (rst != null) {
            try {
                rst.close();
            } catch (SQLException e) {
                System.out.println(e.getMessage());
            }
        }
        // 关闭PreparedStatement对象
        if (pst != null) {
            try {
                pst.close();
            } catch (SQLException e) {
                System.out.println(e.getMessage());
            }
        }
        // 关闭Connection 对象
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                System.out.println(e.getMessage());
            }
        }
    }
    abstract protected <T> T rowMapper(ResultSet rs) throws SQLException;
}

创建底层数据处理类BookMapper.java


package com.demo.template.mapper;
import com.demo.template.entity.BookDO;
import com.demo.template.common.JdbcTemplate;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
 * 底层数据处理
 */
public class BookMapper extends JdbcTemplate {
    public BookDO findById(Long id){
        String sql = "SELECT * FROM book WHERE id ="+id;
        BookDO bookDO=super.findOne(sql);
        return  bookDO;
    }
    @Override
    protected BookDO rowMapper(ResultSet rs) throws SQLException {
        BookDO bookDO = new BookDO();
        bookDO.setId(rs.getLong("id"));
        bookDO.setName(rs.getString("name"));
        return bookDO;
    }
}

创建测试类（包含了分析）


import com.fasterxml.jackson.databind.ObjectMapper;
public class TemplateTest {
    public static void main(String[] args) throws JsonProcessingException {
        //数据库操作步骤
        /**
         * 1、加载驱动Class.forName
         * 2、获取连接Connection
         * 3、获得PreparedStatement
         * 4、执行语句集，获得结果
         * 5、关闭结果集、关闭语句集、关闭连接
         * 我们分析下，这几个步骤在所有操作的地方 有区别的地方就在于 4
         */
        BookMapper bookMapper=new BookMapper();
        BookDO bookDO=bookMapper.findById(1L);
        System.out.println(new ObjectMapper().writeValueAsString(bookDO));
    }
}

总结：其实模板模式很简单，一句话总结就是：在相同的流程下，某个细节实现不一致的情况下，抽取共同的方法，抽象话该细节方法，让子类处理。