设计模式学习笔记之九：模板方法模式

时间 2019-11-17

标签设计模式学习笔记之九模板方法繁體版

原文原文链接

如今我家里有一台铃木的小车锋驭和一台铃木的摩托车风暴1000，我要想把这两种类型的车都先跑起来再停下来，有一些步骤，而且这些步骤是有前后顺序的，那就是：java

1. 打开车门算法

2. 启动发动机spring

3. 挂档sql

4. 走起数据库

5. 刹车设计模式

6. 停车less

OO设计原则之一就是分离可变和不变的部分并把可变的部分封装起来，咱们来看一下以上两种类型的车，哪些步骤的实现是同样的，哪些是可变的。咱们把不变的部分提取出来并放到超类中让全部子类共享其行为，同时咱们把可变部分的具体实现延迟到子类中，让子类来自行决定如何实现。ide

1. 打开车门（摩托车没有车门，可变部分）工具

2. 启动发动机（不变部分）测试

3. 挂档（汽车用手挂档，摩托车用脚挂档，可变部分）

4. 走起（不变部分）

5. 刹车（汽车用脚刹车，摩托车用手刹车，可变部分）

6. 停车（不变部分）

固然以上分离可变及不变部分纯属我的看法，个位看官见仁见智。

若是运用设计模式的方法论，咱们应该采用哪一种模式来很好地知足咱们的需求？

在这种应用场景下我建议使用模板方法模式。

模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤的实现延迟到子类中。模板方法使得子类能够在不改变算法结构的状况下，从新定义算法中某些步骤的具体实现。

看到“设计模式”这四个字咱们每每会以为高深莫测，可是模板方法模式倒是一个例外，你要关注的就是一个方法而已，为了达到深刻浅出的效果，咱们从一个最简单的例子开始。

基于以上UML类图我须要说明几点模板方法的设计意图：

1. DriveTemplate是一个抽象类，咱们能够把一些可变的部分封装为抽象方法让子类去作具体实现。

2. DriveTemplate中的drive方法是final的，这样是由于咱们不但愿子类去覆盖这个方法，由于这个方法中定义了算法的步骤，咱们不但愿子类改变算法的结构。

3. 全部的步骤方法都是protected的访问修饰符，由于咱们但愿具体算法的实现只有子类能够访问，对外是不开放的。

咱们再来看看这个简单例子的代码实现及测试结果：

模板抽象类

package com.singland.dp.template;

public abstract class DriveTemplate {
    
    public final void drive() {
        openDoor();
        startEngine();
        gear();
        go();
        brake();
        stop();
    }
    
    protected abstract void openDoor();
    
    protected void startEngine() {
        System.out.println("engine started !");
    }
    
    protected abstract void gear();
    
    protected void go() {
        System.out.println("running...");
    }
    
    protected abstract void brake();
    
    protected void stop() {
        System.out.println("stopped !");
    }
}

小车锋驭的实现

package com.singland.dp.template;

public class SuzukiScross extends DriveTemplate {

    @Override
    protected void openDoor() {
        System.out.println("keyless entry");
    }

    @Override
    protected void gear() {
        System.out.println("gear with hand");
    }

    @Override
    protected void brake() {
        System.out.println("brake with foot");
    }
}

摩托车风暴1000的具体实现

package com.singland.dp.template;

public class SuzukiStrom1000 extends DriveTemplate {

    @Override
    protected void openDoor() {
        System.out.println("no door actually");
    }

    @Override
    protected void gear() {
        System.out.println("gear with foot");
    }

    @Override
    protected void brake() {
        System.out.println("brake with hand");
    }
}

客户端的测试代码就很简单了

package com.singland.dp.template;

import org.junit.Test;

public class MyTest {
    
    @Test
    public void test() {
//        DriveTemplate template = new SuzukiStrom1000();
        DriveTemplate template = new SuzukiScross();
        template.drive();
    }
}

若是咱们想测试摩托车的实现，只要修改一下测试代码就行了。

刚才说到模板方法模式的设计意图的时候，咱们提到了第2点，咱们不但愿子类改变算法的结构或顺序，可是在某种场景中，咱们但愿子类能有一些自主权，虽然它们不能覆盖drive方法，可是咱们依然但愿子类能够本身决定一些东西，那么模板方法模式可否知足这一需求呢？

答案是确定的，咱们来设想这种场景，当咱们在开锋驭的时候，我但愿能够打开车子的MP3功能来听歌，可是骑摩托车的时候则不须要。

这样咱们的UML类图就须要作一点点小改动：

从类图能够看出，咱们在超类中定义了一个music的方法，可是它并非一个抽象方法，这样子类能够本身决定是否覆盖该方法，该方法返回值是一个布尔值的标志位，默认为false. 子类SuzukiScross覆盖了该方法可是SuzukiStorm1000则没有，咱们再来看看具体的实现：

模板方法类

package com.singland.dp.template;

public abstract class DriveTemplate {
    
    public final void drive() {
        openDoor();
        startEngine();
        gear();
        go();
        if (music()) {
            mp3();
        }
        brake();
        stop();
    }
    
    protected abstract void openDoor();
    
    protected void startEngine() {
        System.out.println("engine started !");
    }
    
    protected abstract void gear();
    
    protected void go() {
        System.out.println("running...");
    }
    
    private void mp3() {
        System.out.println("music is good");
    }
    
    protected boolean music() {
        return false;
    }
    
    protected abstract void brake();
    
    protected void stop() {
        System.out.println("stopped !");
    }
}

锋驭的实现：

package com.singland.dp.template;

public class SuzukiScross extends DriveTemplate {
    
    @Override
    protected void openDoor() {
        System.out.println("keyless entry");
    }

    @Override
    protected void gear() {
        System.out.println("gear with hand");
    }

    @Override
    protected void brake() {
        System.out.println("brake with foot");
    }

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

为节省篇幅，相同的代码我就不贴出来了。咱们来看看驾驶锋驭及风暴1000的各自测试结果：

风暴1000

锋驭

写到这里，我来个简单的总结吧。本质上来讲，模板方法设计模式是一个比较容易并且很好理解的模式，在使用这种模式的时候咱们要注意几点：

1. 保护抽象类中定义算法顺序的方法不被子类修改。

2. 分离可变及不可变部分，让子类本身决定可变部分的实现。

3. 让算法的具体实现对子类开放，对其余类关闭。

模板方法模式适用于哪些场景？

让咱们先来看看一段使用JDBC代码来操做数据库中数据的例子：

    private void addStudent(Student student) throws Exception {
        final String SQL = "insert into student (id,studentNumber,firstName,lastName,gender,age,className,major) values (?,?,?,?,?,?,?,?)";
        Connection conn = null;
        PreparedStatement stmt = null;
        try {
            conn = dataSource.getConnection();
            stmt = conn.prepareStatement(SQL);
            stmt.setString(1, student.getId());
            stmt.setString(2, student.getStudentNumber());
            stmt.setString(3, student.getFirstName());
            stmt.setString(4, student.getLastName());
            stmt.setString(5, student.getGender());
            stmt.setInt(6, student.getAge());
            stmt.setString(7, student.getClassName());
            stmt.setString(8, student.getMajor());
            stmt.execute();
        } catch(SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (stmt != null) {
                    stmt.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

以上是一个典型的JDBC实现，咱们先来看看使用JDBC操做数据库须要通过哪些步骤：

1. 获取数据库链接

2. 经过数据库链接获得Statement对象

3. 使用Statement对象进行增删改查

4. 处理异常

5. 关闭链接释放资源

咱们再来区分一下这些步骤中，哪些是可变部分，哪些是不可变部分：

1. 获取数据库链接（不可变）

2. 经过数据库链接获得Statement对象（不可变）

3. 使用Statement对象进行增删改查（可变）

4. 处理异常（不可变）

5. 关闭链接释放资源（不可变）

咱们能够看到，在5个步骤中，4个是不可变的，只有一个步骤是可变的，让我对代码加一些图形注释，这样就更直观了：

想一想若是咱们要写不少这种CRUD的代码，岂不是要重复写不少遍这种模板式的代码？

咱们可使用模板方法模式解决这种问题。

UML类图我就不画了，直接上代码：

模板方法抽象类

package com.studentinfomgt.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;

public abstract class JdbcTemplate2 {
    
    @Autowired
    private DataSource dataSource;
    
    private Connection connection;
    
    protected PreparedStatement statement;
    
    protected ResultSet resultSet;
    
    public final void dbOperation(String sql, Object entity) throws SQLException {
        getStatement(sql);
        crud(entity);
        releaseResources();
    }

    protected void getStatement(String sql) throws SQLException {
        connection = dataSource.getConnection();
        this.statement = connection.prepareStatement(sql);
    }
    
    protected abstract void crud(Object entity) throws SQLException;
    
    private void releaseResources() throws SQLException {
        if (resultSet != null)
            resultSet.close();
        if (statement != null)
            statement.close();
        if (connection != null)
            connection.close();
    }
}

在上面的抽象类中，组织算法顺序的方法是dbOperation，算法块前后是：获取数据库链接，获取PreparedStatement, CRUD, 释放资源

接下来是增长数据到数据库的具体实现，删改查我就不贴出来了

package com.studentinfomgt.dao;

import java.sql.SQLException;

import com.studentinfomgt.pojo.Student;

public class JdbcCreateEntity extends JdbcTemplate2 {
    
    @Override
    protected void crud(Object entity) throws SQLException {
        Student student = (Student) entity;
        statement.setString(1, student.getId());
        statement.setString(2, student.getStudentNumber());
        statement.setString(3, student.getFirstName());
        statement.setString(4, student.getLastName());
        statement.setString(5, student.getGender());
        statement.setInt(6, student.getAge());
        statement.setString(7, student.getClassName());
        statement.setString(8, student.getMajor());
        statement.execute();
    }
}

再来看看个人DAO实现方法是多么简洁和简单:) 由于那些烦人的模板代码都让模板去处理了

    private void addStudent(Student student) throws Exception {
        final String SQL = "insert into student (id,studentNumber,firstName,lastName,gender,age,className,major) values (?,?,?,?,?,?,?,?)";
        createEntity.dbOperation(SQL, student);
    }

写到这里我再来告诉你，其实咱们不须要重复发明轮子，由于考虑到使用JDBC方式访问数据库形成的重复代码的问题，万能的Spring早就作好了一个现成的工具JdbcTemplate, 咱们只须要使用这个工具就行了。