模板方法模式详解：设计模式中的流程控制艺术

1. 模板方法模式入门指南

刚接触设计模式时，模板方法模式是我最早掌握的几个模式之一。它就像烹饪食谱一样，定义了做菜的步骤框架，但允许你在某些环节自由发挥。这种模式特别适合处理那些流程固定但某些步骤需要灵活调整的场景。

模板方法模式的核心在于：父类定义算法骨架，子类实现具体步骤。举个例子，就像银行办理业务的流程：取号->等待->办理->评价，这个流程是固定的，但"办理"环节的具体操作会根据业务类型（存款、转账、开户）而不同。

2. 模式结构与核心组件

2.1 基本结构拆解

模板方法模式主要包含两个关键角色：

1. 抽象类(AbstractClass)：

   • 定义模板方法：封装算法不变的部分
   • 声明抽象方法：需要子类实现的步骤
   • 提供钩子方法(Hook)：可选扩展点

2. 具体类(ConcreteClass)：

   • 实现父类定义的抽象方法
   • 可选重写钩子方法
   • 禁止重写模板方法本身

// 抽象类示例 public abstract class DataProcessor { // 模板方法（final防止子类修改算法结构） public final void process() { openFile(); parseData(); analyze(); generateReport(); closeFile(); } // 必须由子类实现 protected abstract void parseData(); // 可选默认实现 protected void analyze() { // 通用分析逻辑 } // 钩子方法 protected boolean needReport() { return true; } private void openFile() { /* 通用实现 */ } private void closeFile() { /* 通用实现 */ } }

2.2 三种关键方法类型

1. 抽象方法：必须由子类实现

   • 如parseData()，不同文件格式解析逻辑不同

2. 具体方法：父类提供默认实现

   • 如openFile()，所有子类共用相同实现

3. 钩子方法：提供扩展点的空方法

   • 如needReport()，子类可决定是否生成报告

提示：钩子方法通常以"should"、"need"、"can"开头，返回boolean值

3. 实战应用案例

3.1 文档处理系统实现

假设我们要开发支持多种文档格式的处理系统：

public abstract class DocumentProcessor { public final void processDocument() { validate(); extractText(); if (shouldAnalyzeSentiment()) { analyzeSentiment(); } saveResult(); } protected abstract void extractText(); protected void analyzeSentiment() { // 默认情感分析实现 } // 钩子：默认需要情感分析 protected boolean shouldAnalyzeSentiment() { return true; } private void validate() { /* 校验文档有效性 */ } private void saveResult() { /* 统一保存结果 */ } } // PDF处理器 public class PdfProcessor extends DocumentProcessor { @Override protected void extractText() { // 使用PDFBox等库提取文本 } @Override protected boolean shouldAnalyzeSentiment() { return false; // PDF默认不分析情感 } } // Word处理器 public class WordProcessor extends DocumentProcessor { @Override protected void extractText() { // 使用Apache POI提取文本 } @Override protected void analyzeSentiment() { // Word文档定制化情感分析 } }

3.2 游戏AI开发案例

参考策略游戏中不同种族的AI实现：

class GameAI: def turn(self): self.collect_resources() self.build_structures() self.build_units() self.attack() def collect_resources(self): for structure in self.built_structures: structure.collect() @abstractmethod def build_structures(self): pass @abstractmethod def build_units(self): pass def attack(self): enemy = self.closest_enemy() if enemy is None: self.send_scouts(self.map_center) else: self.send_warriors(enemy.position) @abstractmethod def send_scouts(self, position): pass @abstractmethod def send_warriors(self, position): pass class OrcsAI(GameAI): def build_structures(self): if self.has_resources(): # 兽人特有的建造顺序 self.build_farm() self.build_barracks() self.build_stronghold() def send_warriors(self, position): if len(self.warriors) > 5: # 兽人攻击策略 self.berserk_attack(position)

4. 模式应用场景分析

4.1 适用场景

1. 算法流程固定但部分步骤可变：

   • 如支付流程：验证->扣款->通知，其中通知方式可能不同

2. 存在多个相似类包含重复代码：

   • 各子类60%代码相同，40%不同时特别适用

3. 需要控制子类扩展范围：

   • 只允许子类修改特定步骤，保护核心算法结构

4.2 不适用场景

1. 算法步骤频繁变化：

   • 如果步骤顺序常变，会导致频繁修改抽象类

2. 类层次过深：

   • 超过3层的继承关系会使系统难以维护

3. 所有步骤都需要灵活变化：

   • 此时应考虑策略模式而非模板方法

5. 实现技巧与注意事项

5.1 最佳实践

1. 模板方法应声明为final：

   public final void templateMethod() { ... }

   防止子类意外破坏算法结构

2. 合理使用钩子方法：

   • 在关键步骤前后添加钩子，如beforeSave()/afterSave()
   • 命名应清晰表达意图，如shouldLog(), canRetry()

3. 保持抽象方法数量适中：

   • 通常3-5个抽象方法比较合理
   • 过多会导致子类实现负担

5.2 常见错误规避

1. 违反里氏替换原则：

   • 错误示例：子类重写模板方法
   • 正确做法：只重写指定的步骤方法

2. 过度使用继承：

   • 如果只是少量方法不同，考虑组合模式
   • 继承层次建议不超过3层

3. 忽略默认实现：

   • 能为多数子类提供默认实现的方法，就不应设为抽象

6. 模板方法VS其他模式

6.1 与策略模式对比

6.2 与工厂方法关系

工厂方法常作为模板方法的一个步骤出现：

public abstract class Application { // 模板方法 public final void run() { Document doc = createDocument(); // 工厂方法 doc.open(); doc.process(); doc.save(); } // 工厂方法 public abstract Document createDocument(); }

7. 复杂案例：电商订单处理

考虑一个支持多种支付方式的订单处理系统：

abstract class OrderProcessor { public processOrder(): void { this.validateOrder(); this.reserveInventory(); this.processPayment(); this.sendNotification(); this.updateAccounting(); } protected abstract processPayment(): void; protected sendNotification(): void { // 默认邮件通知 EmailService.send(this.order); } // 钩子方法 protected shouldNotifySeller(): boolean { return true; } private validateOrder(): void { ... } private reserveInventory(): void { ... } } class CreditCardOrderProcessor extends OrderProcessor { protected processPayment(): void { CreditCardService.charge(this.order); } } class PayPalOrderProcessor extends OrderProcessor { protected processPayment(): void { PayPalService.authorize(this.order); } protected sendNotification(): void { // PayPal订单使用短信通知 SMSService.send(this.order); } protected shouldNotifySeller(): boolean { return this.order.amount > 1000; } }

8. 性能优化与扩展

8.1 缓存优化

在文档处理案例中，可以加入缓存机制：

public abstract class CachedDocumentProcessor extends DocumentProcessor { private Map<String, String> cache = new HashMap<>(); @Override public final void processDocument() { String cacheKey = generateCacheKey(); if (cache.containsKey(cacheKey)) { loadFromCache(cacheKey); return; } super.processDocument(); saveToCache(cacheKey); } protected abstract String generateCacheKey(); private void loadFromCache(String key) { ... } private void saveToCache(String key) { ... } }

8.2 异步处理扩展

将同步模板方法改造为异步版本：

class AsyncGameAI(GameAI): async def turn(self): await self.collect_resources() await self.build_structures() await self.build_units() await self.attack() @abstractmethod async def build_structures(self): pass # 其他方法也需要改为async

9. 测试策略

测试模板方法模式时需注意：

1. 测试抽象类：

   • 创建测试用的具体子类
   • 验证模板方法流程是否正确

2. 测试具体类：

   • 重点测试重写的方法
   • 验证钩子方法的预期行为

3. 集成测试：

   • 验证完整业务流程
   • 检查各步骤间的交互

示例测试用例：

@Test public void testPdfProcessor() { DocumentProcessor processor = new PdfProcessor(); processor.processDocument(); // 验证不执行情感分析 verify(sentimentService, never()).analyze(any()); } @Test public void testWordProcessorHook() { DocumentProcessor processor = new WordProcessor(); ((WordProcessor)processor).setAnalyzeSentiment(false); processor.processDocument(); // 验证跳过情感分析 assertFalse(processor.getReport().contains("Sentiment")); }

10. 实际项目经验分享

在电商促销系统开发中，我们使用模板方法处理不同类型的促销活动：

1. 遇到的问题：

   • 每种促销都有相同的校验->计算->通知流程
   • 但折扣计算、资格校验等逻辑各不相同
   • 新人常忘记调用父类方法导致流程中断

2. 解决方案：

   public abstract class PromotionTemplate { public final void execute() { if (!validate()) return; calculateDiscount(); if (shouldNotifyUser()) { notifyUser(); } logResult(); } protected abstract boolean validate(); protected abstract void calculateDiscount(); protected boolean shouldNotifyUser() { return true; } private void logResult() { // 统一日志记录 } }

3. 收获的经验：

   • 将通用日志、监控逻辑放在抽象类中
   • 关键步骤添加hook支持扩展
   • 使用final防止流程被破坏
   • 文档中明确标注哪些方法可以/不可以重写

模板方法模式特别适合业务流程标准化的系统，如电商、金融、工作流引擎等领域。当发现多个类有相似流程但部分实现不同时，就该考虑使用这个模式了。