Go中模板方法模式用组合+函数字段或接口实现：结构体封装固定流程（如Run/Execute），可变步骤设为func字段或接口方法，通过注入实现控制反转。
模板方法模式在 Go 里没有抽象类，怎么写
Go 没有继承和抽象类，所以不能像 Java 那样定义 abstract class 和 final method。但模板方法的核心是「封装不变逻辑，延迟到子类实现可变部分」，这完全可以用 Go 的组合 + 接口 + 函数字段来模拟。
关键不是“复刻语法”，而是守住行为契约：主流程固定（比如 Execute()），其中调用若干钩子函数（如 setup()、process()、teardown()），这些钩子由使用者提供。
- 用结构体封装流程骨架，把可变步骤声明为
func()或接口方法字段 - 对外暴露一个不可覆盖的入口方法（例如
Run()） - 让调用方通过构造函数或配置函数注入具体行为
用函数字段实现最轻量的模板方法
这是最符合 Go 习惯的做法：不引入接口，直接把步骤定义成结构体字段，运行时传入闭包或普通函数。
type Processor struct {
Setup func()
Process func() error
Teardown func()
}
func (p *Processor) Run() error {
if p.Setup != nil {
p.Setup()
}
if err := p.Process(); err != nil {
return err
}
if p.Teardown != nil {
p.Teardown()
}
return nil
}
使用时只需填充字段：
立即学习“go语言免费学习笔记（深入）”；
p := &Processor{
Setup: func() { log.Println("connecting db...") },
Process: func() error {
log.Println("fetching data...")
return nil
},
Teardown: func() { log.Println("closing connection") },
}
p.Run()
- 零接口、零类型定义，适合一次性流程或简单工具
- 注意：字段为
nil时要判空，否则 panic - 如果某步必须实现，就改用接口字段并要求非空校验
用接口+嵌入实现可复用的模板骨架
当多个流程共享相似结构（比如 HTTP handler 链、CLI 命令生命周期），更适合定义接口并让具体类型实现它。
type StepRunner interface {
Setup() error
Process() error
Teardown() error
}
type TemplateRunner struct {
StepRunner
}
func (t *TemplateRunner) Execute() error {
if err := t.StepRunner.Setup(); err != nil {
return err
}
if err := t.StepRunner.Process(); err != nil {
return err
}
return t.StepRunner.Teardown()
}
使用者只需实现接口：
type Importer struct{}
func (i *Importer) Setup() error { return connectDB() }
func (i *Importer) Process() error { return runImport() }
func (i *Importer) Teardown() error { return closeDB() }
runner := &TemplateRunner{StepRunner: &Importer{}}
runner.Execute()
- 接口明确契约，利于测试和 mock
-
TemplateRunner可被复用，甚至加日志、超时、重试等横切逻辑 - 别漏掉对
StepRunner字段的非空检查，否则nil实现会 panic
为什么不用 embed 匿名结构体来“继承”模板
有人尝试用匿名字段嵌入一个含 Run() 方法的结构体，期望“子类自动获得流程”，但这样无法真正约束子类型必须实现钩子——Go 不支持虚函数调用，嵌入后调用的仍是父字段的方法，不是子类型的重写版本。
典型错误写法：
type Base struct{}
func (b *Base) Run() { b.step() } // 这里 b.step() 是 Base 自己的方法，不是子类型的
type Child struct {
Base // ❌ 无法覆盖 step()
}
- Go 的嵌入是**委托**，不是继承；方法调用静态绑定，不会动态分发
- 想实现多态，必须靠接口变量或函数字段，绕不开显式组合
- 强行用反射或 unsafe 替换方法指针，属于反模式，破坏可读性和维护性
真正容易被忽略的是：模板方法的价值不在“结构复用”，而在**控制反转（IoC）**——把流程控制权交给骨架，而不是让每个实现都重复写 try/finally 或 defer 链。只要守住这个边界，用函数还是接口，只是权衡清晰度与扩展性而已。
