联系我

设计模式之模板模式

2020.06.18

定义

模板模式通常又叫模板方法模式(Template Method Pattern)是指定义一个算法的骨架,并允许子类为一个或者多个步骤提供实现。模板方法使得子类可以在不改变算法结构的情况下,重新定义算法的某些步骤,属于行为性设计模式。

模板模式在现实生活中的体现

  • 入职流程:填写入职登记表-->打印简历-->复印学历-->复印身份证-->签订劳动合同-->建立花名册-->办理工牌-->安排工位
  • 炒菜:洗锅-->点火-->热锅-->上油-->下原料-->翻炒-->放调料-->出锅
  • 如何把大象放进冰箱:第一步:打开冰箱门,第二步:把大象塞进冰箱,第三步:关闭冰箱门

模板模式应用场景

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

简单案例

这里以一个课程创建流程为例:发布预习资料-->制作课件 PPT-->在线直播--> 提 交 课 堂 笔 记 --> 提 交 源 码 --> 布 置 作 业 --> 检 查 作 业 。

创建NetworkCourse 抽象类:

public abstract class NetworkCourse {
    protected final void createCourse() {
        //1、 发布预习资料
        this.postPreResource();
        //2、 制作 PPT 课件
        this.createPPT();
        //3、 在线直播
        this.liveVideo();
        //4、 提交课件、 课堂笔记
        this.postNote();
        //5、 提交源码
        this.postSource();
        //6、 布置作业, 有些课是没有作业, 有些课是有作业的
        //如果有作业的话, 检查作业, 如果没作业, 完成了
        if(needHomework()){
            checkHomework();
        }
    }
    abstract void checkHomework();
    protected boolean needHomework(){return false;}
    final void postSource(){
        System.out.println("提交源代码");
    }
    final void postNote(){
        System.out.println("提交课件和笔记");
    }
    final void liveVideo(){
        System.out.println("直播授课");
    }
    final void createPPT(){
        System.out.println("创建备课 PPT");
    }
    final void postPreResource(){
        System.out.println("分发预习资料");
    }
}

创建JavaCourse 类:

public class JavaCourse extends NetworkCourse {
    @Override
    void checkHomework() {
        System.out.println("检查 Java 的架构课件");
    }
}

创建 BigDataCourse 类:

public class BigDataCourse extends NetworkCourse {
    private boolean needHomeworkFlag = false;
    public BigDataCourse(boolean needHomeworkFlag) {
        this.needHomeworkFlag = needHomeworkFlag;
    }
    @Override
    void checkHomework() {
        System.out.println("检查大数据的课后作业");
    }
    @Override
    protected boolean needHomework() {
        return this.needHomeworkFlag;
    }
}

创建客户端测试代码NetworkCourseTest:

public class NetworkCourseTest {
    public static void main(String[] args) {
        System.out.println("---Java 架构师课程---");
        NetworkCourse javaCourse = new JavaCourse();
        javaCourse.createCourse();
        System.out.println("---大数据课程---");
        NetworkCourse bigDataCourse = new BigDataCourse(true);
        bigDataCourse.createCourse();
    }
}

业务场景--模板模式重构 JDBC 操作业务场景

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

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

创建封装了所有处理流程的抽象类 JdbcTemplate:

public 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<>();
        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;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = 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>() {
            @Override
            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);
    }
}

模板模式在源码中的体现

来看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()方法,都是模板方法的抽象实现。

模板模式的优缺点

优点:

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

缺点:

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