设计模式-模板方法模式

介绍

模板方式模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
所以父类模板方法中有两类方法：

1. 共同的方法：所有子类都会用到的代码
2. 不同的方法：子类要覆盖的方法，分为两种：
   抽象方法：父类中的是抽象方法，子类必须覆盖
   钩子方法：父类中是一个空方法，子类继承了默认也是空的

生活中也有许多模板方法的例子，例如手机的操作（开机、开软件等、关机）、吃饭（点单、吃东西、买单）、煮菜（生火，煮菜、关火）等等。
spring 中对 Hibernate 的支持，将一些已经定好的方法封装起来，比如开启事务、获取 Session、关闭 Session 等。

结构图

这里写图片描述

抽象类（AbstractClass）: 定义抽象的原语操作（primitive operation） ，具体的子类将重定义它们以实现一个算法， 实现一个模板方法,定义一个算法的骨架。该模板方法不仅调用原语操作，也调用定义
具体子类 （ConcreteClass）: 实现原语操作以完成算法中与特定子类相关的步骤。

案例

这篇就拿最原始的jdbc连接来说事。
最原始的jdbc连接代码

public class BasicJdbc {
    public static void main(String[] args) throws Exception{
         //1、加载JDBC驱动程序
         Class.forName("com.mysql.jdbc.Driver").newInstance(); //MYSQL驱动
         //2、创建数据库的连接   
         Connection con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test", "root", "root"); //链接本地MYSQL
         //3、创建一个Statement  
         Statement stmt = con.createStatement();

         //4、执行SQL语句 
         ResultSet res = stmt.executeQuery("select * from user ");
         
         //5、处理结果
         if (res.next()) {
             
         }
         //6、关闭连接
    }
}

上面的代码中，1、2、3、6代码都输固定的，只有4、5中是不固定的。所以可以用模板方法将1、2、3、6的代码封装在抽象类中，而4、5两步交给子类。

抽象类

public abstract class JdbcTemplate {
    public Object execute(String sql) throws Exception{
        Class.forName("com.mysql.jdbc.Driver").newInstance(); //MYSQL驱动
        Connection con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test", "root", "root"); //链接本地MYSQL
        Statement stmt = con.createStatement();

        //执行SQL语句 
        sql += addPage();
        
        ResultSet rs = stmt.executeQuery(sql);
        
        //处理结果
        Object object = handleResultSet(rs);
        
        
        //关闭连接
        
        
        return object;
    }
    
    
    public abstract Object handleResultSet(ResultSet rs);
    
    //类似钩子方法（可用可不用）
    public String addPage() {
        return "";
    }
}

实现类

public class UserJdbc extends JdbcTemplate{

    @Override
    public Object handleResultSet(ResultSet rs) {
        //处理结果集
        return null;
    }

    @Override
    public String addPage() {
        int pageNumber = 1,pageSize = 5;
        return "limit "+pageNumber+","+pageSize;
    }
    
    

}

当然，上面的代码只是阐述大意而已，并不适用于项目中。接下来会根据spring源码中的JdbcTemplate进行分析。

spring模板方法（JdbcTemplate）

spring中的JdbcTemplate不仅仅使用了模板模式，还使用了回调模式
JdbcTemplate中的execute方法

public <T> T execute(StatementCallback<T> action) throws DataAccessException {
        Assert.notNull(action, "Callback object must not be null");

        Connection con = DataSourceUtils.getConnection(getDataSource());
        Statement stmt = null;
        try {
            Connection conToUse = con;
            if (this.nativeJdbcExtractor != null &&
                    this.nativeJdbcExtractor.isNativeConnectionNecessaryForNativeStatements()) {
                conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
            }
            stmt = conToUse.createStatement();
            applyStatementSettings(stmt);
            Statement stmtToUse = stmt;
            if (this.nativeJdbcExtractor != null) {
                stmtToUse = this.nativeJdbcExtractor.getNativeStatement(stmt);
            }
            T result = action.doInStatement(stmtToUse);
            handleWarnings(stmt);
            return result;
        }
        catch (SQLException ex) {
            // Release Connection early, to avoid potential connection pool deadlock
            // in the case when the exception translator hasn't been initialized yet.
            JdbcUtils.closeStatement(stmt);
            stmt = null;
            DataSourceUtils.releaseConnection(con, getDataSource());
            con = null;
            throw getExceptionTranslator().translate("StatementCallback", getSql(action), ex);
        }
        finally {
            JdbcUtils.closeStatement(stmt);
            DataSourceUtils.releaseConnection(con, getDataSource());
        }
    }

可以看到传入的参数是StatementCallback类，然后调用action.doInStatement(stmtToUse)返回一个泛型结果，下面看看StatementCallback的源代码

public interface StatementCallback<T> {
    T doInStatement(Statement stmt) throws SQLException, DataAccessException;
}

可以看到就只有一个doInStatement方法，现在再看看调用execute(StatementCallback<T> action)的方法

public void execute(final String sql) throws DataAccessException {
        if (logger.isDebugEnabled()) {
            logger.debug("Executing SQL statement [" + sql + "]");
        }
        class ExecuteStatementCallback implements StatementCallback<Object>, SqlProvider {
            @Override
            public Object doInStatement(Statement stmt) throws SQLException {
                stmt.execute(sql);
                return null;
            }
            @Override
            public String getSql() {
                return sql;
            }
        }
        execute(new ExecuteStatementCallback());
    }

这里定义了一个内部类ExecuteStatementCallback 实现了StatementCallback接口，然后在调用execute(StatementCallback<T> action)方法，最后再回调ExecuteStatementCallback 内部类的doInStatement方法。
这样做的话可以有效减少子类的个数，不同的处理结果只要传入不同的实现了StatementCallback接口的类就可以了， 这样其实也是Spring的无侵入设计思想的体现，同时也是“依赖优于继承”设计理念的体现。