Golang反射如何实现动态结构体创建 演示StructOf方法构建运行时类型

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 定义结构体的字段
    fields := []reflect.StructField{
        {
            Name: "Name",
            Type: reflect.TypeOf(""),
            Tag:  reflect.StructTag(`json:"name"`), // 可以添加tag
        },
        {
            Name: "Age",
            Type: reflect.TypeOf(0),
            Tag:  reflect.StructTag(`json:"age"`),
        },
    }

    // 使用 reflect.StructOf 创建结构体类型
    newType := reflect.StructOf(fields)

    // 打印新创建的结构体类型
    fmt.Println("新结构体的类型:", newType) // 输出: 新结构体的类型: struct { Name string; Age int }

    // 创建新结构体的实例
    newValue := reflect.New(newType).Elem()

    // 设置字段的值
    nameField := newValue.FieldByName("Name")
    nameField.SetString("Alice")

    ageField := newValue.FieldByName("Age")
    ageField.SetInt(30)

    // 打印结构体实例的值
    fmt.Println("结构体实例的值:", newValue) // 输出: 结构体实例的值: {Alice 30}
}

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 创建 Address 结构体
    addressFields := []reflect.StructField{
        {
            Name: "City",
            Type: reflect.TypeOf(""),
        },
        {
            Name: "ZipCode",
            Type: reflect.TypeOf(0),
        },
    }
    addressType := reflect.StructOf(addressFields)

    // 创建 Person 结构体，包含 Address 字段
    personFields := []reflect.StructField{
        {
            Name: "Name",
            Type: reflect.TypeOf(""),
        },
        {
            Name: "Address",
            Type: addressType, // 使用之前创建的 Address 类型
        },
    }
    personType := reflect.StructOf(personFields)

    fmt.Println("Person结构体的类型:", personType) // 输出: Person结构体的类型: struct { Name string; Address struct { City string; ZipCode int } }

    // 创建 Person 实例
    personValue := reflect.New(personType).Elem()

    // 设置 Name 字段
    nameField := personValue.FieldByName("Name")
    nameField.SetString("Bob")

    // 创建 Address 实例并设置字段
    addressField := personValue.FieldByName("Address")
    addressValue := reflect.New(addressType).Elem()

    cityField := addressValue.FieldByName("City")
    cityField.SetString("New York")

    zipCodeField := addressValue.FieldByName("ZipCode")
    zipCodeField.SetInt(10001)

    // 将 Address 实例设置到 Person 的 Address 字段
    addressField.Set(addressValue)

    fmt.Println("Person实例的值:", personValue) // 输出: Person实例的值: {Bob {New York 10001}}
}

package main

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

func main() {
    // 创建动态结构体
    fields := []reflect.StructField{
        {
            Name: "Name",
            Type: reflect.TypeOf(""),
            Tag:  reflect.StructTag(`json:"name"`),
        },
        {
            Name: "Age",
            Type: reflect.TypeOf(0),
            Tag:  reflect.StructTag(`json:"age"`),
        },
    }
    dynamicType := reflect.StructOf(fields)

    // 创建动态结构体的实例
    dynamicValue := reflect.New(dynamicType).Elem()
    dynamicValue.FieldByName("Name").SetString("Charlie")
    dynamicValue.FieldByName("Age").SetInt(40)

    // 序列化为 JSON
    jsonData, err := json.Marshal(dynamicValue.Interface())
    if err != nil {
        fmt.Println("JSON 序列化失败:", err)
        return
    }
    fmt.Println("JSON 数据:", string(jsonData)) // 输出: JSON 数据: {"name":"Charlie","age":40}

    // 反序列化 JSON
    jsonString := `{"name":"David","age":50}`
    newValue := reflect.New(dynamicType).Elem()
    err = json.Unmarshal([]byte(jsonString), newValue.Addr().Interface())
    if err != nil {
        fmt.Println("JSON 反序列化失败:", err)
        return
    }

    fmt.Println("反序列化后的结构体:", newValue) // 输出: 反序列化后的结构体: {David 50}
}