模板方法模式：定义算法骨架，扩展实现细节
在软件开发中，我们经常会遇到这样的情况：某个算法的步骤是固定的，但其中某些步骤的具体实现可能因场景而异。如果每次都在不同的地方重复实现这个算法的整体结构，不仅会导致代码冗余，还会增加维护成本。模板方法模式正是为解决这类问题而生的经典设计模式。
什么是模板方法模式？
模板方法模式是一种行为型设计模式，它在父类中定义一个操作中的算法骨架，而将一些步骤延迟到子类中实现。模板方法使得子类可以不改变算法结构的情况下，重新定义算法中的某些特定步骤。
这种模式的核心思想是：封装不变部分，扩展可变部分。通过把不变的行为搬移到父类，去除子类中的重复代码，提供了一个很好的代码复用平台。
模式结构
模板方法模式包含以下几个主要角色：
- 抽象类：定义算法骨架和抽象方法
- 具体类：实现抽象类中的抽象方法，完成算法中特定步骤的具体实现
实现原理
基本实现
让我们通过一个简单的例子来理解模板方法模式的实现原理。假设我们有一个数据处理的流程，包括读取数据、处理数据和保存数据三个步骤，其中读取和保存数据的方式固定，但处理数据的方式可能不同。
// 抽象类定义算法骨架
public abstract class DataProcessor {
// 模板方法，定义算法骨架（final防止子类重写）
public final void process() {
readData();
processData(); // 抽象方法，由子类实现
saveData();
}
// 具体方法，已有默认实现
private void readData() {
System.out.println("从数据库读取数据...");
}
// 抽象方法，由子类实现
protected abstract void processData();
// 具体方法，已有默认实现
private void saveData() {
System.out.println("将数据保存到数据库...");
}
}
// 具体实现类
public class CSVDataProcessor extends DataProcessor {
@Override
protected void processData() {
System.out.println("使用CSV格式处理数据...");
}
}
// 另一个具体实现类
public class XMLDataProcessor extends DataProcessor {
@Override
protected void processData() {
System.out.println("使用XML格式处理数据...");
}
}
// 使用示例
public class Client {
public static void main(String[] args) {
DataProcessor csvProcessor = new CSVDataProcessor();
csvProcessor.process();
System.out.println("----------");
DataProcessor xmlProcessor = new XMLDataProcessor();
xmlProcessor.process();
}
}
输出结果：
从数据库读取数据...
使用CSV格式处理数据...
将数据保存到数据库...
----------
从数据库读取数据...
使用XML格式处理数据...
将数据保存到数据库...
钩子方法
除了基本的抽象方法外，模板方法模式还可以使用”钩子方法”来提供额外的灵活性。钩子方法在抽象类中提供默认实现，子类可以选择是否重写。
public abstract class DataProcessorWithHook {
public final void process() {
readData();
if (needProcess()) { // 钩子方法
processData();
}
saveData();
postProcess(); // 另一个钩子方法
}
private void readData() {
System.out.println("从数据库读取数据...");
}
protected abstract void processData();
private void saveData() {
System.out.println("将数据保存到数据库...");
}
// 钩子方法：默认返回true，子类可重写
protected boolean needProcess() {
return true;
}
// 钩子方法：空实现，子类可选择重写
protected void postProcess() {
// 默认什么都不做
}
}
// 具体实现类，重写钩子方法
public class OptionalProcessDataProcessor extends DataProcessorWithHook {
private boolean processNeeded;
public OptionalProcessDataProcessor(boolean processNeeded) {
this.processNeeded = processNeeded;
}
@Override
protected void processData() {
System.out.println("处理数据...");
}
@Override
protected boolean needProcess() {
return processNeeded;
}
@Override
protected void postProcess() {
System.out.println("执行后处理操作...");
}
}
实际应用场景
模板方法模式在现实开发中有广泛的应用，以下是一些典型场景：
1. Spring框架中的JdbcTemplate
Spring框架中的JdbcTemplate是模板方法模式的经典应用。它定义了数据库操作的基本流程，而将具体的SQL执行留给使用者。
// Spring JdbcTemplate的使用示例
jdbcTemplate.execute(new ConnectionCallback<Object>() {
@Override
public Object doInConnection(Connection connection) throws SQLException {
// 具体的数据库操作，这是模板方法中的可变部分
try (Statement statement = connection.createStatement()) {
return statement.execute("SELECT * FROM users");
}
}
});
2. Servlet API
Java Servlet API中的service方法也是一个模板方法。它根据HTTP请求方法（GET、POST等）调用相应的doGet、doPost等方法。
public abstract class HttpServlet extends GenericServlet {
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
String method = req.getMethod();
if (method.equals("GET")) {
doGet(req, resp); // 由子类实现
} else if (method.equals("POST")) {
doPost(req, resp); // 由子类实现
}
// 其他HTTP方法...
}
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 默认实现，子类可重写
}
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 默认实现，子类可重写
}
}
3. 游戏开发框架
在游戏开发中，游戏循环通常采用模板方法模式：
public abstract class Game {
// 模板方法：游戏主循环
public final void run() {
initialize();
while (!isGameOver()) { // 钩子方法
processInput();
update();
render();
}
cleanup();
}
protected abstract void initialize();
protected abstract void processInput();
protected abstract void update();
protected abstract void render();
protected abstract boolean isGameOver(); // 钩子方法
protected void cleanup() {
// 默认清理操作
}
}
高级应用：带回调的模板方法
在某些情况下，我们可以使用回调机制来增强模板方法模式的灵活性：
// 使用函数式接口作为回调
@FunctionalInterface
public interface DataProcessorCallback {
void process(String data);
}
public class GenericDataProcessor {
public void process(String source, DataProcessorCallback callback) {
System.out.println("从 " + source + " 读取数据");
String data = "示例数据";
// 执行回调
callback.process(data);
System.out.println("处理完成，保存结果");
}
}
// 使用Lambda表达式
public class CallbackClient {
public static void main(String[] args) {
GenericDataProcessor processor = new GenericDataProcessor();
// 使用Lambda实现不同的处理逻辑
processor.process("数据库", data -> {
System.out.println("处理数据: " + data + " [数据库版本]");
});
processor.process("文件", data -> {
System.out.println("处理数据: " + data + " [文件版本]");
});
}
}
最佳实践与注意事项
优点
- 代码复用：将公共行为放在父类中，避免代码重复
- 提高扩展性：通过子类扩展新的实现，符合开闭原则
- 反向控制：父类调用子类的操作，符合好莱坞原则（”不要调用我们，我们会调用你”）
- 封装不变部分：把不变的行为封装在父类，便于维护
缺点
- 类数量增加：每个不同的实现都需要一个子类
- 骨架修改困难：对算法骨架的修改可能需要修改所有子类
- 可能违反里氏替换原则：如果子类对模板方法进行重写，可能破坏父类定义的行为
设计原则
模板方法模式很好地体现了以下几个面向对象设计原则：
- 开闭原则：对扩展开放，对修改关闭
- 单一职责原则：每个类专注于特定的行为
- 里氏替换原则：子类可以替换父类并保持正确性
总结
模板方法模式通过定义算法的骨架结构，同时将特定步骤的实现延迟到子类，实现了代码复用和扩展性的平衡。这种模式在框架设计、算法实现等场景中有着广泛的应用。
在实际开发中，我们需要仔细分析业务流程，识别出哪些是固定不变的，哪些是可能变化的。将不变的部分封装在模板方法中，将变化的部分通过抽象方法或钩子方法交给子类实现，这样既能保证代码的稳定性，又能提供足够的灵活性。
掌握模板方法模式，能够帮助我们设计出更加灵活、可维护的软件系统，是每个软件工程师都应该熟练掌握的重要设计模式之一。