Go语言中实现策略模式：灵活处理多源数据与格式转换

package main

import "fmt"

// PackageHandlingStrategy 定义了所有数据包处理策略必须实现的行为
type PackageHandlingStrategy interface {
    DoThis() // 执行某个操作
    DoThat() // 执行另一个操作
}

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

// NewSomePackageHandlingStrategy 创建并返回一个 SomePackageHandlingStrategy 实例
func NewSomePackageHandlingStrategy(name string) *SomePackageHandlingStrategy {
    return &SomePackageHandlingStrategy{name: name}
}

// DoThis 实现了 SomePackageHandlingStrategy 的第一个行为
func (s *SomePackageHandlingStrategy) DoThis() {
    fmt.Printf("[%s] SomePackageHandlingStrategy: Performing DoThis action (e.g., parsing specific format).\n", s.name)
}

// DoThat 实现了 SomePackageHandlingStrategy 的第二个行为
func (s *SomePackageHandlingStrategy) DoThat() {
    fmt.Printf("[%s] SomePackageHandlingStrategy: Performing DoThat action (e.g., writing to a specific target).\n", s.name)
}

// AnotherPackageHandlingStrategy 是另一个具体的策略实现
type AnotherPackageHandlingStrategy struct {
    // 同样可以有自己的配置或状态
    id int
}

// NewAnotherPackageHandlingStrategy 创建并返回一个 AnotherPackageHandlingStrategy 实例
func NewAnotherPackageHandlingStrategy(id int) *AnotherPackageHandlingStrategy {
    return &AnotherPackageHandlingStrategy{id: id}
}

// DoThis 实现了 AnotherPackageHandlingStrategy 的第一个行为
func (s *AnotherPackageHandlingStrategy) DoThis() {
    fmt.Printf("[ID:%d] AnotherPackageHandlingStrategy: Performing DoThis action differently (e.g., translating another format).\n", s.id)
}

// DoThat 实现了 AnotherPackageHandlingStrategy 的第二个行为
func (s *AnotherPackageHandlingStrategy) DoThat() {
    fmt.Printf("[ID:%d] AnotherPackageHandlingStrategy: Performing DoThat action differently (e.g., writing to a different target).\n", s.id)
}

// PackageWorker 是一个上下文（Context），它通过方法参数接收策略
type PackageWorker struct {
    // Worker本身不持有具体策略，而是在执行时接收
}

// Work 方法接收一个 PackageHandlingStrategy 接口作为参数，并调用其方法
func (w *PackageWorker) Work(s PackageHandlingStrategy) {
    fmt.Println("\n--- Worker with passed strategy starts working ---")
    s.DoThis() // 调用传入策略的方法
    s.DoThat()
    fmt.Println("--- Worker finished ---")
}

// PackageWorkerWithInjectedStrategy 是一个上下文（Context），它通过结构体字段持有策略
type PackageWorkerWithInjectedStrategy struct {
    strategy PackageHandlingStrategy // 持有策略接口
}

// NewPackageWorkerWithInjectedStrategy 是一个构造函数，用于创建并初始化 Worker
func NewPackageWorkerWithInjectedStrategy(s PackageHandlingStrategy) *PackageWorkerWithInjectedStrategy {
    return &PackageWorkerWithInjectedStrategy{strategy: s}
}

// Work 方法直接调用内部持有的策略实例的方法
func (w *PackageWorkerWithInjectedStrategy) Work() {
    fmt.Println("\n--- Worker with injected strategy starts working ---")
    w.strategy.DoThis()
    w.strategy.DoThat()
    fmt.Println("--- Worker finished ---")
}

func main() {
    // 创建具体的策略实例
    strategy1 := NewSomePackageHandlingStrategy("StrategyA")
    strategy2 := NewAnotherPackageHandlingStrategy(101)

    // --- 使用通过方法参数传递策略的 Worker ---
    worker := &PackageWorker{}

    fmt.Println("Worker uses Strategy A:")
    worker.Work(strategy1) // 传入第一个策略

    fmt.Println("Worker uses Strategy B:")
    worker.Work(strategy2) // 运行时切换到第二个策略

    // --- 使用通过结构体字段注入策略的 Worker ---
    fmt.Println("\n--- Demonstrating injected strategy ---")

    // 初始化 Worker 时注入 Strategy A
    workerInjected1 := NewPackageWorkerWithInjectedStrategy(strategy1)
    workerInjected1.Work()

    // 初始化 Worker 时注入 Strategy B
    workerInjected2 := NewPackageWorkerWithInjectedStrategy(strategy2)
    workerInjected2.Work()

    // 假设我们有一个需要动态切换策略的场景
    // 我们可以通过重新创建 Worker 或提供 SetStrategy 方法来实现
    // 例如，如果需要切换 workerInjected1 的策略，需要这样做：
    fmt.Println("\n--- Changing injected strategy example (re-injection) ---")
    workerInjected1 = NewPackageWorkerWithInjectedStrategy(strategy2) // 重新注入策略
    workerInjected1.Work()
}