摘要
模版方法设计模式是一种行为型设计模式，定义了算法的步骤顺序和整体结构，将某些步骤的具体实现延迟到子类中。它通过抽象类定义模板方法，子类实现抽象步骤，实现代码复用和算法流程控制。该模式适用于有固定流程但部分步骤可变的场景，如业务流程控制等。
1. 模版设计模式定义
定义一个操作中的算法骨架（即步骤的顺序和整体结构），而将某些步骤的具体实现延迟到子类中。子类可以在不改变算法结构的前提下，重新定义算法中的某些具体步骤。
1.1.1. 模版设计模式的关键点
- 抽象模版类：定义一个模板方法，描述算法的整体流程。模板方法一般是
final，防止子类改变算法结构。 - 基本方法（基本操作）：模板方法所依赖的步骤，这些步骤可以是抽象的，也可以有默认实现。
- 具体子类：实现抽象类中的抽象步骤，完成具体的业务逻辑。
1.1.2. 作用
- 复用代码：把不变的行为放在父类，变化的行为由子类实现，避免代码重复。
- 控制算法流程：子类只需关注具体步骤实现，算法整体流程由父类控制，增强代码的可维护性和可扩展性。
2. 模版设计模式结构
- 抽象类 （AbstractClass） 会声明作为算法步骤的方法， 以及依次调用它们的实际模板方法。 算法步骤可以被声明为
抽象类型， 也可以提供一些默认实现。 - 具体类 （ConcreteClass） 可以重写所有步骤， 但不能重写模板方法自身。
2.1. 模版设计模式类图
2.2. 模版设计模式时序图
3. 模版设计模式实现方式
3.1. 模版设计模式的实现方式核心在于：
- 在抽象父类中定义一个模板方法（通常是
final的），它规定了算法的执行顺序和骨架。 - 模板方法调用若干个基本方法（步骤），其中部分基本方法是抽象的，由子类实现；部分基本方法可以有默认实现。
- 子类继承抽象父类，实现抽象步骤，完成具体业务逻辑。
3.2. 模板设计模式实现步骤
- 创建抽象类（AbstractClass）
-
- 定义模板方法
templateMethod()，并用final修饰，防止子类重写改变流程。 - 模板方法中按照固定步骤顺序调用基本操作。
- 定义基本操作（抽象方法或具体方法），其中抽象方法由子类实现。
- 定义模板方法
- 创建具体子类（ConcreteClass）
-
- 继承抽象类，实现抽象的基本方法，完成具体业务。
3.3. 示例代码（Java）
// 抽象模板类
public abstract class AbstractTemplate {// 模板方法，定义固定流程，防止子类覆盖public final void templateMethod() {step1();step2();step3();}// 抽象基本操作，由子类实现protected abstract void step1();protected abstract void step2();// 具体基本操作，父类实现，子类可选择复写protected void step3() {System.out.println("默认实现步骤3");}
}// 具体子类A
public class ConcreteTemplateA extends AbstractTemplate {@Overrideprotected void step1() {System.out.println("ConcreteTemplateA 实现步骤1");}@Overrideprotected void step2() {System.out.println("ConcreteTemplateA 实现步骤2");}
}// 具体子类B
public class ConcreteTemplateB extends AbstractTemplate {@Overrideprotected void step1() {System.out.println("ConcreteTemplateB 实现步骤1");}@Overrideprotected void step2() {System.out.println("ConcreteTemplateB 实现步骤2");}// 可以覆盖父类默认实现@Overrideprotected void step3() {System.out.println("ConcreteTemplateB 重写步骤3");}
}3.4. 模版模式示例
public class Client {public static void main(String[] args) {AbstractTemplate templateA = new ConcreteTemplateA();templateA.templateMethod();// 输出：// ConcreteTemplateA 实现步骤1// ConcreteTemplateA 实现步骤2// 默认实现步骤3AbstractTemplate templateB = new ConcreteTemplateB();templateB.templateMethod();// 输出：// ConcreteTemplateB 实现步骤1// ConcreteTemplateB 实现步骤2// ConcreteTemplateB 重写步骤3}
}说明
- 模板方法
templateMethod()固定了整体流程，子类不能改变流程，只能重写步骤细节。 - 这样保证了算法骨架不变，细节可变。
4. 模版设计模式适合场景
4.1. ✅ 适合使用模版设计模式的场景
| 场景 | 说明 |
| 多个子类有相同算法骨架 | 多个子类共享固定流程，只有具体步骤实现不同，便于代码复用和规范流程。 |
| 需要复用公共流程代码 | 将不变的算法结构封装在父类，避免重复代码，提升维护性。 |
| 需要统一控制算法执行顺序 | 模板方法定义执行顺序，防止子类随意改变流程，保证算法正确执行。 |
| 算法结构清晰、变化点集中 | 业务流程稳定，只有个别步骤需要子类实现，方便集中管理和扩展。 |
| 希望固定流程，允许步骤扩展 | 允许子类通过实现抽象步骤或覆盖钩子方法灵活扩展功能，而不破坏整体流程。 |
4.2. ❌ 不适合使用模版设计模式的场景
| 场景 | 原因 |
| 需要动态调整或拼装流程 | 模板方法流程固定，难以支持运行时动态改变步骤或流程组合。 |
| 继承层次过深，代码复杂 | 模板方法依赖继承，过多层次会导致系统复杂且难维护。 |
| 业务变化点不明显或过少 | 过度抽象导致代码冗余，简单业务用模版模式反而增加复杂度。 |
| 多维度变化且复杂 | 多个变化点分布在算法不同部分，模板方法难以灵活应对，策略模式或责任链模式更合适。 |
| 需要高度灵活、组合式的行为 | 模板方法结构静态，不适合高动态组合或插件式设计。 |
5. 模版设计模式实战示例
5.1. 场景描述
在金融风控中，不同风控策略的执行流程大致相同：
- 数据准备
- 规则校验
- 风控决策（通过/拒绝）
- 结果记录
不同风控策略的规则校验细节不同，适合用模板设计模式抽象固定流程，把校验逻辑由子类实现。
5.2. 项目结构示例（Spring Boot）
com.example.riskcontrol
├── RiskControlTemplate.java // 抽象模板类
├── UserRiskControl.java // 具体风控策略1
├── TransactionRiskControl.java // 具体风控策略2
├── RiskControlService.java // 调用客户端
└── SpringBootApplication.java // 启动类5.3. 抽象模板类 RiskControlTemplate
package com.example.riskcontrol;public abstract class RiskControlTemplate {// 模板方法，定义风控流程public final void executeRiskControl(String userId) {prepareData(userId);boolean passed = validateRules(userId);makeDecision(passed);recordResult(userId, passed);}// 准备数据，具体实现可重写，默认空实现protected void prepareData(String userId) {System.out.println("准备风控数据，用户ID：" + userId);}// 抽象规则校验步骤，由具体策略实现protected abstract boolean validateRules(String userId);// 风控决策步骤，固定流程private void makeDecision(boolean passed) {if (passed) {System.out.println("风控通过，继续后续流程");} else {System.out.println("风控拒绝，终止流程");}}// 记录风控结果，默认实现protected void recordResult(String userId, boolean passed) {System.out.println("记录风控结果，用户ID：" + userId + ", 结果：" + (passed ? "通过" : "拒绝"));}
}5.4. 具体策略实现类
package com.example.riskcontrol;import org.springframework.stereotype.Component;@Component("userRiskControl")
public class UserRiskControl extends RiskControlTemplate {@Overrideprotected boolean validateRules(String userId) {System.out.println("执行用户维度的风控规则校验，用户ID：" + userId);// 简单示例，实际接入数据库或外部接口判断return userId.hashCode() % 2 == 0; // 偶数通过，奇数拒绝}
}package com.example.riskcontrol;import org.springframework.stereotype.Component;@Component("transactionRiskControl")
public class TransactionRiskControl extends RiskControlTemplate {@Overrideprotected boolean validateRules(String userId) {System.out.println("执行交易维度的风控规则校验，用户ID：" + userId);// 这里模拟判断交易风险return userId.length() > 5; // 用户ID长度大于5通过}
}5.5. 业务调用层 RiskControlService
package com.example.riskcontrol;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;import java.util.Map;@Service
public class RiskControlService {// 用Spring注解注入所有实现的模板，key为bean名字private final Map<String, RiskControlTemplate> riskControlMap;@Autowiredpublic RiskControlService(Map<String, RiskControlTemplate> riskControlMap) {this.riskControlMap = riskControlMap;}// 执行指定策略public void executeRiskControl(String strategyName, String userId) {RiskControlTemplate strategy = riskControlMap.get(strategyName);if (strategy == null) {throw new IllegalArgumentException("未找到对应风控策略：" + strategyName);}strategy.executeRiskControl(userId);}
}5.6. Spring Boot 启动类
package com.example.riskcontrol;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class SpringBootRiskControlApplication implements CommandLineRunner {@Autowiredprivate RiskControlService riskControlService;public static void main(String[] args) {SpringApplication.run(SpringBootRiskControlApplication.class, args);}@Overridepublic void run(String... args) throws Exception {System.out.println("模拟执行用户风控策略：");riskControlService.executeRiskControl("userRiskControl", "user12345");System.out.println("\n模拟执行交易风控策略：");riskControlService.executeRiskControl("transactionRiskControl", "user12345");}
}5.7. 运行结果示例
模拟执行用户风控策略：
准备风控数据，用户ID：user12345
执行用户维度的风控规则校验，用户ID：user12345
风控拒绝，终止流程
记录风控结果，用户ID：user12345, 结果：拒绝模拟执行交易风控策略：
准备风控数据，用户ID：user12345
执行交易维度的风控规则校验，用户ID：user12345
风控通过，继续后续流程
记录风控结果，用户ID：user12345, 结果：通过5.8. 模版模式总结
- 抽象父类
RiskControlTemplate封装公共流程（模板方法）。 - 具体策略类只需实现风控规则校验步骤。
- 通过 Spring 的
@Component注解和自动装配Map<String, RiskControlTemplate>，方便策略的灵活管理和调用。
6. 模版设计模式思考
6.1. 模版设计模式是不是用于父子类？
是的，模板设计模式（Template Method Pattern）确实是基于父子类继承关系实现的设计模式。
6.1.1. 关键点总结：
- 父类（抽象类）：定义一个模板方法，规定算法的整体流程和执行顺序。模板方法通常是
final，防止子类改变流程。 - 子类（具体类）：继承父类，实现父类中定义的抽象步骤，完成具体业务逻辑。
换句话说，模板模式就是把不变的流程写在父类里，把可变的步骤留给子类实现。
6.1.2. 为什么是父子类？
- 模板方法模式的核心就是“复用公共代码，且允许子类重写部分行为”，这是继承的典型应用场景。
- 父类定义了算法框架，子类只实现细节，满足“开闭原则”（对扩展开放，对修改关闭）。
6.1.3. 举个简单类比：
- 父类像“烘焙蛋糕的流程”
- 子类像“不同口味蛋糕的具体做法”（巧克力、草莓等）
父类确定做蛋糕的步骤（比如准备材料、搅拌、烘焙、装饰），子类决定每步的具体实现。
模板设计模式在实战开发中常和以下设计模式配合使用，发挥协同优势：
6.2. 模版设计模式常和哪些模式用于实战开发中？
| 设计模式 | 结合方式及应用场景 |
| 策略模式 | 模板模式定义算法骨架，策略模式封装可替换的具体行为，实现灵活的步骤替换。比如模板方法中调用策略接口完成某步骤。 |
| 工厂方法模式 | 用工厂方法创建模板方法中需要的具体实现对象，解耦模板和具体子类的实例化。 |
| 钩子方法（Hook Method） | 模板方法模式中提供可选的“钩子”方法，允许子类决定是否覆盖，灵活控制流程细节。 |
| 装饰器模式 | 在模板方法执行前后动态增强功能，如日志、权限校验等，避免修改模板代码。 |
| 责任链模式 | 将模板方法中的步骤拆分成责任链上的多个处理对象，形成更灵活的处理流程。 |
| 命令模式 | 模板方法中调用命令对象完成某些具体操作，命令模式封装请求，增强扩展性。 |
| 观察者模式 | 模板方法执行过程中发生重要事件时通知观察者，实现业务解耦。 |
简单示例场景
- 金融风控：模板定义风控流程，策略模式封装不同风控规则。
- Web请求处理：模板方法定义请求处理流程，工厂方法创建具体处理器。
- 消息发送：模板定义消息发送步骤，装饰器动态添加日志或限流。
博文参考
- 模板方法设计模式
- 设计模式之模板方法模式 | DESIGN
