现在我家里有一台铃木的小车锋驭和一台铃木的摩托车风暴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, 我们只需要使用这个工具就好了。