将 YAML 解组为复杂的 object，它可以是结构或字符串

Question

尝试将 YAML 解组为复杂的 object，例如map[string]map[interface{}]string 。 问题是我希望能够区分string和Source之间的interface{}部分，这是一个结构。

type Source struct {
    ID     string `yaml:"id"`
    Name   string `yaml:"name"`
    LogoID string `yaml:"logoId"`
    URL    string `yaml:"url"`
}

type UNFT struct {
    ItemMeta map[string]map[interface{}]string `yaml:"item_meta"`
    // could be
    // ItemMeta map[string]map[string]string `yaml:"item_meta"`
    // or
    // ItemMeta map[string]map[Source]string `yaml:"item_meta"`
}

显然 YAML 不知道如何解组为Source结构，所以我必须实现Unmarshaler接口：

type Unmarshaler interface {
    UnmarshalYAML(value *Node) error
}

但是我不太了解解组过程的全局。 一般来说，我假设我必须手动遍历*yaml.Node并在每个节点上调用func UnmarshalYAML(value *Node) error 。

package main

import (
    "fmt"

    "gopkg.in/yaml.v3"
)

type Source struct {
    ID     string `json:"id"`
    Name   string `json:"name"`
    LogoID string `json:"logoId"`
    URL    string `json:"url"`
}

var data = `
unf:
    item_meta:
      source:
           !struct
           ? id: "data-watch" 
             name: "DataWatch"
             logoid: "data-watch"
             url: "https"
           : "product_any('SS')"
      public_usage:
        "": "source_any('SDF')"
        "provider": "source_any('ANO')"`

type UNFT struct {
    ItemMeta map[string]map[interface{}]string `yaml:"item_meta"`
}

type MetaConverterConfigT struct {
    UNFT UNFT `yaml:"unf"`
}

func main() {
    cfg := MetaConverterConfigT{}

    err := yaml.Unmarshal([]byte(data), &cfg)
    if err != nil {
        fmt.Println("%w", err)
    }

    fmt.Println(cfg)
}

func (s *UNFT) UnmarshalYAML(n *yaml.Node) error {
    var cfg map[string]map[interface{}]string
    if err := n.Decode(&cfg); err != nil {
        fmt.Println("%w", err)
    }

    return nil
}

Go游乐场

Answer 1

type MetaKey struct {
    String string
    Source Source
}

func (k *MetaKey) UnmarshalYAML(n *yaml.Node) error {
    if n.Tag == "!!str" {
        return n.Decode(&k.String)
    }
    if n.Tag == "!!map" {
        return n.Decode(&k.Source)
    }
    return fmt.Errorf("unsupported MetaKey type")
}

// ...

type UNFT struct {
    ItemMeta map[string]map[MetaKey]string `yaml:"item_meta"`
}

https://go.dev/play/p/Nhtab4l-ANT

---

如果您需要 map 类型保持原样，即不添加自定义密钥类型，那么您也可以在 UNFT 上实现解组器，只需使用any进行重新映射：

type UNFT struct {
    ItemMeta map[string]map[any]string `yaml:"item_meta"`
}

func (u *UNFT) UnmarshalYAML(n *yaml.Node) error {
    var obj struct {
        ItemMeta map[string]map[MetaKey]string `yaml:"item_meta"`
    }
    if err := n.Decode(&obj); err != nil {
        return err
    }

    u.ItemMeta = make(map[string]map[any]string, len(obj.ItemMeta))
    for k, v := range obj.ItemMeta {
        m := make(map[any]string, len(v))
        for k, v := range v {
            if k.Source != (Source{}) {
                m[k.Source] = v
            } else {
                m[k.String] = v
            }
        }
        u.ItemMeta[k] = m
    }
    return nil
}

https://go.dev/play/p/uwboGKf3qnD