Golang如何实现模板方法模式固定执行顺序

Go语言通过接口与结构体组合实现模板方法模式，固定算法执行顺序。定义Task接口声明步骤，Template结构体包含task实例并实现Execute方法按Step1→Step2→Step3顺序调用。具体任务如ConcreteTaskA、ConcreteTaskB实现Task接口自定义各步逻辑，客户端通过注入不同task实现扩展行为，整体流程由模板控制不变。此外可采用函数字段的灵活方式，FlexibleTemplate直接持有step1/step2/step3函数变量，Execute依次执行，适用于轻量级场景。两种方式均无需继承，利用组合与接口达成模板模式核心——复用流程、隔离变化。

在 Go 语言中实现模板方法模式以固定执行顺序，核心是利用接口和结构体组合来定义算法骨架，子类（或具体实现）可以重写某些步骤而不改变整体流程。Go 没有继承，但可以通过嵌入结构体和接口回调模拟这一行为。

定义模板接口和抽象结构体

先定义一个接口描述算法的各个步骤，再用一个基础结构体实现主流程（即模板方法），该方法调用具体的步骤方法。

示例：

import "fmt"

立即学习“go语言免费学习笔记（深入）”；

// 定义流程步骤接口 type Task interface { Step1() Step2() Step3() }

// 模板结构体，包含执行模板方法 type Template struct { task Task // 组合具体任务实现 }

// 固定执行顺序的模板方法 func (t *Template) Execute() { t.task.Step1() t.task.Step2() t.task.Step3() }

实现具体任务
创建具体结构体实现 Task 接口，每个步骤自定义逻辑，但执行顺序由模板控制。

```go
type ConcreteTaskA struct{}

func (c *ConcreteTaskA) Step1() { fmt.Println("Task A: Step 1") }
func (c *ConcreteTaskA) Step2() { fmt.Println("Task A: Step 2") }
func (c *ConcreteTaskA) Step3() { fmt.Println("Task A: Step 3") }

type ConcreteTaskB struct{}

func (c *ConcreteTaskB) Step1() { fmt.Println("Task B: Step 1") }
func (c *ConcreteTaskB) Step2() { fmt.Println("Task B: Step 2") }
func (c *ConcreteTaskB) Step3() { fmt.Println("Task B: Step 3") }

使用模板方法

客户端代码只需传入具体实现，调用模板的 Execute 方法即可按固定顺序执行。

Cutout.Pro

AI驱动的视觉设计平台

下载

func main() {
    taskA := &ConcreteTaskA{}
    taskB := &ConcreteTaskB{}

    template := &Template{task: taskA}
    fmt.Println("Executing Task A:")
    template.Execute()

    fmt.Println("\nExecuting Task B:")
    template.task = taskB
    template.Execute()
}

输出结果：

Executing Task A:
Task A: Step 1
Task A: Step 2
Task A: Step 3
Executing Task B:
Task B: Step 1
Task B: Step 2
Task B: Step 3

这样就实现了算法骨架的复用和执行顺序的固化。即使不同任务实现各自的步骤，整体流程不变。

更灵活的做法：函数式模板

如果步骤较为简单，也可以直接用函数字段代替接口，减少类型定义。

type FlexibleTemplate struct {
    step1 func()
    step2 func()
    step3 func()
}

func (t *FlexibleTemplate) Execute() {
    t.step1()
    t.step2()
    t.step3()
}

// 使用示例
func main() {
    t := &FlexibleTemplate{
        step1: func() { fmt.Println("Init") },
        step2: func() { fmt.Println("Process") },
        step3: func() { fmt.Println("Cleanup") },
    }
    t.Execute()
}

这种方式更轻量，适合小型流程控制。

基本上就这些。Go 虽无继承，但通过接口组合和结构体嵌套，完全可以优雅实现模板方法模式，确保执行顺序不被破坏。