如何在特定接口字段的情况下实现 UnmarshalJSON 的特殊行为？

本篇文章向大家介绍《如何在特定接口字段的情况下实现 UnmarshalJSON 的特殊行为？》，主要包括，具有一定的参考价值，需要的朋友可以参考一下。

type myobj struct {
    field1 string      `json:"field_1"`
    field2 int64       `json:"field_2"`
    field3 string      `json:"field_3"`
    ...
    fieldk string      `json:"field_k"`
    fieldn myinterface `json:"field_n"`
}

我的代码中有一个模型（除了不相关的域详细信息）如下所示。 fieldn 字段的想法是支持两种类型，例如 mytype1 和 mytype2。它们具有相同的 commonmethod() 但模型非常不同，因此这并不是要拥有具有更多字段的父类型。

不出所料，go 无法将 json 解组为接口值。我正在尝试使用自定义 unmarshaljson() 实现，但到目前为止它看起来真的很尴尬：

func (m *MyObj) UnmarshalJSON(data []byte) error {
    out := &MyObj{}

    var m map[string]json.RawMessage
    if err := json.Unmarshal(data, &m); err != nil {
        return err
    }

    if err := json.Unmarshal(m["field_1"], &out.Field1); err != nil {
        return err
    }
    delete(m, "field_1")

    if err := json.Unmarshal(m["field_2"], &out.Field2); err != nil {
        return err
    }
    delete(m, "field_2")

    if err := json.Unmarshal(m["field_3"], &out.Field3); err != nil {
        return err
    }
    delete(m, "field_3")

    ... // from 3 to k-1

    if err := json.Unmarshal(m["field_k"], &out.FieldK); err != nil {
        return err
    }
    delete(m, "field_k")

    var mt1 MyType1
    if err := json.Unmarshal(m["field_n"], &mt1); err == nil {
        s.FieldN = &mt1
        return nil
    }

    var mt2 MyType2
    if err := json.Unmarshal(m["field_n"], &mt2); err == nil {
        s.FieldN = &mt2
        return nil
    }

    return nil
}

这种方法的想法是首先解组所有“静态”值，然后处理接口类型。然而，在我看来，它至少存在两个问题：

1. 就我而言，字段的数量将来可能会增加，并且代码将变得比现在更加重复

2. 即使当前版本也需要检查地图 m 是否具有键 field_i，否则我只会得到 意外的输入 结尾。这样就更麻烦了。

是否有更优雅的方法来执行以下操作：

• 解组所有静态类型字段
• 处理唯一的特殊接口类型值

谢谢！

重要更新：

应该注意的是，field1有效地定义了fieldn应使用哪种具体类型。正如评论中所指出的，这应该大大简化方法，但我仍然在正确实施方面遇到了一些困难。

正确答案

使用 json.rawmessage 捕获对象的变化部分。使用应用程序逻辑中确定的类型对原始消息进行解码。

func (m *myobj) unmarshaljson(data []byte) error {

    // declare new type with same fields as myobj, but
    // but no methods. this type is used to avoid
    // recursion when unmarshaling a value of type 
    // y declared below.
    type x myobj

    // declare a type to capture field_n as a raw message
    // and all other fields as normal.  the fieldn in 
    // myobj is shadowed by the fieldn here.
    type y struct {
        *x
        fieldn json.rawmessage `json:"field_n"`
    }

    // unmarshal field_n to the raw message and all other fields
    // to m.
    y := y{x: (*x)(m)}
    err := json.unmarshal(data, &y)
    if err != nil {
        return err
    }

    // we now have field_n as a json.rawmessage in y.fieldn.
    // we can use whatever logic we want to determine the
    // concrete type, create a value of that type, and unmarshal
    // to that value.
    //
    // here, i assume that field_1 specifies the concrete type.
    switch m.field1 {
    case "type1":
        m.fieldn = &mytype1{}
    case "type2":
        m.fieldn = &mytype2{}
    default:
        return errors.new("unknown field 1")
    }

    return json.unmarshal(y.fieldn, m.fieldn)

}

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

此演示基于 @mkopriva 的建议 (disallowunknownfields)，但仍使用 “尝试一个；如果失败，请尝试另一个” 过程。

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
)

type myobj struct {
    field1 string      `json:"field_1"`
    fieldn myinterface `json:"field_n"`
}

type myinterface interface{}

type mytype1 struct {
    ff1 string `json:"ff1"`
}

type mytype2 struct {
    ff2 string `json:"ff2"`
}

func (m *myobj) unmarshaljson(data []byte) error {
    // we can not use myobj directly. if we do this, the json decoder will
    // call this func, and result in a stack overflow panic. replace
    // "type myobj1 myobj" with "type myobj1 = myobj" and you will see the error.
    type myobj1 myobj
    out := myobj1{fieldn: &mytype1{}}

    dec := json.newdecoder(bytes.newreader(data))
    dec.disallowunknownfields()

    if err := dec.decode(&out); err == nil {
        *m = myobj(out)
        return nil
    }

    out.fieldn = &mytype2{}
    dec = json.newdecoder(bytes.newreader(data))
    dec.disallowunknownfields()
    if err := dec.decode(&out); err == nil {
        *m = myobj(out)
        return nil
    } else {
        return err
    }
}

func main() {
    test(`{"field_1":"field1","field_n":{"ff1":"abc"}}`)
    test(`{"field_1":"field1","field_n":{"ff2":"abc"}}`)
}

func test(input string) {
    var obj myobj

    if err := json.unmarshal([]byte(input), &obj); err != nil {
        fmt.println(err)
    } else {
        fmt.printf("%#v, %#v\n", obj, obj.fieldn)
    }
}

输出：

main.MyObj{Field1:"field1", FieldN:(*main.MyType1)(0xc00009e270)}, &main.MyType1{FF1:"abc"}
main.MyObj{Field1:"field1", FieldN:(*main.MyType2)(0xc00009e3a0)}, &main.MyType2{FF2:"abc"}

以上就是《如何在特定接口字段的情况下实现 UnmarshalJSON 的特殊行为？》的详细内容，更多关于的资料请关注golang学习网公众号！