Go语言中策略模式的实现与应用

// PackageHandlingStrategy 定义了包处理策略的接口
// 任何实现此接口的类型都可作为具体的策略
type PackageHandlingStrategy interface {
    DoThis() // 执行第一步操作
    DoThat() // 执行第二步操作
}

// SomePackageHandlingStrategy 是 PackageHandlingStrategy 接口的一个具体实现
type SomePackageHandlingStrategy struct {
    // 可以包含策略所需的任何字段，例如配置、依赖等
    Name string
}

// DoThis 实现了 PackageHandlingStrategy 接口的 DoThis 方法
func (s *SomePackageHandlingStrategy) DoThis() {
    // 具体的“做这事”逻辑，例如处理特定格式的数据
    fmt.Printf("[%s] Strategy: Performing DoThis action.\n", s.Name)
}

// DoThat 实现了 PackageHandlingStrategy 接口的 DoThat 方法
func (s *SomePackageHandlingStrategy) DoThat() {
    // 具体的“做那事”逻辑，例如将数据发送到特定渠道
    fmt.Printf("[%s] Strategy: Performing DoThat action.\n", s.Name)
}

// AnotherPackageHandlingStrategy 是 PackageHandlingStrategy 接口的另一个具体实现
type AnotherPackageHandlingStrategy struct {
    // ...
    ID int
}

// DoThis 实现了 PackageHandlingStrategy 接口的 DoThis 方法
func (a *AnotherPackageHandlingStrategy) DoThis() {
    fmt.Printf("[ID:%d] Another Strategy: Executing DoThis.\n", a.ID)
}

// DoThat 实现了 PackageHandlingStrategy 接口的 DoThat 方法
func (a *AnotherPackageHandlingStrategy) DoThat() {
    fmt.Printf("[ID:%d] Another Strategy: Executing DoThat.\n", a.ID)
}

import "fmt"

// PackageWorker 是上下文结构体
type PackageWorker struct {
    PackageHandlingStrategy // 嵌入策略接口
    WorkerID int
}

// Work 方法通过嵌入的策略执行操作
func (w *PackageWorker) Work() {
    fmt.Printf("Worker %d: Starting work with embedded strategy.\n", w.WorkerID)
    w.DoThis() // 直接调用嵌入策略的方法
    w.DoThat()
    fmt.Printf("Worker %d: Work finished.\n", w.WorkerID)
}

func main() {
    // 创建一个具体策略
    strategyA := &SomePackageHandlingStrategy{Name: "StrategyA"}

    // 创建一个工作者，并嵌入策略A
    worker1 := &PackageWorker{
        PackageHandlingStrategy: strategyA,
        WorkerID: 1,
    }
    worker1.Work() // worker1将使用strategyA的DoThis和DoThat

    fmt.Println("---")

    // 创建另一个具体策略
    strategyB := &AnotherPackageHandlingStrategy{ID: 101}

    // 创建另一个工作者，并嵌入策略B
    worker2 := &PackageWorker{
        PackageHandlingStrategy: strategyB,
        WorkerID: 2,
    }
    worker2.Work() // worker2将使用strategyB的DoThis和DoThat
}

// PackageWorker 是上下文结构体，不直接持有策略
type PackageWorker struct {
    WorkerID int
}

// Work 方法接收一个 PackageHandlingStrategy 接口作为参数
func (w *PackageWorker) Work(s PackageHandlingStrategy) {
    fmt.Printf("Worker %d: Starting work with passed strategy.\n", w.WorkerID)
    s.DoThis() // 调用传入策略的方法
    s.DoThat()
    fmt.Printf("Worker %d: Work finished.\n", w.WorkerID)
}

func main() {
    // 创建一个工作者
    worker := &PackageWorker{WorkerID: 3}

    // 创建不同的具体策略
    strategyC := &SomePackageHandlingStrategy{Name: "StrategyC"}
    strategyD := &AnotherPackageHandlingStrategy{ID: 202}

    // 动态传递策略给Work方法
    worker.Work(strategyC) // worker使用strategyC
    fmt.Println("---")
    worker.Work(strategyD) // worker切换到strategyD
}