在golang中从struct手动创建json对象

Question

我有一个结构可以说

type Foo struct {
  A string `json:",omitemtpy"
}

我知道我可以使用类似的东西轻松将其转换为 json

json.Marshal(Foo{})

它将返回一个空的 json 字符串。

但是我需要使用相同的结构返回结构的 json 表示形式，其中包含所有字段和 json 中存在的“空值”。 （实际上它是一个非常大的结构，所以我不能只保留没有标签的副本）

最简单的方法是什么？

基本上我需要创建一个忽略 json omitempty 标签的结构的 json 元帅。

此 json 创建不需要高效或高性能。

如果有一个用于此类任务的库，我会更喜欢，但我见过的大多数库要么创建一些特殊格式，要么尊重 omitempty

Answer 1

您无法在运行时修改标签，但您可以使用

reflect.StructOf()

在运行时创建结构类型。

因此，我们的想法是复制结构类型，但在重复中使用空标记值。

您可以在Go Playground找到以下所有示例。

这比人们一开始想象的要容易。我们只需要递归地执行（一个结构体字段可能是另一个结构体），并且我们绝对应该处理指针：

func dupType(t reflect.Type) reflect.Type {
    if t.Kind() == reflect.Pointer {
        return reflect.PointerTo(dupType(t.Elem()))
    }

    if t.Kind() != reflect.Struct {
        return t
    }

    var fields []reflect.StructField

    for i := 0; i < t.NumField(); i++ {
        sf := t.Field(i)
        sf.Type = dupType(sf.Type)
        sf.Tag = ""
        fields = append(fields, sf)
    }

    return reflect.StructOf(fields)
}

我们用这个类型来测试一下：

type Foo struct {
    Str string `json:",omitempty"`
    Int int    `json:",omitempty"`
    Bar struct {
        Float  float64 `json:",omitempty"`
        PtrInt int     `json:",omitempty"`
        Baz    struct {
            X int `json:",omitempty"`
        } `json:",omitempty"`
    } `json:",omitempty"`
}

首先，这是没有类型重复的 JSON 输出：

    data, err := json.Marshal(Foo{})
    fmt.Println("Foo:\n", string(data), err)

输出：

Foo:
 {"Bar":{"Baz":{}}} <nil>

请注意，我们得到了

Bar

和

Baz

字段，因为它们是结构体。

让我们尝试类型复制：

    dupFooType := dupType(reflect.TypeOf(Foo{}))
    foo := reflect.Zero(dupFooType).Interface()

    data, err := json.Marshal(foo)
    fmt.Println("dup Foo:\n", string(data), err)

这将输出：

dup Foo:
 {"Str":"","Int":0,"Bar":{"Float":0,"PtrInt":0,"Baz":{"X":0}}} <nil>

不错！正是我们想要的！

但我们还没有完成。如果我们有一个带有结构指针字段的类型怎么办？像这样：

type FooWithPtrs struct {
    Str string `json:",omitempty"`
    Int int    `json:",omitempty"`
    Bar *struct {
        Float  float64 `json:",omitempty"`
        PtrInt int     `json:",omitempty"`
        Baz    *struct {
            X int `json:",omitempty"`
        } `json:",omitempty"`
    } `json:",omitempty"`
}

尝试 JSON 编组重复类型的值：

    dupFooType := dupType(reflect.TypeOf(FooWithPtrs{}))
    foo := reflect.Zero(dupFooType).Interface()

    data, err := json.Marshal(foo)
    fmt.Println("dup FooWithPtrs:\n", string(data), err)

输出：

dup FooWithPtrs:
 {"Str":"","Int":0,"Bar":null} <nil>

如果结构体包含指针，则它们在 JSON 输出中显示为

null

，但我们希望它们出现在输出中。这需要将它们初始化为非

nil

值，以便它们生成输出。

幸运的是，我们也可以使用反射来做到这一点：

func initPtrs(v reflect.Value) {
    if !v.CanAddr() {
        return
    }

    if v.Kind() == reflect.Pointer {
        v.Set(reflect.New(v.Type().Elem()))
        v = v.Elem()
    }

    if v.Kind() == reflect.Struct {
        for i := 0; i < v.NumField(); i++ {
            initPtrs(v.Field(i))
        }
    }
}

我们很兴奋！让我们看看实际效果：

    dupFooType := dupType(reflect.TypeOf(FooWithPtrs{}))
    fooVal := reflect.New(dupFooType)
    initPtrs(fooVal.Elem())

    data, err := json.Marshal(fooVal.Interface())
    fmt.Println("dup and inited FooWithPtrs:\n", string(data), err)

输出：

dup and inited FooWithPtrs:
 {"Str":"","Int":0,"Bar":{"Float":0,"PtrInt":0,"Baz":{"X":0}}} <nil>

不错！它包含所有字段！