模板模式

概述

模板模式通常也叫模板方法模式（Template Method Pattern）是指定义一个算法的骨架，并允许子类对一个或多个步骤提供实现，属于行为型设计模式。简单来说就是定义基类(通常是抽象类)在类中定义好算法的具体步骤，每个步骤具体的实现可能是固定的也有可能推迟到子类中实现。比如把大象放冰箱里，这里一共分三步：1.打开冰箱门、2.把大象放冰箱里、3.关冰箱门，那么第一步和最后一步可以是固定的，具体怎么把大象放入冰箱有可能有不同的实现，不过总的就是三步。

下面我们来看一个老师上课的例子，假如老师上课分为这些步骤：发放预习资料>制作上课ppt>授课>检查作业，这里检查作业需判断有作业才检查作业，我们用代码简单的实现一下这个过程

课程抽象类定义课程创建的过程其中授课和检查作业是变化的，是否有作业是通过needHomework()方法控制的默认是有作业的

public abstract class Course {
    protected final void createCourse()
    {
        //1.发布预习资料
        postPreSource();
        //2.制作ppt
        createPPT();
        //3.授课
        teaching();
        //4.检查作业（有作业才需要检查作业）,默认是有作业的
        if (needHomework())
        {
            checkHomework();
        }
    }

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

    private final void createPPT() {
        System.out.println("制作上课使用的PPT");
    }

    abstract void teaching();

    protected boolean needHomework(){
        return true;
    }

    abstract void checkHomework();
}

具体子课程-英语课程

public class EnglishCourse extends Course{
    @Override
    void teaching() {
        System.out.println("英语授课");
    }

    @Override
    void checkHomework() {
        System.out.println("检查英语作业");
    }
}

具体子课程-数学课程，这里needHomework可以传值

public class MathCourse extends Course{
    private boolean needHomework;

    public MathCourse(boolean needHomework) {
        this.needHomework = needHomework;
    }

    @Override
    void teaching() {
        System.out.println("数学授课");
    }

    @Override
    protected boolean needHomework() {
        return needHomework;
    }

    @Override
    void checkHomework() {
        System.out.println("检查数学作业");
    }
}

测试代码

public class CourseTest {
    public static void main(String[] args) {
        Course engCourse = new EnglishCourse();
        engCourse.createCourse();
        System.out.println("==================");
        Course mathCourse = new MathCourse(false);
        mathCourse.createCourse();
    }
}

测试结果

为了加深印象我们结合一个常见的业务场景

利用模板模式重构JDBC的查询(这边举的例子是查询其他也可以)操作

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

/**
 * @Auther : gudazhi
 * @Description 处理结果集接口
 **/
public interface RowMapper<T> {
    T mapRow(ResultSet rs,int row) throws Exception;
}

封装所有JDBC操作流程的抽象类JDBCTemplate

public abstract class JDBCTemplate {
    private DataSource dataSource;

    protected JDBCTemplate(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    protected List<?> executeQuery(String sql,RowMapper<?> rowMapper,Object[] args)
    {
        try {
            //1.获取连接
            Connection conn = this.getConnection();
            //2.创建语句集
            PreparedStatement pstm = this.createPreparedStatement(conn, sql);
            //3.执行语句集
            ResultSet rs = this.executeQuery(pstm, args);
            //4.处理结果集
            List<?> result = this.parseResultSet(rs, rowMapper);
            //5.关闭结果集
            this.closeResultSet(rs);
            //6.关闭语句集
            this.closeStatement(pstm);
            //7.关闭连接
            this.closeConnection(conn);
            return result;
        }catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }

    private void closeConnection(Connection conn) throws Exception{
        //连接池的话不是关闭
        conn.close();
    }

    private void closeStatement(PreparedStatement pstm) throws Exception{
        pstm.close();
    }

    private void closeResultSet(ResultSet rs) throws Exception{
        rs.close();
    }

    private List<?> parseResultSet(ResultSet rs, RowMapper<?> rowMapper) throws Exception{
        List<Object> result = new ArrayList<Object>();
        int i = 1;
        while (rs.next())
        {
            result.add(rowMapper.mapRow(rs,i++));
        }
        return result;
    }

    private ResultSet executeQuery(PreparedStatement pstm, Object[] args) throws Exception{
        for (int i=0;i<args.length;i++)
        {
            pstm.setObject(i,args[i]);
        }
        return pstm.executeQuery();
    }

    private PreparedStatement createPreparedStatement(Connection conn, String sql) throws Exception{
        return conn.prepareStatement(sql);
    }

    private Connection getConnection() throws Exception{
        return this.dataSource.getConnection();
    }
}

实体类-Member

public class Member {
    private String username;
    private String password;
    private String age;

    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 getAge() {
        return age;
    }

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

数据库操作类-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 row) throws Exception {
                Member member = new Member();
                //属性比较多可以使用原型模式
                member.setUsername(rs.getString("username"));
                member.setPassword(rs.getString("password"));
                member.setAge(rs.getString("age"));
                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);
    }
}

模板模式优缺点

优点

1. 利用模板模式将相同的处理逻辑放在抽象父类中，提高代码复用性
2. 不同逻辑可以放在子类中实现，提高代码扩展性

缺点

1. 类的数目增加，每一个抽象类都需要子类来实现，导致类的数目增加，增加系统的复杂度
2. 继承关系自身的缺点，如果父类中新增抽象方法，每一个子类都需要实现