策略模式通过定义统一接口将不同算法封装，使算法可互换且不影响客户端；在Go中以SortStrategy接口为例，实现快速排序、归并排序等具体策略，由上下文动态调用，提升代码灵活性与可维护性。
在 Golang 项目中，当面对多种相似但行为不同的业务逻辑时，使用 策略模式（Strategy Pattern） 能有效解耦代码、提升可维护性。特别是在需要动态切换算法或处理方式的场景下，比如支付方式选择、排序算法替换、数据导出格式切换等，策略模式尤为实用。
什么是策略模式？
策略模式定义了一系列算法或行为，并将每个算法封装到独立的结构体中，使它们可以互相替换，且算法的变化不会影响使用它的客户端。核心由三部分组成：
- 策略接口（Strategy Interface）：定义所有支持算法的公共操作方法。
- 具体策略（Concrete Strategies）：实现策略接口的具体逻辑。
- 上下文（Context）：持有策略接口引用，运行时决定使用哪个具体策略。
实际应用场景示例：不同排序策略
假设我们需要对一组整数进行排序，但允许用户在运行时选择使用快速排序、归并排序或冒泡排序。我们可以用策略模式来实现灵活切换。
定义策略接口先定义一个统一的排序策略接口：
立即学习“go语言免费学习笔记（深入）”；
type SortStrategy interface {
Sort([]int) []int
}
实现具体策略
编写几种具体的排序算法实现：
type QuickSort struct{}
func (q *QuickSort) Sort(data []int) []int {
if len(data) <= 1 {
return data
}
pivot := data[0]
var less, greater []int
for _, v := range data[1:] {
if v <= pivot {
less = append(less, v)
} else {
greater = append(greater, v)
}
}
sorted := make([]int, 0)
sorted = append(sorted, q.Sort(less)...)
sorted = append(sorted, pivot)
sorted = append(sorted, q.Sort(greater)...)
return sorted
}
type MergeSort struct{}
func (m *MergeSort) Sort(data []int) []int {
if len(data) <= 1 {
return data
}
mid := len(data) / 2
left := m.Sort(data[:mid])
right := m.Sort(data[mid:])
return merge(left, right)
}
func merge(left, right []int) []int {
result := make([]int, 0, len(left)+len(right))
i, j := 0, 0
for i < len(left) && j < len(right) {
if left[i] <= right[j] {
result = append(result, left[i])
i++
} else {
result = append(result, right[j])
j++
}
}
result = append(result, left[i:]...)
result = append(result, right[j:]...)
return result
}
type BubbleSort struct{}
func (b *BubbleSort) Sort(data []int) []int {
sorted := make([]int, len(data))
copy(sorted, data)
n := len(sorted)
for i := 0; i < n-1; i++ {
for j := 0; j < n-i-1; j++ {
if sorted[j] > sorted[j+1] {
sorted[j], sorted[j+1] = sorted[j+1], sorted[j]
}
}
}
return sorted
}
创建上下文管理策略切换
上下文结构体负责持有当前策略，并提供切换和执行能力：
type Sorter struct {
strategy SortStrategy
}
func (s *Sorter) SetStrategy(strategy SortStrategy) {
s.strategy = strategy
}
func (s *Sorter) Execute(data []int) []int {
if s.strategy == nil {
panic("未设置排序策略")
}
return s.strategy.Sort(data)
}
使用示例
在主程序中动态切换排序策略：
func main() {
data := []int{64, 34, 25, 12, 22, 11, 90}
sorter := &Sorter{}
// 使用快速排序
sorter.SetStrategy(&QuickSort{})
fmt.Println("快速排序:", sorter.Execute(data))
// 切换为归并排序
sorter.SetStrategy(&MergeSort{})
fmt.Println("归并排序:", sorter.Execute(data))
// 切换为冒泡排序
sorter.SetStrategy(&BubbleSort{})
fmt.Println("冒泡排序:", sorter.Execute(data))
}
扩展：通过名称注册和获取策略
如果策略较多，可以通过映射注册，按名称调用，提高灵活性：
var strategies = map[string]SortStrategy{
"quick": &QuickSort{},
"merge": &MergeSort{},
"bubble": &BubbleSort{},
}
func GetStrategy(name string) (SortStrategy, error) {
strategy, exists := strategies[name]
if !exists {
return nil, fmt.Errorf("不支持的排序策略: %s", name)
}
return strategy, nil
}
这样就可以从配置或参数中读取策略名，实现动态绑定：
strategy, err := GetStrategy("merge")
if err != nil {
log.Fatal(err)
}
sorter.SetStrategy(strategy)
总结与优势
通过策略模式，Golang 实现算法切换变得清晰而灵活。主要优点包括：
- 新增算法无需修改原有代码，符合开闭原则。
- 策略之间完全解耦，便于单元测试。
- 运行时可动态切换，适应多变业务需求。
- 结合工厂或注册机制，能实现更高级的配置驱动行为。
基本上就这些。只要抓住“接口定义行为，结构体实现细节，上下文控制切换”这个核心思路，就能在实际项目中轻松应用策略模式。
