标签：
现在我家里有一台铃木的小车锋驭和一台铃木的摩托车风暴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, 我们只需要使用这个工具就好了。
标签：
原文地址：http://www.cnblogs.com/stonefeng/p/5743673.html
