常用设计模式：模板方法模式

技术分享 4个月前 (11-15) 0 999+

引言

模板方法模式（Template Method Pattern）是一种行为型设计模式。它定义算法骨架，将具体步骤延迟到子类实现。适用于固定流程但部分步骤可变的情景，如游戏初始化或数据处理。

定义

抽象类：定义模板方法（final方法）和抽象步骤。
具体子类：实现抽象步骤。

优点：代码复用，易扩展。缺点：子类过多时复杂。

classDiagram class Beverage { +prepare(): void +boilWater(): void +pourInCup(): void +brew(): void abstract +addCondiments(): void abstract } class Coffee { +brew(): void +addCondiments(): void } class Tea { +brew(): void +addCondiments(): void } Beverage <|-- Coffee Beverage <|-- Tea

TypeScript 示例

假设实现饮料冲泡流程。

类实现

// 抽象类 abstract class Beverage {   // 模板方法   prepare(): void {     this.boilWater();     this.brew();     this.pourInCup();     this.addCondiments();   }    boilWater(): void {     console.log("煮沸水");   }    abstract brew(): void; // 抽象步骤    pourInCup(): void {     console.log("倒入杯中");   }    abstract addCondiments(): void; // 抽象步骤 }  // 具体子类：咖啡 class Coffee extends Beverage {   brew(): void {     console.log("冲泡咖啡");   }    addCondiments(): void {     console.log("加糖和奶");   } }  // 具体子类：茶 class Tea extends Beverage {   brew(): void {     console.log("浸泡茶叶");   }    addCondiments(): void {     console.log("加柠檬");   } }  // 使用 const coffee = new Coffee(); coffee.prepare(); // 输出：煮沸水 冲泡咖啡 倒入杯中 加糖和奶  const tea = new Tea(); tea.prepare(); // 输出：煮沸水 浸泡茶叶 倒入杯中 加柠檬

prepare() 是模板方法，固定流程。子类重写 brew() 和 addCondiments()，不改整体结构。

函数式实现

// ====================== // Step 1: 定义策略函数类型 // ======================  type BrewFunction = () => void; type AddCondimentsFunction = () => void;  // ====================== // Step 2: 固定步骤函数 // ======================  const boilWater = (): void => {   console.log("🔥 Boiling water..."); };  const pourInCup = (): void => {   console.log("🥛 Pouring into cup..."); };  // ====================== // Step 3: 模板方法（高阶函数） // ======================  const makeDrink =   (brew: BrewFunction, addCondiments: AddCondimentsFunction) =>   (): void => {     console.log("n🧪 Starting to make a drink...n");      boilWater();           // 固定     brew();                // 可变     pourInCup();           // 固定     addCondiments();       // 可变      console.log("n✅ Drink is ready!n");   };  // ====================== // Step 4: 策略实现（不同饮料） // ======================  // Coffee const brewCoffee: BrewFunction = () => {   console.log("☕ Brewing coffee grounds..."); };  const addSugarAndMilk: AddCondimentsFunction = () => {   console.log("🍬 Adding sugar and milk..."); };  // Tea const brewTea: BrewFunction = () => {   console.log("🍵 Steeping the tea..."); };  const addLemon: AddCondimentsFunction = () => {   console.log("🍋 Adding a slice of lemon..."); };  // ====================== // Step 5: 组合并执行 // ======================  const makeCoffee = makeDrink(brewCoffee, addSugarAndMilk); makeCoffee();  const makeTea = makeDrink(brewTea, addLemon); makeTea();

真实案例

下面列举了 3 个真实开源仓库，包含明确的“模板方法模式（Template Method Pattern）”逻辑。

Apache Kafka（Java）

Kafka 的复制（Replica / Fetcher / LogCleaner）流程大量使用模板方法模式。

模板方法骨架，文件：AbstractFetcherThread.java

public abstract class AbstractFetcherThread extends ShutdownableThread {     @Override     public void doWork() {         Map<TopicPartition, FetchData> fetched = fetchData();  // 模板步骤         processFetchedData(fetched);                           // 模板步骤         maybeThrottle();     }      protected abstract Map<TopicPartition, FetchData> fetchData();     protected abstract void processFetchedData(Map<TopicPartition, FetchData> fetched); }

子类实现步骤，示例：ReplicaFetcherThread.java

@Override protected Map<TopicPartition, FetchData> fetchData() {     // 从 leader 拉取日志 }  @Override protected void processFetchedData(Map<TopicPartition, FetchData> fetched) {     // 写入本地日志副本 }

doWork() 是固定流程（骨架）
fetchData()、processFetchedData() 由子类决定

Spring Framework / Spring AOP

Spring AOP 的拦截器链实现中大量使用模板方法结构。

模板方法骨架，文件：AbstractPlatformTransactionManager.java

public final TransactionStatus getTransaction(TransactionDefinition definition) {     Object transaction = doGetTransaction();            // 模板步骤     boolean newTx = shouldStartTransaction(...);           if (newTx) {         doBegin(transaction, definition);               // 模板步骤     }     return prepareTransactionStatus(...); }  protected abstract Object doGetTransaction(); protected abstract void doBegin(Object transaction, TransactionDefinition definition);

子类实现步骤，示例：DataSourceTransactionManager.java

@Override protected Object doGetTransaction() {     return new DataSourceTransactionObject(); }  @Override protected void doBegin(Object transaction, TransactionDefinition definition) {     // 开启 JDBC 事务 }

getTransaction() 定义统一事务开启流程
某些步骤由子类实现（JDBC, JPA, Hibernate 都不一样）

Medusa.js

Medusa 是一个基于 TypeScript 的电商框架，批量任务、支付、库存策略等通过抽象基类强制子类实现步骤。

模板方法骨架，文件：AbstractBatchJobStrategy.ts

 export abstract class AbstractBatchJobStrategy {   async prepareBatchJob(batchJob: BatchJob): Promise<void> {     await this.preProcessBatchJob(batchJob);   // 模板步骤     await this.processJob(batchJob);           // 模板步骤     await this.postProcessBatchJob(batchJob);  // 模板步骤   }    protected abstract preProcessBatchJob(job: BatchJob): Promise<void>;   protected abstract processJob(job: BatchJob): Promise<void>;   protected abstract postProcessBatchJob(job: BatchJob): Promise<void>; }

子类实现步骤，示例：ProductImportStrategy.ts

export class ProductImportStrategy extends AbstractBatchJobStrategy {   protected async preProcessBatchJob(job) { ... }   protected async processJob(job) { ... }   protected async postProcessBatchJob(job) { ... } }