在Golang中从 struct 手动创建JSON对象

你不能在运行时修改标记，但是你可以使用reflect.StructOf()在运行时创建 struct 类型.

所以我们的 idea 是复制 struct 类型，但是在复制中从JSON标记中排除,omitempty选项.

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

这比人们最初想象的要容易得多.我们只需递归地完成( struct 字段可以是另一个 struct )，并且我们绝对应该处理指针:

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)
        // Keep json tag but cut ,omitempty option if exists:
        if tag, _ := strings.CutSuffix(sf.Tag.Get("json"), ",omitempty"); tag == "" {
            sf.Tag = ""
        } else {
            sf.Tag = `json:"` + reflect.StructTag(tag) + `"`
        }
        fields = append(fields, sf)
    }

    return reflect.StructOf(fields)
}

让我们用这个类型来测试它:

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

首先，在没有类型重复的情况下，JSON输出是这样的:

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

输出:

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

请注意，我们有Bar和Baz个字段，因为它们是 struct .

让我们try 一下类型复制:

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:
 {"String":"","Int":0,"Bar":{"Float":0,"PtrInt":0,"Baz":{"XXXX":0}}} <nil>

好的!这正是我们想要的！

但我们还没说完.如果我们有一个带 struct 指针字段的类型呢？就像这样:

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

try 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:
 {"String":"","Int":0,"Bar":null} <nil>

如果 struct 包含指针，则这些指针在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:
 {"String":"","Int":0,"Bar":{"Float":0,"PtrInt":0,"Baz":{"XXXX":0}}} <nil>

好的!它包含所有字段！