Golang策略模式优化算法选择方法

type CompressionStrategy interface {
    Compress(data []byte) ([]byte, error)
    Decompress(data []byte) ([]byte, error)
}

type GzipStrategy struct{}

func (g *GzipStrategy) Compress(data []byte) ([]byte, error) {
    var buf bytes.Buffer
    writer := gzip.NewWriter(&buf)
    _, err := writer.Write(data)
    if err != nil {
        return nil, err
    }
    writer.Close()
    return buf.Bytes(), nil
}

func (g *GzipStrategy) Decompress(data []byte) ([]byte, error) {
    reader, err := gzip.NewReader(bytes.NewReader(data))
    if err != nil {
        return nil, err
    }
    defer reader.Close()
    return io.ReadAll(reader)
}

type Compressor struct {
    strategy CompressionStrategy
}

func (c *Compressor) SetStrategy(s CompressionStrategy) {
    c.strategy = s
}

func (c *Compressor) Process(data []byte) ([]byte, error) {
    if c.strategy == nil {
        return nil, fmt.Errorf("no strategy set")
    }
    return c.strategy.Compress(data)
}

compressor := &Compressor{}
if useGzip {
    compressor.SetStrategy(&GzipStrategy{})
} else {
    compressor.SetStrategy(&ZstdStrategy{})
}
result, _ := compressor.Process(inputData)

func NewCompressionStrategy(name string) (CompressionStrategy, error) {
    switch name {
    case "gzip":
        return &GzipStrategy{}, nil
    case "zstd":
        return &ZstdStrategy{}, nil
    default:
        return nil, fmt.Errorf("unsupported strategy: %s", name)
    }
}