模板方法模式

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

1. 打开车门

2. 启动发动机

3. 挂档

4. 走起

5. 刹车

6. 停车

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

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, 我们只需要使用这个工具就好了。

转载自:https://www.cnblogs.com/stonefeng/p/5743673.html