当前位置：首页 > news >正文

设计模式——模版方法设计模式（行为型）

news 来源：原创 2025/6/3 9:26:08

摘要

模版方法设计模式是一种行为型设计模式，定义了算法的步骤顺序和整体结构，将某些步骤的具体实现延迟到子类中。它通过抽象类定义模板方法，子类实现抽象步骤，实现代码复用和算法流程控制。该模式适用于有固定流程但部分步骤可变的场景，如业务流程控制等。

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）	模板方法模式中提供可选的“钩子”方法，允许子类决定是否覆盖，灵活控制流程细节。
装饰器模式	在模板方法执行前后动态增强功能，如日志、权限校验等，避免修改模板代码。
责任链模式	将模板方法中的步骤拆分成责任链上的多个处理对象，形成更灵活的处理流程。
命令模式	模板方法中调用命令对象完成某些具体操作，命令模式封装请求，增强扩展性。
观察者模式	模板方法执行过程中发生重要事件时通知观察者，实现业务解耦。