1. 模板方法模式初探：为什么我们需要它？
作为一名在Java领域摸爬滚打多年的开发者，我至今记得第一次在项目中应用模板方法模式时的场景。那是一个电商订单处理系统，需要支持多种支付方式（支付宝、微信、银联），每种支付流程都有相同的骨架步骤（验证→执行→回调→日志），但具体实现细节各异。如果为每种支付方式都写一套完整流程，不仅代码重复率高，后期维护更是噩梦——每次流程调整都得修改所有实现类。
模板方法模式（Template Method Pattern）正是为解决这类问题而生。它属于行为型设计模式，通过定义一个操作中的算法骨架，而将某些步骤延迟到子类中实现。这样既保证了算法结构不变，又允许子类根据需要重写特定步骤。
关键理解：模板方法不是关于"代码生成"的技术，而是关于"行为抽象"的艺术。它控制的是算法流程的稳定性，而非具体实现。
2. 模式结构与核心组件拆解
2.1 UML类图解析
标准的模板方法模式包含两个核心角色：
- 抽象类（AbstractClass）：
- 定义算法骨架的模板方法（通常标记为final防止子类覆盖）
- 包含若干抽象方法（由子类必须实现）
- 可能包含具体方法（公共实现）
- 可能包含钩子方法（可选步骤）
java复制public abstract class PaymentProcessor {
// 模板方法（final确保算法结构不被破坏）
public final void process() {
validate();
executePayment();
callback();
logTransaction();
}
// 抽象方法（子类必须实现）
protected abstract void executePayment();
// 具体方法（公共实现）
protected void validate() {
// 通用验证逻辑
}
// 钩子方法（可选步骤）
protected void logTransaction() {
// 默认日志实现
}
}
2.2 方法类型对比表
| 方法类型 | 修饰符 | 是否可重写 | 典型用途 |
|---|---|---|---|
| 模板方法 | final | 否 | 定义算法骨架 |
| 抽象方法 | abstract | 必须 | 强制子类实现的关键步骤 |
| 具体方法 | 无/非abstract | 可选 | 提供默认实现 |
| 钩子方法 | 无 | 可选 | 提供扩展点（非必须实现步骤） |
3. 实战：支付系统案例深度实现
3.1 支付宝支付实现
java复制public class AlipayProcessor extends PaymentProcessor {
@Override
protected void executePayment() {
System.out.println("调用支付宝SDK进行支付");
// 具体的支付宝API调用逻辑
}
@Override
protected void logTransaction() {
System.out.println("记录支付宝专属交易日志");
// 支付宝特有的日志格式
}
}
3.2 微信支付实现
java复制public class WechatPayProcessor extends PaymentProcessor {
@Override
protected void executePayment() {
System.out.println("调用微信支付API");
// 微信支付特有的预处理逻辑
}
// 不重写logTransaction()则使用父类默认实现
}
3.3 客户端调用示例
java复制public class Client {
public static void main(String[] args) {
PaymentProcessor alipay = new AlipayProcessor();
alipay.process(); // 执行完整流程（含自定义日志）
PaymentProcessor wechatPay = new WechatPayProcessor();
wechatPay.process(); // 执行流程（使用默认日志）
}
}
4. 模式进阶：那些教科书不会告诉你的实战经验
4.1 钩子方法的精妙运用
钩子方法（Hook Method）是模板方法模式中最容易被低估的特性。它通过提供一个默认空实现的方法，允许子类"选择性"地介入流程控制。我在金融风控系统中曾这样使用：
java复制public abstract class RiskControlTemplate {
public final void process() {
collectData();
if (needDeepAnalysis()) { // 钩子方法控制流程分支
deepAnalysis();
}
generateReport();
}
// 钩子方法：默认不启用深度分析
protected boolean needDeepAnalysis() {
return false;
}
}
这样设计后，常规交易走快速通道，只有高风险交易（子类重写needDeepAnalysis返回true）才会触发深度分析。
4.2 模板方法与策略模式的抉择
当遇到需要灵活算法时，新手常困惑该用模板方法还是策略模式。我的决策树是：
- 如果算法步骤固定，只是某些步骤实现不同 → 模板方法
- 如果整个算法都需要替换 → 策略模式
曾经在开发文件导出功能时，我同时使用了两者：
java复制// 模板方法处理导出流程
abstract class ExportTemplate {
public final void export() {
prepareData();
formatData(); // 抽象方法
saveToFile();
notifyUser();
}
}
// 策略模式处理不同数据格式
interface Formatter {
String format(List<Data> data);
}
class CSVFormatter implements Formatter { /*...*/ }
class ExcelFormatter implements Formatter { /*...*/ }
4.3 性能优化：模板方法的缓存技巧
在电商促销系统开发中，我发现模板方法常被高频调用。通过将不变的部分提取为静态方法，性能提升显著：
java复制public abstract class PromotionTemplate {
public final void execute() {
// 不变的验证逻辑移入静态方法
ValidationUtils.validateCommonRules();
doExecute(); // 子类实现
}
}
5. 典型应用场景与行业案例
5.1 Java生态中的经典实现
- JUC中的AQS（AbstractQueuedSynchronizer）
java复制// 开发者只需实现tryAcquire/tryRelease public class MyLock extends AbstractQueuedSynchronizer { protected boolean tryAcquire(int arg) { /*...*/ } } - Servlet中的HttpServlet
java复制// 只需重写doGet/doPost public class MyServlet extends HttpServlet { protected void doGet(HttpServletRequest req, HttpServletResponse resp) { // 业务逻辑 } }
5.2 金融行业实战案例
在某银行交易系统中，我们使用模板方法处理不同渠道的交易：
-
ATM交易模板
java复制public abstract class ATMTransaction { public final void process() { insertCard(); authenticate(); doTransaction(); // 抽象方法 printReceipt(); ejectCard(); } } -
手机银行模板
java复制public abstract class MobileTransaction { public final void process() { login(); verifySMS(); doTransaction(); // 相同抽象方法名 pushNotification(); } }
这种设计让渠道差异和业务核心分离，新渠道接入效率提升40%。
6. 反模式：模板方法的常见误用与规避
6.1 过度抽象陷阱
曾见过一个灾难性的设计：抽象类定义了15个抽象方法，导致每个子类都要实现大量无关方法。正确的做法应该是：
- 核心步骤才设为抽象方法
- 非必要步骤提供默认实现
- 使用接口隔离原则拆分大模板
6.2 流程僵化问题
在某物流系统中，原始设计将装车→运输→卸货流程固定为模板。当出现"中转仓"新需求时，不得不重构整个层次。后来我们改进为：
java复制public abstract class ShippingTemplate {
public void process() {
load();
if (needTransit()) { // 钩子方法提供扩展点
transit();
}
deliver();
}
protected boolean needTransit() { return false; }
protected void transit() { /* 默认空实现 */ }
}
6.3 与工厂方法的混淆
新手常分不清模板方法与工厂方法。关键区别在于：
- 工厂方法：创建对象
- 模板方法：定义算法流程
我曾用组合方式同时使用两者：
java复制public abstract class ReportGenerator {
// 模板方法
public final void generate() {
Data data = fetchData();
Format format = createFormatter(); // 工厂方法
String output = format.process(data);
export(output);
}
// 工厂方法
protected abstract Format createFormatter();
}
7. 现代Java中的模板方法演进
7.1 Lambda表达式的影响
Java 8后，部分简单模板可以用Lambda实现：
java复制public void processTemplate(Runnable step1, Runnable step2) {
init();
step1.run();
step2.run();
cleanup();
}
// 调用
processTemplate(
() -> System.out.println("Custom step1"),
() -> System.out.println("Custom step2")
);
但对于复杂流程，传统模板方法仍更具优势。
7.2 Spring框架中的新应用
在Spring Boot中，模板方法模式演变为更灵活的形式：
java复制@Configuration
public class MyConfig {
@Bean
public Template template() {
return new Template() {
@Override
protected void customInit() {
// 通过匿名类实现
}
};
}
}
7.3 与函数式编程的结合
现代Java开发者可以混合使用模板方法与函数式接口：
java复制public class AdvancedTemplate {
private Consumer<Context> preProcess = c -> {};
private Consumer<Context> postProcess = c -> {};
public void execute() {
preProcess.accept(context);
coreBusinessLogic();
postProcess.accept(context);
}
// 提供配置入口
public AdvancedTemplate withPreProcess(Consumer<Context> pre) {
this.preProcess = pre;
return this;
}
}
这种写法在测试时特别有用，可以动态注入mock行为。