【设计模式】行为型：模板方法模式

悠悠 2023-01-17 07:43 98阅读 0赞

模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。属于行为性设计模式。

这里的“算法”，我们可以理解为广义上的“业务逻辑”，并不特指数据结构和算法中的“算法”。这里的算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”，这也是模板方法模式名字的由来。

模板方法适用于以下应用场景

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

为了加深理解，下面我们来结合一个常见的业务场景。

### 1.代码示例 ###

利用模板模式重构 JDBC 操作业务场景…

创建一个模板类 JdbcTemplate，封装所有的 JDBC 操作。以查询为例，每次查询的表不同，返回的数据结构也就不一样。我们针对不同的数据，都要封装成不同的实体对象。 而每个实体封装的逻辑都是不一样的，但封装前和封装后的处理流程是不变的，因此， 我们可以使用模板方法模式来设计这样的业务场景。

先创建约束 ORM 逻辑的接口 RowMapper

/**
     * ORM映射定制化的接口
     */
    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;
    
        // getter/setter...
    }

创建数据库操作类 MemberDao：

public class MemberDao extends JdbcTemplate {
        
        public MemberDao(DataSource dataSource) {
        
            super(dataSource);
        }
    
        public List<?> selectAll(){
        
            String sql = "select * from t_member";
            // 调用模板方法 executeQuery
            // 入参自定义 RowMapper
            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);
        }
    }

### 2.源码应用 ###

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

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

我们看到 get() 是一个抽象方法，那么它的逻辑就是交给子类来实现，我们大家所熟知的 ArrayList 就是 AbstractList 的子类 。 同理，有 AbstractList 就 有 AbstractSet 和 AbstractMap，有兴趣的小伙伴可以去看看这些的源码实现。

还有，对于 Java Web 项目开发来说，常用的开发框架是 SpringMVC。利用它，我们只需要关注业务代码的编写，底层的原理几乎不会涉及。但是，如果我们抛开这些高级框架来开发 Web 项目，必然会用到 Servlet。实际上，使用比较底层的 Servlet 来开发 Web 项目也不难。我们只需要定义一个继承 HttpServlet 的类，并且重写其中的 doGet() 或 doPost() 方法，来分别处理 get 和 post 请求。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]  
从上面的代码中我们可以看出，HttpServlet 的 service() 方法就是一个模板方法，它实现了整个 HTTP 请求的执行流程，doGet()、doPost() 是模板中可以由子类来定制的部分。实际上，这就相当于 Servlet 框架提供了一个扩展点（doGet()、doPost() 方法），让框架用户在不用修改 Servlet 框架源码的情况下，将业务代码通过扩展点镶嵌到框架中执行。

### 3.总结 ###

模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。这里的“算法”，我们可以理解为广义上的“业务逻辑”，并不特指数据结构和算法中的“算法”。这里的算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”，这也是模板方法模式名字的由来。

在模板模式经典的实现中，模板方法定义为 final，可以避免被子类重写。需要子类重写的方法定义为 abstract，可以强迫子类去实现。不过，在实际项目开发中，模板模式的实现比较灵活，以上两点都不是必须的。

模板模式有两大作用：复用和扩展。其中，复用指的是，所有的子类可以复用父类中提供的模板方法的代码。扩展指的是，框架通过模板模式提供功能扩展点，让框架用户可以在不修改框架源码的情况下，基于扩展点定制化框架的功能。

优点：

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

缺点：

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221021/9c1d93d0afda470785ddd28091ea1e0c.png