如何检查 json 是否与结构/结构字段匹配

Question

有没有一种简单的方法来检查 myStruct 的每个字段是否已使用 json.Unmarshal(jsonData, &myStruct) 进行映射。

我能想到的唯一方法是将结构体的每个字段定义为指针，否则您将始终返回一个初始化的结构体。因此，每个作为对象的 jsonString（即使是空的 {}）都会返回一个初始化的结构，并且您无法判断该 json 是否代表您的结构。

我能想到的唯一解决方案是非常不舒服的：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name *string `json:name`
    Age  *int    `json:age`
    Male *bool   `json:male`
}

func main() {
    var p *Person
    err := json.Unmarshal([]byte("{}"), &p)
    // handle parse error
    if err != nil {
        return
    }

    // handle json did not match error
    if p.Name == nil || p.Age == nil || p.Male == nil {
        return
    }

    // now use the fields with dereferencing and hope you did not forget a nil check
    fmt.Println("Hello " + *p.Name)
}

也许可以使用像govalidator这样的库并使用 SetFieldsRequiredByDefault。但是，您仍然必须执行验证，并且仍然会留下整个指针取消引用以进行值检索和 nil 指针的风险。

我想要的是一个函数，该函数将我的未编组的 json 作为结构返回，或者在字段不匹配时返回错误。golang json 库提供的唯一功能是在未知字段上失败但在缺失字段上不失败的选项。

任何想法？

Answer 1

另一种方法是实现您自己的json.Unmarshaler，它使用反射（类似于默认的 json unmarshaler）：

有几点需要考虑：

• 如果速度对您来说非常重要，那么您应该编写一个基准来看看额外反射的影响有多大。我怀疑它可以忽略不计，但编写一个小的 go 基准来获取一些数字也没什么坏处。
• stdlib 会将 json 输入中的所有数字解组为浮点数。因此，如果您使用反射来设置整数字段，那么您需要自己提供相应的转换（请参阅下面示例中的 TODO）
• 该json.Decoder.DisallowUnknownFields函数将无法按您的类型预期工作。您需要自己实现（参见下面的示例）
• 如果您决定采用这种方法，您的代码将会变得更加复杂，从而更难理解和维护。您真的确定您必须知道字段是否被省略吗？也许您可以重构您的字段以充分利用零值？

这是此方法的完全可执行的测试：

package sandbox

import (
    "encoding/json"
    "errors"
    "reflect"
    "strings"
    "testing"
)

type Person struct {
    Name string
    City string
}

func (p *Person) UnmarshalJSON(data []byte) error {
    var m map[string]interface{}
    err := json.Unmarshal(data, &m)
    if err != nil {
        return err
    }

    v := reflect.ValueOf(p).Elem()
    t := v.Type()

    var missing []string
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        val, ok := m[field.Name]
        delete(m, field.Name)
        if !ok {
            missing = append(missing, field.Name)
            continue
        }

        switch field.Type.Kind() {
        // TODO: if the field is an integer you need to transform the val from float
        default:
            v.Field(i).Set(reflect.ValueOf(val))
        }
    }

    if len(missing) > 0 {
        return errors.New("missing fields: " + strings.Join(missing, ", "))
    }

    if len(m) > 0 {
        extra := make([]string, 0, len(m))
        for field := range m {
            extra = append(extra, field)
        }
        // TODO: consider sorting the output to get deterministic errors:
        // sort.Strings(extra)
        return errors.New("unknown fields: " + strings.Join(extra, ", "))
    }

    return nil
}

func TestJSONDecoder(t *testing.T) {
    cases := map[string]struct {
        in       string
        err      string
        expected Person
    }{
        "Empty object": {
            in:       `{}`,
            err:      "missing fields: Name, City",
            expected: Person{},
        },
        "Name missing": {
            in:       `{"City": "Berlin"}`,
            err:      "missing fields: Name",
            expected: Person{City: "Berlin"},
        },
        "Age missing": {
            in:       `{"Name": "Friedrich"}`,
            err:      "missing fields: City",
            expected: Person{Name: "Friedrich"},
        },
        "Unknown field": {
            in:       `{"Name": "Friedrich", "City": "Berlin", "Test": true}`,
            err:      "unknown fields: Test",
            expected: Person{Name: "Friedrich", City: "Berlin"},
        },
        "OK": {
            in:       `{"Name": "Friedrich", "City": "Berlin"}`,
            expected: Person{Name: "Friedrich", City: "Berlin"},
        },
    }

    for name, c := range cases {
        t.Run(name, func(t *testing.T) {
            var actual Person
            r := strings.NewReader(c.in)
            err := json.NewDecoder(r).Decode(&actual)
            switch {
            case err != nil && c.err == "":
                t.Errorf("Expected no error but go %v", err)
            case err == nil && c.err != "":
                t.Errorf("Did not return expected error %v", c.err)
            case err != nil && err.Error() != c.err:
                t.Errorf("Expected error %q but got %v", c.err, err)
            }

            if !reflect.DeepEqual(c.expected, actual) {
                t.Errorf("\nWant: %+v\nGot:  %+v", c.expected, actual)
            }
        })
    }
}