Go语言策略模式实战：实现算法动态切换与解耦

温以宁

发布时间：2026-10-16 | 4人浏览过

原创

在Go语言开发中，当面对同一类型问题存在多种处理方式时，传统的if-else或switch结构往往会导致代码臃肿且难以维护。策略模式通过将一系列可互相替换的算法封装成独立的对象，实现了业务逻辑与算法实现的解耦，是提升Go代码可读性和可扩展性的关键手段。

概述

策略模式的核心定义是：定义一系列算法，将每个算法封装起来，并使它们可以相互替换。这种设计模式使得算法的变化独立于使用它的客户端，从而让系统更加灵活。

为什么需要引入策略模式？

以“用户出行”为例，如果未使用策略模式，通常会在一个函数中使用 switch 语句来处理不同的场景（如飞机、火车、走路）：

package main
import "fmt"

type User struct {
	Name string
}

// 原始写法：所有逻辑耦合在一个方法中
func (this User) travel(t string) {
	switch t {
	case "飞机":
		fmt.Printf("%s,飞机出行\n", this.Name)
	case "火车":
		fmt.Printf("%s,火车出行\n", this.Name)
	case "走路":
		fmt.Printf("%s,走路出行\n", this.Name)
	default:
		fmt.Println("你未选择了出行方式吗")
	}
}

func main() {
	User{"张三"}.travel("飞机")
	User{"张三"}.travel("火车")
	User{"张三"}.travel("走路")
	User{"张三"}.travel("")
}

该写法的缺点非常明显：
1. 随着业务增加，switch 分支会越来越多，导致代码复杂。
2. 违反了面向对象设计中的“开闭原则”，若要新增一种出行方式，必须修改现有源码。
3. 复用性差，无法单独提取或重用某个特定的算法逻辑。

在现实场景中，类似的逻辑无处不在：比如视频平台的会员权益（普通/超级/金牌对应不同折扣和皮肤），或者游戏中的不同技能组合。解决这类问题的标准做法就是引入策略模式。

策略模式的三要素

编号	角色	描述
1	环境(Context)角色	持有一个Strategy的引用，负责调用具体的策略算法。
2	抽象策略(Strategy)角色	这是一个抽象角色（在Go中通常由接口实现），声明了所有具体策略需要实现的公共方法。
3	具体策略(ConcreteStrategy)角色	包装了相关的算法或行为，实现抽象策略定义的接口。

Go语言策略模式实战

下面演示如何使用Go语言的接口特性来实现上述的“出行策略”。我们将把“飞机”、“火车”、“走路”分别抽离为独立的策略类。

package main
import "fmt"

/* 1. 抽象策略接口 */
type ITravel interface {
	Travel()
}

/* 2. 具体策略类 */
/* 飞机出行 */
type Aircraft struct{}
func (this Aircraft) Travel() {
	fmt.Println("选择乘坐飞机出行")
}

/* 火车出行 */
type Train struct{}
func (this Train) Travel() {
	fmt.Println("选择乘坐火车出行")
}

/* 走路出行 */
type Walk struct{}
func (this Walk) Travel() {
	fmt.Println("选择步行出行")
}

/* 3. 环境类 */
type User struct {
	Name    string
	ITravel ITravel // 持有策略接口的引用
}

// 行为委托给当前的策略执行
func (this User) travel() {
	fmt.Printf("%s的出行方式是：", this.Name)
	this.ITravel.Travel()
}

func main() {
	// 使用飞机策略
	user := &User{Name: "张三", ITravel: Aircraft{}}
	user.travel()

	// 使用火车策略（实例化并赋值）
	user = &User{Name: "李四", ITravel: new(Train)}
	user.travel()

	// 使用走路策略
	user = &User{Name: "王五", ITravel: &Walk{}}
	user.travel()
}