Go语言通过接口与结构体组合实现模板方法模式，固定算法执行顺序。定义Task接口声明步骤，Template结构体包含task实例并实现Execute方法按Step1→Step2→Step3顺序调用。具体任务如ConcreteTaskA、ConcreteTaskB实现Task接口自定义各步逻辑，客户端通过注入不同task实现扩展行为，整体流程由模板控制不变。此外可采用函数字段的灵活方式，FlexibleTemplate直接持有step1/step2/step3函数变量，Execute依次执行，适用于轻量级场景。两种方式均无需继承，利用组合与接口达成模板模式核心——复用流程、隔离变化。
在 Go 语言中实现模板方法模式以固定执行顺序，核心是利用接口和结构体组合来定义算法骨架，子类（或具体实现）可以重写某些步骤而不改变整体流程。Go 没有继承，但可以通过嵌入结构体和接口回调模拟这一行为。
定义模板接口和抽象结构体
先定义一个接口描述算法的各个步骤，再用一个基础结构体实现主流程（即模板方法），该方法调用具体的步骤方法。
注意：Go 中没有抽象方法，但我们可以通过结构体字段赋值为函数，或使用接口+默认实现的方式来模拟。示例：
```go package mainimport "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() }
<H3>实现具体任务</H3>
<p>创建具体结构体实现 Task 接口，每个步骤自定义逻辑，但执行顺序由模板控制。</p><div class="aritcle_card flexRow">
<div class="artcardd flexRow">
<a class="aritcle_card_img" href="/xiazai/skill8661" title="Golang Uber Dig"><img
src="https://img.php.cn/upload/skill/000/000/081/179215391842073.jpg" alt="Golang Uber Dig" ></a>
<div class="aritcle_card_info flexColumn">
<a href="/xiazai/skill8661" title="Golang Uber Dig">Golang Uber Dig</a>
<p>使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等</p>
</div>
<a href="/xiazai/skill8661" title="Golang Uber Dig" class="aritcle_card_btn flexRow flexcenter"><b></b><span>下载</span> </a>
</div>
</div>
```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 方法即可按固定顺序执行。
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 <p>Executing Task B: Task B: Step 1 Task B: Step 2 Task B: Step 3</p>
这样就实现了算法骨架的复用和执行顺序的固化。即使不同任务实现各自的步骤，整体流程不变。
更灵活的做法：函数式模板
如果步骤较为简单，也可以直接用函数字段代替接口，减少类型定义。
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 虽无继承，但通过接口组合和结构体嵌套，完全可以优雅实现模板方法模式，确保执行顺序不被破坏。
