模板方法

发表于 更新于 分类于 ，

模板方法模式（Template Method Pattern）是一种经典的行为型设计模式，其核心思想是定义一个算法的骨架流程，将算法中不变的核心步骤固化在父类的模板方法中，而将算法中可变的具体实现步骤延迟到子类中实现。通过这种“固定骨架、灵活填充”的设计，既能保证算法整体流程的一致性，又能让子类在不改变算法结构的前提下，灵活定制具体步骤的实现，是软件设计中实现代码复用、规范流程、提升扩展性的重要手段。

模板方法模式的核心价值在于“封装不变、扩展可变”，它将多个子类共有的通用逻辑提取到父类中，避免代码冗余，同时通过抽象方法预留扩展点，让子类按需实现差异化逻辑，完美契合“开闭原则”——对扩展开放，对修改关闭。

一、模板方法模式的核心结构

模板方法模式的结构简洁清晰，核心角色分为两类，二者协同工作，实现“骨架固定、细节灵活”的设计目标，确保算法流程的一致性与实现的灵活性：

1.1 抽象类（Abstract Class）

模板方法模式的核心角色，负责定义算法的骨架流程。它包含两种类型的方法：

  • 模板方法（Template Method）：定义算法的整体执行流程，通常为非抽象方法（可加final修饰，防止子类重写破坏流程），依次调用算法的各个步骤，包括不变的通用步骤和可变的抽象步骤。

  • 基本方法：构成算法流程的具体步骤，分为两种：一是抽象方法（Abstract Method），由子类实现的可变步骤，父类仅定义方法签名，不提供具体实现；二是具体方法（Concrete Method），父类提供的不变通用步骤，子类可直接复用，无需重写（也可根据需求重写，称为“钩子方法”）。

1.2 具体子类（Concrete Class）

继承抽象类，负责实现抽象类中定义的抽象方法，即填充算法流程中可变的具体步骤。子类无需修改算法的整体流程，仅需专注于自身业务场景下的步骤实现，确保算法流程的一致性，同时实现差异化逻辑。

核心逻辑链路：客户端调用抽象类的模板方法 → 模板方法按固定流程调用基本方法（通用步骤+子类实现的可变步骤） → 完成算法执行。整个过程中，算法骨架不变，可变细节由子类灵活实现。

二、多语言实现模板方法模式

为便于开发者落地实践，本文以“饮品制作流程”为经典案例，实现多语言版本的模板方法模式：饮品制作的整体流程（烧水→冲泡→倒入容器→添加配料）为固定骨架，其中“冲泡”和“添加配料”为可变步骤（不同饮品实现不同），“烧水”和“倒入容器”为通用步骤（所有饮品均可复用）。所有实现均保证完整可运行，贴合各语言设计理念，添加规范注释，兼顾实用性与可读性。

2.1 C# 实现（面向对象标准实现）

C# 作为强类型面向对象语言，通过抽象类定义算法骨架，抽象方法定义可变步骤，具体方法定义通用步骤，模板方法用final（C#中为sealed）修饰防止子类破坏流程，代码结构严谨、可读性高，适配企业级业务系统开发，是最常用的实现方式之一。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
using System;

// 抽象类：饮品制作模板（定义算法骨架）
public abstract class BeverageTemplate
{
    /// <summary>
    /// 模板方法：定义饮品制作的固定流程（不可重写，防止破坏流程）
    /// </summary>
    public sealed void MakeBeverage()
    {
        BoilWater();       // 通用步骤：烧水
        Brew();            // 可变步骤：冲泡（子类实现）
        PourInCup();       // 通用步骤：倒入容器
        AddCondiments();   // 可变步骤：添加配料（子类实现）
        Console.WriteLine("饮品制作完成！\n");
    }

    /// <summary>
    /// 具体方法：通用步骤 - 烧水（所有饮品复用）
    /// </summary>
    protected void BoilWater()
    {
        Console.WriteLine("步骤1：烧开水（100℃）");
    }

    /// <summary>
    /// 抽象方法：可变步骤 - 冲泡（子类实现差异化逻辑）
    /// </summary>
    protected abstract void Brew();

    /// <summary>
    /// 具体方法：通用步骤 - 倒入容器（所有饮品复用）
    /// </summary>
    protected void PourInCup()
    {
        Console.WriteLine("步骤3：将饮品倒入杯子中");
    }

    /// <summary>
    /// 抽象方法：可变步骤 - 添加配料（子类实现差异化逻辑）
    /// </summary>
    protected abstract void AddCondiments();
}

// 具体子类1：咖啡制作（实现可变步骤）
public class Coffee : BeverageTemplate
{
    protected override void Brew()
    {
        Console.WriteLine("步骤2：用沸水冲泡咖啡粉");
    }

    protected override void AddCondiments()
    {
        Console.WriteLine("步骤4：添加牛奶和方糖");
    }
}

// 具体子类2：茶制作（实现可变步骤）
public class Tea : BeverageTemplate
{
    protected override void Brew()
    {
        Console.WriteLine("步骤2：用沸水冲泡茶叶");
    }

    protected override void AddCondiments()
    {
        Console.WriteLine("步骤4：添加柠檬片");
    }
}

// 客户端调用（仅依赖抽象类，符合依赖倒置原则）
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("制作咖啡：");
        BeverageTemplate coffee = new Coffee();
        coffee.MakeBeverage();

        Console.WriteLine("制作茶：");
        BeverageTemplate tea = new Tea();
        tea.MakeBeverage();
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义抽象类（可借助abc模块模拟），通过类的继承关系实现模板方法模式，语法简洁灵活，无需繁琐的类型声明，依托GC自动管理内存，适配快速开发、脚本开发及轻量级项目场景，完整保留模板方法模式的核心逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
from abc import ABC, abstractmethod

# 抽象类：饮品制作模板（借助ABC模块模拟抽象类）
class BeverageTemplate(ABC):
    def make_beverage(self):
        """模板方法：定义饮品制作的固定流程（不可重写，Python中通过命名规范约束）"""        self.boil_water()       # 通用步骤：烧水
        self.brew()            # 可变步骤：冲泡（子类实现）
        self.pour_in_cup()      # 通用步骤：倒入容器
        self.add_condiments()   # 可变步骤：添加配料（子类实现）
        print("饮品制作完成！\n")
    
    def boil_water(self):
        """具体方法：通用步骤 - 烧水（所有饮品复用）"""        print("步骤1：烧开水（100℃）")
    
    @abstractmethod
    def brew(self):
        """抽象方法：可变步骤 - 冲泡（子类必须实现）"""        pass
    
    def pour_in_cup(self):
        """具体方法：通用步骤 - 倒入容器（所有饮品复用）"""        print("步骤3：将饮品倒入杯子中")
    
    @abstractmethod
    def add_condiments(self):
        """抽象方法：可变步骤 - 添加配料（子类必须实现）"""        pass

# 具体子类1：咖啡制作
class Coffee(BeverageTemplate):
    def brew(self):
        print("步骤2：用沸水冲泡咖啡粉")
    
    def add_condiments(self):
        print("步骤4：添加牛奶和方糖")

# 具体子类2：茶制作
class Tea(BeverageTemplate):
    def brew(self):
        print("步骤2：用沸水冲泡茶叶")
    
    def add_condiments(self):
        print("步骤4：添加柠檬片")

# 客户端调用
if __name__ == "__main__":
    print("制作咖啡：")
    coffee = Coffee()
    coffee.make_beverage()
    
    print("制作茶：")
    tea = Tea()
    tea.make_beverage()

2.3 Go 实现（接口+结构体的极简实现）

Go 语言无类和继承概念，核心遵循“组合优于继承”的设计哲学，通过接口定义可变步骤的契约，结构体嵌入实现通用步骤，模板方法定义固定流程，代码极简、高效，贴合Go语言“简洁、务实、高性能”的设计理念，适配高并发、高性能的后端开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package main

import (
    "fmt"
)

// 定义可变步骤的接口（抽象方法契约）
type BeverageInterface interface {
    Brew()            // 可变步骤：冲泡
    AddCondiments()   // 可变步骤：添加配料
}

// 抽象模板结构体：实现通用步骤，嵌入接口实现可变步骤
type BeverageTemplate struct {
    BeverageInterface // 嵌入接口，实现依赖注入
}

// 模板方法：定义固定流程（不可重写，Go中通过结构体方法实现）
func (t *BeverageTemplate) MakeBeverage() {
    t.BoilWater()       // 通用步骤：烧水
    t.Brew()            // 可变步骤：调用接口方法（子类实现）
    t.PourInCup()       // 通用步骤：倒入容器
    t.AddCondiments()   // 可变步骤：调用接口方法（子类实现）
    fmt.Println("饮品制作完成！\n")
}

// 通用步骤：烧水（所有饮品复用）
func (t *BeverageTemplate) BoilWater() {
    fmt.Println("步骤1：烧开水（100℃）")
}

// 通用步骤：倒入容器（所有饮品复用）
func (t *BeverageTemplate) PourInCup() {
    fmt.Println("步骤3：将饮品倒入杯子中")
}

// 具体子类1：咖啡制作（实现接口的可变步骤）
type Coffee struct{}

func (c *Coffee) Brew() {
    fmt.Println("步骤2：用沸水冲泡咖啡粉")
}

func (c *Coffee) AddCondiments() {
    fmt.Println("步骤4：添加牛奶和方糖")
}

// 具体子类2：茶制作（实现接口的可变步骤）
type Tea struct{}

func (t *Tea) Brew() {
    fmt.Println("步骤2：用沸水冲泡茶叶")
}

func (t *Tea) AddCondiments() {
    fmt.Println("步骤4：添加柠檬片")
}

// 客户端调用
func main() {
    fmt.Println("制作咖啡：")
    coffee := &Coffee{}
    coffeeTemplate := &BeverageTemplate{BeverageInterface: coffee}
    coffeeTemplate.MakeBeverage()
    
    fmt.Println("制作茶：")
    tea := &Tea{}
    teaTemplate := &BeverageTemplate{BeverageInterface: tea}
    teaTemplate.MakeBeverage()
}

2.4 C++ 实现（面向对象经典实现）

C++ 作为经典面向对象语言，通过抽象类（纯虚函数）定义可变步骤，具体方法定义通用步骤，模板方法用final修饰防止子类重写，依托继承关系实现代码复用，需手动管理内存，兼顾灵活性与高性能，适配底层开发、高频调用场景，是底层系统、高性能应用的优选实现方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#include <iostream>
using namespace std;

// 抽象类：饮品制作模板（定义算法骨架）
class BeverageTemplate {
public:
    // 模板方法：固定流程，final修饰防止子类重写
    final void makeBeverage() {
        boilWater();       // 通用步骤：烧水
        brew();            // 可变步骤：冲泡（纯虚函数，子类实现）
        pourInCup();       // 通用步骤：倒入容器
        addCondiments();   // 可变步骤：添加配料（纯虚函数，子类实现）
        cout << "饮品制作完成！\n" << endl;
    }

protected:
    // 具体方法：通用步骤 - 烧水（所有饮品复用）
    void boilWater() {
        cout << "步骤1：烧开水（100℃）" << endl;
    }

    // 纯虚函数：可变步骤 - 冲泡（子类必须实现）
    virtual void brew() = 0;

    // 具体方法：通用步骤 - 倒入容器（所有饮品复用）
    void pourInCup() {
        cout << "步骤3：将饮品倒入杯子中" << endl;
    }

    // 纯虚函数：可变步骤 - 添加配料（子类必须实现）
    virtual void addCondiments() = 0;

    // 析构函数：虚析构，避免多态场景下内存泄漏
    virtual ~BeverageTemplate() = default;
};

// 具体子类1：咖啡制作
class Coffee : public BeverageTemplate {
protected:
    void brew() override {
        cout << "步骤2：用沸水冲泡咖啡粉" << endl;
    }

    void addCondiments() override {
        cout << "步骤4：添加牛奶和方糖" << endl;
    }
};

// 具体子类2：茶制作
class Tea : public BeverageTemplate {
protected:
    void brew() override {
        cout << "步骤2：用沸水冲泡茶叶" << endl;
    }

    void addCondiments() override {
        cout << "步骤4：添加柠檬片" << endl;
    }
};

// 客户端调用
int main() {
    cout << "制作咖啡：" << endl;
    BeverageTemplate* coffee = new Coffee();
    coffee->makeBeverage();
    delete coffee; // 释放资源

    cout << "制作茶：" << endl;
    BeverageTemplate* tea = new Tea();
    tea->makeBeverage();
    delete tea; // 释放资源

    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，无类和继承，通过“结构体封装数据+函数指针封装行为”，手动模拟模板方法模式的核心逻辑，用函数指针实现可变步骤，用普通函数实现通用步骤，需手动管理内存，代码虽略显冗余，但底层可控性强，适配嵌入式、底层开发等资源受限场景，完美还原“固定骨架、灵活填充”的核心思想。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#include <stdio.h>
#include <stdlib.h>

// 定义可变步骤的函数指针（模拟抽象方法）
typedef void (*BrewFunc)();
typedef void (*AddCondimentsFunc)();

// 抽象模板结构体：封装通用步骤和可变步骤的函数指针
typedef struct {
    BrewFunc brew;                // 可变步骤：冲泡
    AddCondimentsFunc add_condiments; // 可变步骤：添加配料
} BeverageTemplate;

// 通用步骤：烧水（所有饮品复用）
void boil_water() {
    printf("步骤1：烧开水（100℃）\n");
}

// 通用步骤：倒入容器（所有饮品复用）
void pour_in_cup() {
    printf("步骤3：将饮品倒入杯子中\n");
}

// 模板方法：定义固定流程
void make_beverage(BeverageTemplate* template) {
    if (template == NULL || template->brew == NULL || template->add_condiments == NULL) {
        printf("模板初始化失败，无法制作饮品\n");
        return;
    }
    boil_water();
    template->brew();
    pour_in_cup();
    template->add_condiments();
    printf("饮品制作完成！\n\n");
}

// 具体实现1：咖啡的冲泡和添加配料方法
void coffee_brew() {
    printf("步骤2：用沸水冲泡咖啡粉\n");
}
void coffee_add_condiments() {
    printf("步骤4：添加牛奶和方糖\n");
}

// 具体实现2：茶的冲泡和添加配料方法
void tea_brew() {
    printf("步骤2：用沸水冲泡茶叶\n");
}
void tea_add_condiments() {
    printf("步骤4：添加柠檬片\n");
}

// 创建咖啡模板实例
BeverageTemplate* create_coffee_template() {
    BeverageTemplate* template = (BeverageTemplate*)malloc(sizeof(BeverageTemplate));
    if (template == NULL) return NULL;
    template->brew = coffee_brew;
    template->add_condiments = coffee_add_condiments;
    return template;
}

// 创建茶模板实例
BeverageTemplate* create_tea_template() {
    BeverageTemplate* template = (BeverageTemplate*)malloc(sizeof(BeverageTemplate));
    if (template == NULL) return NULL;
    template->brew = tea_brew;
    template->add_condiments = tea_add_condiments;
    return template;
}

// 释放模板资源
void destroy_template(BeverageTemplate* template) {
    if (template != NULL) {
        free(template);
        template = NULL;
    }
}

// 客户端调用
int main() {
    printf("制作咖啡：\n");
    BeverageTemplate* coffee = create_coffee_template();
    make_beverage(coffee);
    destroy_template(coffee);

    printf("制作茶：\n");
    BeverageTemplate* tea = create_tea_template();
    make_beverage(tea);
    destroy_template(tea);

    return 0;
}

三、模板方法模式的优缺点

模板方法模式的核心价值是“封装不变、扩展可变”，其优缺点均围绕这一核心展开。在实际开发中，需结合业务场景的流程复杂度、扩展需求，权衡使用，避免过度设计或滥用，确保既发挥其核心优势，又规避潜在问题，实现架构设计的合理性。

3.1 核心优点

  • 代码复用性高：将多个子类共有的通用逻辑提取到抽象类中，避免代码冗余，子类仅需实现差异化的可变步骤，减少重复开发工作量，提升开发效率。

  • 流程规范统一：模板方法定义了算法的固定骨架，确保所有子类的执行流程一致，避免因子类实现差异导致流程混乱，提升系统的规范性和可维护性。

  • 扩展性强，符合开闭原则：新增业务场景时，无需修改抽象类的模板方法和通用步骤，仅需新增子类并实现抽象方法即可，实现“对扩展开放，对修改关闭”，降低代码修改风险。

  • 解耦通用逻辑与差异化逻辑：抽象类负责封装通用逻辑，子类负责实现差异化逻辑，职责划分清晰，便于代码的维护和迭代，降低后期修改成本。

3.2 主要缺点

  • 灵活性受限：模板方法固定了算法的整体流程，若需修改流程结构，必须修改抽象类的模板方法，违反开闭原则，难以适配流程频繁变化的场景。

  • 子类依赖抽象类：子类的实现依赖抽象类的模板设计，若抽象类发生修改（如新增通用步骤），可能导致所有子类需要调整，增加维护成本。

  • 抽象类复杂度提升：当算法流程步骤较多、通用逻辑复杂时，抽象类的代码会变得繁琐，难以理解和维护，尤其当通用步骤与可变步骤耦合较深时，会降低代码可读性。

  • 子类数量可能激增：每新增一种差异化场景，就需要新增一个子类，若场景过多，会导致子类数量激增，增加系统的管理成本。

四、模板方法模式的使用场景

模板方法模式的核心适用场景是“存在多个具有相同执行流程、仅部分步骤实现不同的业务场景”。以下结合具体场景及典型实战案例，帮助开发者快速判断是否适用，实现精准落地，避免滥用或错用。

4.1 核心适用场景

  • 流程固定、细节可变的场景：多个业务场景的执行流程完全一致，仅部分步骤的具体实现不同，如各类文件解析（读取文件→解析内容→校验数据→保存结果）、各类任务执行（初始化→执行核心逻辑→日志记录→清理资源）。

  • 需要统一流程规范的场景：要求所有子类遵循统一的执行流程，避免流程混乱，如框架开发中的流程模板、企业级系统中的业务流程规范（如订单处理、支付流程）。

  • 需要提升代码复用的场景：多个子类存在大量重复的通用逻辑，需提取到父类中复用，减少代码冗余，如各类工具类、业务服务的通用流程封装。

  • 需要灵活扩展的场景：后期可能新增多种差异化场景，且新增场景不改变原有流程，仅需扩展具体步骤，如插件开发、多类型数据处理。

4.2 典型实战案例

  • 框架开发中的流程模板：如Spring的生命周期、JUnit的单元测试流程，框架定义固定的执行骨架（初始化→执行核心逻辑→销毁），开发者仅需实现核心逻辑步骤，无需关注整体流程。

  • 文件解析工具：如Excel、CSV、JSON等多种格式的文件解析，整体流程均为“读取文件→解析内容→校验数据→保存结果”，仅解析步骤的实现不同，通过模板方法模式封装通用流程，子类实现差异化解析逻辑。

  • 业务流程规范：如电商系统的订单处理流程（创建订单→库存扣减→支付验证→订单确认→日志记录），通用步骤（日志记录、参数校验）提取到抽象类，子类实现不同类型订单（普通订单、秒杀订单）的差异化步骤。

  • 工具类封装：如各类数据导出工具（导出Excel、PDF、Word），流程均为“查询数据→格式化数据→生成文件→下载文件”，仅生成文件的步骤不同，通过模板方法模式提升代码复用率。

  • 游戏开发中的角色技能释放：不同角色的技能释放流程一致（前置准备→技能释放→效果展示→冷却计时），仅技能释放和效果展示的逻辑不同，通过模板方法模式规范流程，灵活扩展不同角色的技能。

五、总结

模板方法模式的核心是“固定骨架、灵活填充”，它通过抽象类封装算法的不变流程，用抽象方法预留扩展点，让子类实现差异化细节，既保证了流程的一致性和代码复用性，又实现了功能的灵活扩展，是“开闭原则”的典型落地方式。其本质是将“流程控制”与“细节实现”分离，让抽象类负责把控全局流程，子类专注于具体细节，提升代码的可维护性和扩展性。

从多语言实现来看，尽管各语言的语法特性差异显著，但核心逻辑高度统一，且均能适配自身的设计理念，完整实现模板方法模式的核心价值：

  • 面向对象语言（C#、Python、C++）：通过抽象类+继承关系实现，抽象类定义模板方法和通用步骤，子类继承并实现抽象方法，依托面向对象的封装、多态特性，实现逻辑清晰、易于维护的代码结构，适配大多数业务场景；

  • Go语言：遵循“组合优于继承”，通过接口定义可变步骤契约，结构体嵌入接口实现通用步骤，模板方法定义固定流程，代码极简高效，贴合高并发、高性能的后端开发需求；

  • 纯C语言：通过结构体+函数指针模拟面向对象特性，用函数指针实现可变步骤，用普通函数实现通用步骤，手动管理模板实例，底层可控性强，适配嵌入式、底层开发等资源受限场景，虽代码冗余，但能完整还原“固定骨架、灵活填充”的核心思想。

在工程实践中，使用模板方法模式需把握三个核心原则：一是判断业务场景是否具备“固定流程、细节可变”的特征，流程频繁变化的场景不适合使用；二是控制抽象类的复杂度，避免通用步骤与可变步骤耦合，确保职责单一；三是合理设计扩展点，抽象方法的定义需贴合业务扩展需求，避免过度设计抽象方法导致子类实现成本增加。

总体而言，模板方法模式是实现代码复用、规范流程、提升扩展性的高效工具，尤其在框架开发、业务流程规范、工具类封装等场景中价值显著。合理使用模板方法模式，可让代码结构更清晰、流程更规范、扩展更灵活，是每一位开发者必备的架构设计工具。