將 yaml 字段動態解析為 Go 中的一組有限結構之一

Question

我有一個yaml文件，其中一個字段可以由一種可能的結構表示。 為了簡化代碼和 yaml 文件，假設我有這些 yaml 文件：

kind: "foo"
spec:
  fooVal: 4

kind: "bar"
spec:
  barVal: 5

這些用於解析的結構：

    type Spec struct {
        Kind string      `yaml:"kind"`
        Spec interface{} `yaml:"spec"`
    }
    type Foo struct {
        FooVal int `yaml:"fooVal"`
    }
    type Bar struct {
        BarVal int `yaml:"barVal"`
    }

我知道我可以使用map[string]interface{}作為一種Spec字段。 但實際的例子更復雜，涉及更多可能的結構類型，不僅僅是Foo和Bar ，這就是為什么我不喜歡將spec解析到該字段中。

我找到了一種解決方法：將 yaml 解組為中間結構，然后檢查kind字段，並將map[string]interface{}字段編組到 yaml 后面，並將其解組為具體類型：

    var spec Spec
    if err := yaml.Unmarshal([]byte(src), &spec); err != nil {
        panic(err)
    }
    tmp, _ := yaml.Marshal(spec.Spec)
    if spec.Kind == "foo" {
        var foo Foo
        yaml.Unmarshal(tmp, &foo)
        fmt.Printf("foo value is %d\n", foo.FooVal)
    }
    if spec.Kind == "bar" {
        tmp, _ := yaml.Marshal(spec.Spec)
        var bar Bar
        yaml.Unmarshal(tmp, &bar)
        fmt.Printf("bar value is %d\n", bar.BarVal)
    }

但它需要額外的步驟並消耗更多的 memory（實際的 yaml 文件可能比示例中更大）。 是否存在一些更優雅的方法來將 yaml 動態解組為有限的結構集？

更新：我正在使用github.com/go-yaml/yaml v2.1.0 Yaml 解析器。

Answer 1

您可以通過實現自定義UnmarshalYAML函數來做到這一點。 但是，對於 API 的v2版本，您基本上會做和現在一樣的事情，只是封裝得更好一點。

但是，如果您切換到使用v3 API，您將獲得更好的UnmarshalYAML ，它實際上可以讓您在解析的 YAML 節點被處理為本機 Go 類型之前對其進行處理。 看起來是這樣的：

package main

import (
    "errors"
    "fmt"
    "gopkg.in/yaml.v3"
)

type Spec struct {
    Kind string      `yaml:"kind"`
    Spec interface{} `yaml:"spec"`
}
type Foo struct {
    FooVal int `yaml:"fooVal"`
}
type Bar struct {
    BarVal int `yaml:"barVal"`
}

func (s *Spec) UnmarshalYAML(value *yaml.Node) error {
    s.Kind = ""
    for i := 0; i < len(value.Content)/2; i += 2 {
        if value.Content[i].Kind == yaml.ScalarNode &&
            value.Content[i].Value == "kind" {
            if value.Content[i+1].Kind != yaml.ScalarNode {
                return errors.New("kind is not a scalar")
            }
            s.Kind = value.Content[i+1].Value
            break
        }
    }
    if s.Kind == "" {
        return errors.New("missing field `kind`")
    }
    switch s.Kind {
    case "foo":
        var foo Foo
        if err := value.Decode(&foo); err != nil {
            return err
        }
        s.Spec = foo
    case "bar":
        var bar Bar
        if err := value.Decode(&bar); err != nil {
            return err
        }
        s.Spec = bar
    default:
        return errors.New("unknown kind: " + s.Kind)
    }
    return nil
}

var input1 = []byte(`
kind: "foo"
spec:
  fooVal: 4
`)

var input2 = []byte(`
kind: "bar"
spec:
  barVal: 5
`)

func main() {
    var s1, s2 Spec
    if err := yaml.Unmarshal(input1, &s1); err != nil {
        panic(err)
    }
    fmt.Printf("Type of spec from input1: %T\n", s1.Spec)
    if err := yaml.Unmarshal(input2, &s2); err != nil {
        panic(err)
    }
    fmt.Printf("Type of spec from input2: %T\n", s2.Spec)
}

我建議研究在 YAML 中使用 YAML 標簽而不是 model 的當前結構的可能性； 標簽正是為此目的而設計的。 代替現在的YAML

kind: "foo"
spec:
  fooVal: 4

你可以寫

--- !foo
fooVal: 4

現在您不再需要具有kind和spec的描述結構。 加載它看起來會有些不同，因為您需要一個可以在其上定義UnmarshalYAML的包裝根類型，但如果這只是更大結構的一部分，它可能是可行的。 您可以在yaml.Node的Tag字段中訪問標簽!foo 。

Answer 2

要與yaml.v2使用，您可以執行以下操作：

type yamlNode struct {
    unmarshal func(interface{}) error
}

func (n *yamlNode) UnmarshalYAML(unmarshal func(interface{}) error) error {
    n.unmarshal = unmarshal
    return nil
}

type Spec struct {
    Kind string      `yaml:"kind"`
    Spec interface{} `yaml:"-"`
}

func (s *Spec) UnmarshalYAML(unmarshal func(interface{}) error) error {
    type S Spec
    type T struct {
        S    `yaml:",inline"`
        Spec yamlNode `yaml:"spec"`
    }

    obj := &T{}
    if err := unmarshal(obj); err != nil {
        return err
    }
    *s = Spec(obj.S)

    switch s.Kind {
    case "foo":
        s.Spec = new(Foo)
    case "bar":
        s.Spec = new(Bar)
    default:
        panic("kind unknown")
    }
    return obj.Spec.unmarshal(s.Spec)
}

https://play.golang.org/p/Ov0cOaedb-x

---

要與yaml.v3使用，您可以執行以下操作：

type Spec struct {
    Kind string      `yaml:"kind"`
    Spec interface{} `yaml:"-"`
}

func (s *Spec) UnmarshalYAML(n *yaml.Node) error {
    type S Spec
    type T struct {
        *S   `yaml:",inline"`
        Spec yaml.Node `yaml:"spec"`
    }

    obj := &T{S: (*S)(s)}
    if err := n.Decode(obj); err != nil {
        return err
    }

    switch s.Kind {
    case "foo":
        s.Spec = new(Foo)
    case "bar":
        s.Spec = new(Bar)
    default:
        panic("kind unknown")
    }
    return obj.Spec.Decode(s.Spec)
}

https://play.golang.org/p/ryEuHyU-M2Z