Golang策略模式与接口结合动态实现

if-else if

DataProcessor

package main

import (
    "fmt"
    "strconv"
)

// Strategy 接口定义了所有具体策略必须实现的方法
type DataProcessingStrategy interface {
    Process(data string) (string, error)
}

// Concrete Strategy A: 处理数字字符串
type NumberProcessor struct{}

func (np *NumberProcessor) Process(data string) (string, error) {
    num, err := strconv.Atoi(data)
    if err != nil {
        return "", fmt.Errorf("NumberProcessor: invalid number format: %w", err)
    }
    return fmt.Sprintf("Processed number: %d (doubled: %d)", num, num*2), nil
}

// Concrete Strategy B: 处理文本字符串
type TextProcessor struct{}

func (tp *TextProcessor) Process(data string) (string, error) {
    return fmt.Sprintf("Processed text: '%s' (uppercase: %s)", data, data), nil
}

// Context 结构体，持有Strategy接口的引用
type Context struct {
    strategy DataProcessingStrategy
}

// SetStrategy 方法允许在运行时更改策略
func (c *Context) SetStrategy(s DataProcessingStrategy) {
    c.strategy = s
}

// ExecuteStrategy 方法委托给当前策略执行
func (c *Context) ExecuteStrategy(data string) (string, error) {
    if c.strategy == nil {
        return "", fmt.Errorf("no strategy set in context")
    }
    return c.strategy.Process(data)
}

func main() {
    context := &Context{}

    // 使用数字处理器
    context.SetStrategy(&NumberProcessor{})
    result, err := context.ExecuteStrategy("123")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println(result) // Output: Processed number: 123 (doubled: 246)
    }

    // 切换到文本处理器
    context.SetStrategy(&TextProcessor{})
    result, err = context.ExecuteStrategy("hello world")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println(result) // Output: Processed text: 'hello world' (uppercase: HELLO WORLD)
    }

    // 尝试用数字处理器处理非数字
    context.SetStrategy(&NumberProcessor{})
    result, err = context.ExecuteStrategy("not a number")
    if err != nil {
        fmt.Println("Error:", err) // Output: Error: NumberProcessor: invalid number format: strconv.Atoi: parsing "not a number": invalid syntax
    } else {
        fmt.Println(result)
    }
}

DataProcessingStrategy

Context

switch

if-else if

implements

// StrategyFactory 根据类型返回对应的策略实例
func StrategyFactory(strategyType string) (DataProcessingStrategy, error) {
    switch strategyType {
    case "number":
        return &NumberProcessor{}, nil
    case "text":
        return &TextProcessor{}, nil
    // 以后添加新的策略，只需在这里增加case
    default:
        return nil, fmt.Errorf("unknown strategy type: %s", strategyType)
    }
}

func main() {
    context := &Context{}

    // 动态选择策略
    numStrategy, err := StrategyFactory("number")
    if err != nil {
        fmt.Println("Error getting strategy:", err)
        return
    }
    context.SetStrategy(numStrategy)
    fmt.Println(context.ExecuteStrategy("456"))

    textStrategy, err := StrategyFactory("text")
    if err != nil {
        fmt.Println("Error getting strategy:", err)
        return
    }
    context.SetStrategy(textStrategy)
    fmt.Println(context.ExecuteStrategy("golang is awesome"))
}

map

var strategies = make(map[string]func() DataProcessingStrategy)

// RegisterStrategy 注册策略
func RegisterStrategy(name string, constructor func() DataProcessingStrategy) {
    strategies[name] = constructor
}

// GetStrategy 获取策略
func GetStrategy(name string) (DataProcessingStrategy, error) {
    constructor, ok := strategies[name]
    if !ok {
        return nil, fmt.Errorf("strategy '%s' not registered", name)
    }
    return constructor(), nil
}

func init() {
    // 在程序启动时注册所有策略
    RegisterStrategy("number", func() DataProcessingStrategy { return &NumberProcessor{} })
    RegisterStrategy("text", func() DataProcessingStrategy { return &TextProcessor{} })
}

func main() {
    context := &Context{}

    // 通过注册获取策略
    numStrategy, err := GetStrategy("number")
    if err != nil {
        fmt.Println("Error getting strategy:", err)
        return
    }
    context.SetStrategy(numStrategy)
    fmt.Println(context.ExecuteStrategy("789"))
}

RegisterStrategy