Go语言中策略模式的实践：利用接口实现灵活的行为切换

package main

import "fmt"

// PackageHandlingStrategy 定义了数据包处理策略的接口
type PackageHandlingStrategy interface {
    DoThis() // 执行某种处理操作
    DoThat() // 执行另一种处理操作
}

// SomePackageHandlingStrategy 是一个具体的策略实现
type SomePackageHandlingStrategy struct {
    // 可以包含策略所需的任何状态或配置
    name string
}

// NewSomePackageHandlingStrategy 构造函数
func NewSomePackageHandlingStrategy(name string) *SomePackageHandlingStrategy {
    return &SomePackageHandlingStrategy{name: name}
}

// DoThis 实现了 PackageHandlingStrategy 接口的 DoThis 方法
func (s *SomePackageHandlingStrategy) DoThis() {
    fmt.Printf("[%s] 执行 'DoThis' 操作\n", s.name)
    // ... 具体的数据处理逻辑 ...
}

// DoThat 实现了 PackageHandlingStrategy 接口的 DoThat 方法
func (s *SomePackageHandlingStrategy) DoThat() {
    fmt.Printf("[%s] 执行 'DoThat' 操作\n", s.name)
    // ... 具体的数据处理逻辑 ...
}

// AnotherPackageHandlingStrategy 是另一个具体的策略实现
type AnotherPackageHandlingStrategy struct {
    // 可以包含策略所需的任何状态或配置
    id int
}

// NewAnotherPackageHandlingStrategy 构造函数
func NewAnotherPackageHandlingStrategy(id int) *AnotherPackageHandlingStrategy {
    return &AnotherPackageHandlingStrategy{id: id}
}

// DoThis 实现了 PackageHandlingStrategy 接口的 DoThis 方法
func (a *AnotherPackageHandlingStrategy) DoThis() {
    fmt.Printf("[Strategy ID: %d] 执行 'DoThis' 操作 (另一种方式)\n", a.id)
    // ... 不同的数据处理逻辑 ...
}

// DoThat 实现了 PackageHandlingStrategy 接口的 DoThat 方法
func (a *AnotherPackageHandlingStrategy) DoThat() {
    fmt.Printf("[Strategy ID: %d] 执行 'DoThat' 操作 (另一种方式)\n", a.id)
    // ... 不同的数据处理逻辑 ...
}

// PackageWorker 是上下文结构体，通过嵌入策略来使用它
type PackageWorker struct {
    PackageHandlingStrategy // 嵌入策略接口
    workerID                string
}

// NewPackageWorkerWithEmbedding 构造函数
func NewPackageWorkerWithEmbedding(id string, strategy PackageHandlingStrategy) *PackageWorker {
    return &PackageWorker{
        PackageHandlingStrategy: strategy, // 初始化时注入具体策略
        workerID:                id,
    }
}

// Work 方法直接调用嵌入策略的方法
func (w *PackageWorker) Work() {
    fmt.Printf("Worker [%s] 开始工作...\n", w.workerID)
    w.DoThis() // 直接调用嵌入策略的方法
    w.DoThat() // 直接调用嵌入策略的方法
    fmt.Printf("Worker [%s] 完成工作。\n\n", w.workerID)
}

// PackageProcessor 是另一个上下文结构体，通过方法参数传递策略
type PackageProcessor struct {
    processorName string
}

// NewPackageProcessorWithParam 构造函数
func NewPackageProcessorWithParam(name string) *PackageProcessor {
    return &PackageProcessor{processorName: name}
}

// Process 方法接收一个策略作为参数
func (p *PackageProcessor) Process(strategy PackageHandlingStrategy) {
    fmt.Printf("Processor [%s] 开始处理 (使用动态策略)...\n", p.processorName)
    strategy.DoThis() // 调用传入策略的方法
    strategy.DoThat() // 调用传入策略的方法
    fmt.Printf("Processor [%s] 完成处理。\n\n", p.processorName)
}

func main() {
    fmt.Println("--- 策略模式示例 ---")

    // 实例化具体的策略
    strategyA := NewSomePackageHandlingStrategy("Strategy Alpha")
    strategyB := NewAnotherPackageHandlingStrategy(101)

    // 使用嵌入策略的上下文
    fmt.Println("使用嵌入策略的 PackageWorker:")
    worker1 := NewPackageWorkerWithEmbedding("Worker-001", strategyA)
    worker1.Work()

    worker2 := NewPackageWorkerWithEmbedding("Worker-002", strategyB)
    worker2.Work() // 切换策略只需在初始化时传入不同的策略实例

    // 使用方法参数传递策略的上下文
    fmt.Println("使用方法参数传递策略的 PackageProcessor:")
    processor := NewPackageProcessorWithParam("MainProcessor")

    processor.Process(strategyA) // 动态传入策略A
    processor.Process(strategyB) // 动态传入策略B

    // 甚至可以在运行时创建匿名策略
    processor.Process(&SomePackageHandlingStrategy{name: "Anonymous Strategy"})
}

--- 策略模式示例 ---
使用嵌入策略的 PackageWorker:
Worker [Worker-001] 开始工作...
[Strategy Alpha] 执行 'DoThis' 操作
[Strategy Alpha] 执行 'DoThat' 操作
Worker [Worker-001] 完成工作。

Worker [Worker-002] 开始工作...
[Strategy ID: 101] 执行 'DoThis' 操作 (另一种方式)
[Strategy ID: 101] 执行 'DoThat' 操作 (另一种方式)
Worker [Worker-002] 完成工作。

使用方法参数传递策略的 PackageProcessor:
Processor [MainProcessor] 开始处理 (使用动态策略)...
[Strategy Alpha] 执行 'DoThis' 操作
[Strategy Alpha] 执行 'DoThat' 操作
Processor [MainProcessor] 完成处理。

Processor [MainProcessor] 开始处理 (使用动态策略)...
[Strategy ID: 101] 执行 'DoThis' 操作 (另一种方式)
[Strategy ID: 101] 执行 'DoThat' 操作 (另一种方式)
Processor [MainProcessor] 完成处理。

Processor [MainProcessor] 开始处理 (使用动态策略)...
[Anonymous Strategy] 执行 'DoThis' 操作
[Anonymous Strategy] 执行 'DoThat' 操作
Processor [MainProcessor] 完成处理。