策略模式在Go中通过接口定义统一行为契约、结构体实现具体算法，上下文动态切换策略，支持无状态或带依赖的策略实现。
策略模式的核心是把一组算法或行为封装成独立的类，让它们可以互相替换。Golang 没有传统面向对象的继承和接口实现语法，但通过接口（interface）和结构体组合，能非常自然地实现策略模式——关键在于定义统一的行为契约，再由不同结构体提供具体实现。
定义策略接口
先抽象出“可执行的策略”行为，比如一个通用的 Execute 方法：
// Strategy 定义所有策略必须实现的行为
type Strategy interface {
Execute(data interface{}) string
}
这个接口不绑定具体逻辑，只约定“怎么被调用”。后续任何结构体只要实现了 Execute，就自动成为一种策略。
实现多个具体策略
每个策略对应一个结构体，各自封装不同的算法逻辑。例如处理文本的三种方式：
立即学习“go语言免费学习笔记（深入）”；
type UpperCaseStrategy struct{}
func (u UpperCaseStrategy) Execute(data interface{}) string {
if s, ok := data.(string); ok {
return strings.ToUpper(s)
}
return ""
}
type ReverseStrategy struct{}
func (r ReverseStrategy) Execute(data interface{}) string {
if s, ok := data.(string); ok {
return reverseString(s)
}
return ""
}
type CountLengthStrategy struct{}
func (c CountLengthStrategy) Execute(data interface{}) string {
if s, ok := data.(string); ok {
return fmt.Sprintf("length: %d", len(s))
}
return "invalid input"
}
注意：策略结构体可以是空结构体（如 UpperCaseStrategy{}），因为行为全靠方法实现，无需保存状态。
构建上下文并动态切换策略
上下文（Context）持有当前策略，并提供设置和执行入口。它不关心策略内部怎么实现，只负责委托调用：
type Context struct {
strategy Strategy
}
func NewContext(s Strategy) *Context {
return &Context{strategy: s}
}
func (c *Context) SetStrategy(s Strategy) {
c.strategy = s
}
func (c *Context) Execute(data interface{}) string {
if c.strategy == nil {
return "no strategy set"
}
return c.strategy.Execute(data)
}
使用时可随时更换策略，比如根据配置、用户输入或运行时条件：
-
按命令行参数选策略：
if flag.Arg(0) == "upper" { ctx.SetStrategy(UpperCaseStrategy{}) } -
按 HTTP 请求头切换：
if r.Header.Get("X-Strategy") == "reverse" { ctx.SetStrategy(ReverseStrategy{}) } - 按数据特征自动选择：比如字符串长度 > 100 时用压缩策略，否则用原样输出
进阶：支持带状态或依赖的策略
如果某个策略需要外部依赖（如日志器、数据库连接），可在结构体中嵌入字段：
type LoggingStrategy struct {
logger *log.Logger
}
func (l LoggingStrategy) Execute(data interface{}) string {
l.logger.Println("executing logging strategy")
return "logged"
}
创建时传入依赖：ctx.SetStrategy(LoggingStrategy{logger: log.Default()})。这比全局变量更清晰，也利于单元测试。
