强制解组为interface{}而不是mapinterface{}

在IT行业这个发展更新速度很快的行业，只有不停止的学习，才不会被行业所淘汰。如果你是golang学习者，那么本文《强制解组为interface{}而不是mapinterface{}》就很适合你！本篇内容主要包括##content_title##，希望对大家的知识积累有所帮助，助力实战开发！

我有以下 yaml 结构：

type pipeline struct {
    name string                  `yaml:"name"`
    nodes map[string]nodeconfig  `yaml:"nodes"`
    connections []nodeconnection `yaml:"connections"`
}

type nodeconfig struct {
    type   string      `yaml:"type"`
    config interface{} `yaml:"config"`
}

对于每个nodeconfig，根据type的值，我需要检测config的真实类型。

switch nc.type {
    case "request":
        return newrequestnode(net, name, nc.config.(requestconfig))
    case "log":
        return newlognode(net, name)
    //...
}

这是我从中得到的错误：

panic: interface conversion: interface {} is map[string]interface {}, not main.RequestConfig

我怀疑这是因为 config 被自动识别为 map[string]interface{}，而我真的希望它只是一个 interface{}。我怎样才能做到这一点？

编辑：最小示例

正确答案

您对这个问题的看法是正确的，它会被自动识别为 map[string]interface{}，因为您没有提供自定义 unmarshalyaml 函数，yaml 包只能做到这一点。但您实际上并不希望它只是 interface{}，您需要确定您想要哪种实际实现。

使用yaml.v3的解决方案

我不知道如何在不向 nodeconfig 类型提供自定义 unmarshalyaml 函数的情况下解决该问题。如果这是 JSON，我会将 config 读取为 json.rawmessage，然后对于每种可能的类型，我会将其解组为所需的类型，而 yaml.v3 等效项似乎是 yaml.Node type。

使用它，您可以创建一个类似于 nodeconfig 的结构，其中 config 为 yaml.node 并根据 type 值将其转换为具体类型，如下所示：

func (nc *nodeconfig) unmarshalyaml(value *yaml.node) error {
    var ncu struct {
        type   string    `yaml:"type"`
        config yaml.node `yaml:"config"`
    }
    var err error

    // unmarshall into a nodeconfigunmarshaler to detect correct type
    err = value.decode(&ncu)
    if err != nil {
        return err
    }

    // now, detect the type and covert it accordingly
    nc.type = ncu.type
    switch ncu.type {
    case "request":
        nc.config = &requestconfig{}
    case "log":
        nc.config = &loGConfig{}
    default:
        return fmt.errorf("unknown type %q", ncu.type)
    }
    err = ncu.config.decode(nc.config)

    return err
}

示例代码

为了测试这一点，我创建了虚拟对象 requestconfig 和 logconfig 以及一个示例：

type requestconfig struct {
    foo string `yaml:"foo"`
    bar string `yaml:"bar"`
}

type logconfig struct {
    message string `yaml:"message"`
}

func main() {
    logsampleyaml := []byte(`
type: log
config:
    message: this is a log message
`)

    reqsampleyaml := []byte(`
type: request
config:
    foo: foo value
    bar: bar value
`)

    for i, val := range [][]byte{logsampleyaml, reqsampleyaml} {
        var nc nodeconfig
        err := yaml.unmarshal(val, &nc)
        if err != nil {
            fmt.printf("failed to parse sample %d: %v\n", i, err)
        } else {
            fmt.printf("sample %d type %q (%t) = %+v\n", i, nc.type, nc.config, nc.config)
        }
    }
}

哪些输出：

sample 0 type "log" (*main.logconfig) = &{message:this is a log message}
sample 1 type "request" (*main.requestconfig) = &{foo:foo value bar:bar value}

因此，正如您所看到的 nodeconfig 的每个实例都使用所需的具体类型实例化 config ，这意味着您现在可以使用类型断言作为 confg.(*requestconfig) 或 config.(*logconfig) （或 switch ，当然）。

你可以玩那个solution in this Go Playground full sample。

使用yaml.v2的解决方案

我犯了一个错误，并使用 v2 发送了解决方案，但我建议任何人使用 v3。如果不能，请遵循 v2 版本...

v2没有yaml.node，但我在this issue的答案中找到了一个非常相似的解决方案（我修复了那里的拼写错误）：

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

func (msg *rawmessage) unmarshalyaml(unmarshal func(interface{}) error) error {
    msg.unmarshal = unmarshal
    return nil
}

func (msg *rawmessage) unmarshal(v interface{}) error {
    return msg.unmarshal(v)
}

这是一个有趣的技巧，通过它，您可以通过将其加载到临时结构中来烘焙您自己的 unmarshalyaml 函数，然后识别您想要的每种类型，而无需处理 yaml 两次：

func (nc *NodeConfig) UnmarshalYAML(unmarshal func(interface{}) error) error {
    var ncu struct {
        Type   string     `yaml:"type"`
        Config RawMessage `yaml:"config"`
    }
    var err error

    // unmarshall into a NodeConfigUnmarshaler to detect correct type
    err = unmarshal(&ncu)
    if err != nil {
        return err
    }

    // now, detect the type and covert it accordingly
    nc.Type = ncu.Type
    switch ncu.Type {
    case "request":
        cfg := &RequestConfig{}
        err = ncu.Config.Unmarshal(cfg)
        nc.Config = cfg
    case "log":
        cfg := &LogConfig{}
        err = ncu.Config.Unmarshal(cfg)
        nc.Config = cfg
    default:
        return fmt.Errorf("unknown type %q", ncu.Type)
    }

    return err
}

v2 和 v3 的示例代码是相同的。

你可以玩那个solution in this Go Playground full sample。

理论要掌握，实操不能落！以上关于《强制解组为interface{}而不是mapinterface{}》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注编程网公众号吧！