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

摘要

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

1. 模版设计模式定义

定义一个操作中的算法骨架（即步骤的顺序和整体结构），而将某些步骤的具体实现延迟到子类中。子类可以在不改变算法结构的前提下，重新定义算法中的某些具体步骤。

1.1.1. 模版设计模式的关键点

• 抽象模版类：定义一个模板方法，描述算法的整体流程。模板方法一般是 final，防止子类改变算法结构。
• 基本方法（基本操作） ：模板方法所依赖的步骤，这些步骤可以是抽象的，也可以有默认实现。
• 具体子类：实现抽象类中的抽象步骤，完成具体的业务逻辑。

1.1.2. 作用

• 复用代码：把不变的行为放在父类，变化的行为由子类实现，避免代码重复。
• 控制算法流程：子类只需关注具体步骤实现，算法整体流程由父类控制，增强代码的可维护性和可扩展性。

2. 模版设计模式结构

1. 抽象类 （Abstract­Class） 会声明作为算法步骤的方法， 以及依次调用它们的实际模板方法。 算法步骤可以被声明为 抽象类型， 也可以提供一些默认实现。
2. 具体类 （Concrete­Class） 可以重写所有步骤， 但不能重写模板方法自身。

2.1. 模版设计模式类图

2.2. 模版设计模式时序图

3. 模版设计模式实现方式

3.1. 模版设计模式的实现方式核心在于：

• 在抽象父类中定义一个模板方法（通常是final的），它规定了算法的执行顺序和骨架。
• 模板方法调用若干个基本方法（步骤），其中部分基本方法是抽象的，由子类实现；部分基本方法可以有默认实现。
• 子类继承抽象父类，实现抽象步骤，完成具体业务逻辑。

3.2. 模板设计模式实现步骤

1. 创建抽象类（AbstractClass）

• • 定义模板方法templateMethod()，并用final修饰，防止子类重写改变流程。
  • 模板方法中按照固定步骤顺序调用基本操作。
  • 定义基本操作（抽象方法或具体方法），其中抽象方法由子类实现。

2. 创建具体子类（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 {

    @Override
    protected void step1() {
        System.out.println("ConcreteTemplateA 实现步骤1");
    }

    @Override
    protected void step2() {
        System.out.println("ConcreteTemplateA 实现步骤2");
    }
}

// 具体子类B
public class ConcreteTemplateB extends AbstractTemplate {

    @Override
    protected void step1() {
        System.out.println("ConcreteTemplateB 实现步骤1");
    }

    @Override
    protected void step2() {
        System.out.println("ConcreteTemplateB 实现步骤2");
    }

    // 可以覆盖父类默认实现
    @Override
    protected 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
        // 默认实现步骤3

        AbstractTemplate templateB = new ConcreteTemplateB();
        templateB.templateMethod();
        // 输出：
        // ConcreteTemplateB 实现步骤1
        // ConcreteTemplateB 实现步骤2
        // ConcreteTemplateB 重写步骤3
    }
}

说明

• 模板方法templateMethod()固定了整体流程，子类不能改变流程，只能重写步骤细节。
• 这样保证了算法骨架不变，细节可变。

4. 模版设计模式适合场景

4.1. ✅ 适合使用模版设计模式的场景

场景	说明
多个子类有相同算法骨架	多个子类共享固定流程，只有具体步骤实现不同，便于代码复用和规范流程。
需要复用公共流程代码	将不变的算法结构封装在父类，避免重复代码，提升维护性。
需要统一控制算法执行顺序	模板方法定义执行顺序，防止子类随意改变流程，保证算法正确执行。
算法结构清晰、变化点集中	业务流程稳定，只有个别步骤需要子类实现，方便集中管理和扩展。
希望固定流程，允许步骤扩展	允许子类通过实现抽象步骤或覆盖钩子方法灵活扩展功能，而不破坏整体流程。

4.2. ❌ 不适合使用模版设计模式的场景

场景	原因
需要动态调整或拼装流程	模板方法流程固定，难以支持运行时动态改变步骤或流程组合。
继承层次过深，代码复杂	模板方法依赖继承，过多层次会导致系统复杂且难维护。
业务变化点不明显或过少	过度抽象导致代码冗余，简单业务用模版模式反而增加复杂度。
多维度变化且复杂	多个变化点分布在算法不同部分，模板方法难以灵活应对，策略模式或责任链模式更合适。
需要高度灵活、组合式的行为	模板方法结构静态，不适合高动态组合或插件式设计。

5. 模版设计模式实战示例

5.1. 场景描述

在金融风控中，不同风控策略的执行流程大致相同：

1. 数据准备
2. 规则校验
3. 风控决策（通过/拒绝）
4. 结果记录

不同风控策略的规则校验细节不同，适合用模板设计模式抽象固定流程，把校验逻辑由子类实现。

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 {

    @Override
    protected 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 {

    @Override
    protected 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;

    @Autowired
    public 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 {

    @Autowired
    private RiskControlService riskControlService;

    public static void main(String[] args) {
        SpringApplication.run(SpringBootRiskControlApplication.class, args);
    }

    @Override
    public 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请求处理：模板方法定义请求处理流程，工厂方法创建具体处理器。
• 消息发送：模板定义消息发送步骤，装饰器动态添加日志或限流。

博文参考

• refactoringguru.cn/design-patt…
• dunwu.github.io/design/page…