[01][01][15] 模板方法模式详解

1. 定义

模板模式通常又叫模板方法模式,是指定义一个算法的架构,并不允许子类为一个或者多个步骤提供实现

模板方法使得子类可以在不改变算法结构的情况下,重新定义算法的某些步骤

2. 适用场景

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

我们平时办理入职流程填写入职登记表–>打印简历–>复印学历–>复印身份证–>签订
劳动合同–>建立花名册–>办理工牌–>安排工位等

再比如我平时在家里炒菜:洗锅–>点火–>热锅–>上油–>下原料–>翻炒–>放调料–>出锅

再比如赵本山问宋丹丹:“如何把大象放进冰箱?”宋丹丹回答:“第一步:打开冰箱门,第二步:把大象塞进冰箱,第三步:关闭冰箱门”.赵本山再问:“怎么把长劲鹿放进冰箱?”宋丹丹答:“第一步:打开冰箱门,第二步:把大象拿出来,第三步:把长劲鹿塞进去,第四步:关闭冰箱门”(如下图所示),这些都是模板模式的体现

3. 代码实现

以 java 课程创建流程为例
发布预习资料–>制作课件 PPT–>在线直播–>提交课堂笔记–>提交源码–>布置作业–>检查作业

• NetworkCourse 抽象类

public abstract class NetworkCourse {

    protected final void createCourse() {
        //1. 发布预习资料
        this.postPreResource();
        //2. 制作 PPT 课件
        this.createPPT();
        //3. 在线直播
        this.liceVideo();
        //4. 提交课件和课堂笔记
        this.postNote();
        //5. 提交源代码
        this.postSource();
        //6. 布置作业, 如果有作业需要检查作业, 没有作业就不需要检查
        if (this.needHomeWork()) {
            this.checkHomeWork();
        }
    }

    abstract void checkHomeWork();

    /**
     * 钩子方法
     * @return
     */
    protected boolean needHomeWork() {
        return false;
    }

    final void postPreResource(){
        System.out.println("发布预习资料");
    }

    final void createPPT(){
        System.out.println("制作 PPT 课件");
    }

    final void liceVideo(){
        System.out.println("在线直播");
    }

    final void postNote(){
        System.out.println("提交课件和课堂笔记");
    }

    final void postSource(){
        System.out.println("提交源代码");
    }
}

设计钩子方法的主要目的是用来干预执行流程,使得我们控制行为流程更加灵活,更符合实际业务的需求.钩子方法的返回值一般为适合条件分支语句的返回值(如 boolean,int 等).小伙伴们可以根据自己的业务场景来决定是否需要使用钩子方法

• JavaCourse 类

public class JavaCourse extends NetworkCourse {
    @Override
    void checkHomeWork() {
        System.out.println("检查 java 源码编写作业");
    }
}

• BigDataCourse 类

public class BigDataCourse extends NetworkCourse {

    @Override
    protected boolean needHomeWork() {
        return true;
    }

    @Override
    void checkHomeWork() {
        System.out.println("检查大数据课程的作业");
    }
}

• 测试代码

public class NetworkCourseTest {
    public static void main(String[] args) {
        NetworkCourse javaCourse = new JavaCourse();
        javaCourse.createCourse();

        System.out.println("--------------------------------------");

        NetworkCourse bigDataCourse = new BigDataCourse();
        bigDataCourse.createCourse();
    }
}

• 运行结果
  

4. 利用模板模式重构 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 类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Member {
    private String username;
    private String password;
    private String nickName;
    private int age;
    private String 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 {
                return new Member(rs.getString("username"),
                        rs.getString("password"), rs.getString("nickName"),
                        rs.getInt("age"), rs.getString("addr"));
            }
        }, null);
    }
}

• 测试代码

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

5. 模板模式在源码中的体现

先来看 JDK 中的 AbstractList,来看代码

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    ...
    abstract public E get(int index);
    ...
}

我们看到 get()是一个抽象方法,那么它的逻辑就是交给子类来实现,我们大家所熟知的 ArrayList 就是 AbstractList 的子类.同理,有 AbstractList 就有 AbstractSet 和 AbstractMap,有兴趣的小伙伴可以去看看这些的源码实现.还有一个每天都在用的 HttpServlet,有三个方法 service()和 doGet(),doPost()方法,都是模板方法的抽象实现

在 MyBatis 框架也有一些经典的应用,我们来一下 BaseExecutor 类,它是一个基础的 SQL 执行类,实现了大部分的 SQL 执行逻辑,然后把几个方法交给子类定制化完成,源码如下

public abstract class BaseExecutor implements Executor {
    ...
    protected abstract int doUpdate(MappedStatement var1, Object var2) throws SQLException;

    protected abstract List<BatchResult> doFlushStatements(boolean var1) throws SQLException;

    protected abstract <E> List<E> doQuery(MappedStatement var1, Object var2, RowBounds var3, ResultHandler var4, BoundSql var5) throws SQLException;

    protected abstract <E> Cursor<E> doQueryCursor(MappedStatement var1, Object var2, RowBounds var3, BoundSql var4) throws SQLException;
    ...
}

如 doUpdate,doFlushStatements,doQuery,doQueryCursor 这几个方法就是交由子类来实现,那么 BaseExecutor 有哪些子类呢?我们来看一下它的类图

我们一起来看一下 SimpleExecutor 的 doUpdate 实现

public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
    Statement stmt = null;

    int var6;
    try {
        Configuration configuration = ms.getConfiguration();
        StatementHandler handler = configuration.newStatementHandler(this, ms,
            parameter, RowBounds.DEFAULT, (ResultHandler)null, (BoundSql)null);

        stmt = this.prepareStatement(handler, ms.getStatementLog());
        var6 = handler.update(stmt);
    } finally {
        this.closeStatement(stmt);
    }
    return var6;

再来对比一下 BatchExecutor 的 doUpate 实现

public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {
    Configuration configuration = ms.getConfiguration();
    StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject,
        RowBounds.DEFAULT, (ResultHandler)null, (BoundSql)null);

    BoundSql boundSql = handler.getBoundSql();
    String sql = boundSql.getSql();

    Statement stmt;

    if(sql.equals(this.currentSql) && ms.equals(this.currentStatement)) {
        int last = this.statementList.size() - 1;
        stmt = (Statement)this.statementList.get(last);
        this.applyTransactionTimeout(stmt);
        handler.parameterize(stmt);
        BatchResult batchResult = (BatchResult)this.batchResultList.get(last);
        batchResult.addParameterObject(parameterObject);
    } else {
        Connection connection = this.getConnection(ms.getStatementLog());
        stmt = handler.prepare(connection, this.transaction.getTimeout());
        handler.parameterize(stmt);

        this.currentSql = sql;
        this.currentStatement = ms;
        this.statementList.add(stmt);
        this.batchResultList.add(new BatchResult(ms, sql, parameterObject));
    }

    handler.batch(stmt);
    return -2147482646;
 }

细心的小伙伴一定看出来了差异

6. 优缺点

6.1 优点

• 利用模板方法将相同处理逻辑的代码放到抽象父类中,可以提高代码的复用性
• 将不同的代码不同的子类中,通过对子类的扩展增加新的行为,提高代码的扩展性
• 把不变的行为写在父类上,去除子类的重复代码,提供了一个很好的代码复用平台,符合开闭原则

6.2 缺点

• 类数目的增加,每一个抽象类都需要一个子类来实现,这样导致类的个数增加
• 类数量的增加,间接地增加了系统实现的复杂度
• 继承关系自身缺点,如果父类添加新的抽象方法,所有子类都要改一遍