北风设计模式课程---模板方法模式
一、总结
一句话总结：
模板方法就是指定算法步骤，具体不同的子类实现不同的算法
1、下列问题适合哪种设计模式：现在我家里有一台铃木的小车锋驭和一台铃木的摩托车风暴1000，我要想把这两种类型的车都先跑起来再停下来，有一些步骤，并且这些步骤是有先后顺序的，那就是：1. 打开车门；2. 启动发动机；3. 挂档；4. 走起；5. 刹车；6. 停车；？
模板方法模式：一个方法中定义一个算法的骨架，而将一些步骤的实现延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中某些步骤的具体实现。
OO设计原则之一就是分离可变和不变的部分并把可变的部分封装起来，我们来看一下以上两种类型的车，哪些步骤的实现是一样的，哪些是可变的。我们把不变的部分提取出来并放到超类中让所有子类共享其行为，同时我们把可变部分的具体实现延迟到子类中，让子类来自行决定如何实现。
1. 打开车门（摩托车没有车门，可变部分）
2. 启动发动机（不变部分）
3. 挂档（汽车用手挂档，摩托车用脚挂档，可变部分）
4. 走起（不变部分）
5. 刹车（汽车用脚刹车，摩托车用手刹车，可变部分）
6. 停车（不变部分）
2、模板方法设计模式 使用注意点？
1. 保护抽象类中定义算法顺序的方法不被子类修改。
2. 分离可变及不可变部分，让子类自己决定可变部分的实现。
3. 让算法的具体实现对子类开放，对其他类关闭。
二、设计模式学习笔记之九：模板方法模式
转自或参考：设计模式学习笔记之九：模板方法模式
https://www.cnblogs.com/stonefeng/p/5743673.html
现在我家里有一台铃木的小车锋驭和一台铃木的摩托车风暴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 {@Overrideprotected void openDoor() {System.out.println("keyless entry");}@Overrideprotected void gear() {System.out.println("gear with hand");}@Overrideprotected void brake() {System.out.println("brake with foot");} }
摩托车风暴1000的具体实现
package com.singland.dp.template;public class SuzukiStrom1000 extends DriveTemplate {@Overrideprotected void openDoor() {System.out.println("no door actually");}@Overrideprotected void gear() {System.out.println("gear with foot");}@Overrideprotected void brake() {System.out.println("brake with hand");} }
客户端的测试代码就很简单了
package com.singland.dp.template;import org.junit.Test;public class MyTest {@Testpublic 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 {@Overrideprotected void openDoor() {System.out.println("keyless entry");}@Overrideprotected void gear() {System.out.println("gear with hand");}@Overrideprotected void brake() {System.out.println("brake with foot");}@Overrideprotected 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 {@Autowiredprivate 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 {@Overrideprotected 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, 我们只需要使用这个工具就好了。
