Go JSON序列化与反序列化reflect.Type的挑战与解决方案

package main

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

var datajson []byte

type User struct {
    Name string
    Type reflect.Type // 存储 reflect.Type 实例
}

// MustJSONEncode 将 Go 对象编码为 JSON 字节数组
func MustJSONEncode(i interface{}) []byte {
    result, err := json.Marshal(i)
    if err != nil {
        panic(err)
    }
    return result
}

// MustJSONDecode 将 JSON 字节数组解码为 Go 对象
func MustJSONDecode(b []byte, i interface{}) {
    err := json.Unmarshal(b, i)
    if err != nil {
        panic(err) // 反序列化 reflect.Type 时会在此处 panic
    }
}

// Store 将 Go 对象序列化并存储
func Store(a interface{}) {
    datajson = MustJSONEncode(a)
    fmt.Printf("Serialized JSON: %s\n", datajson)
}

// Get 从存储中反序列化 Go 对象
func Get(a []byte, b interface{}) {
    MustJSONDecode(a, b)
    fmt.Printf("Deserialized Object: %+v\n", b)
}

func main() {
    david := &User{Name: "DavidMahon"}
    typ := reflect.TypeOf(david) // 获取 *main.User 类型的 reflect.Type
    david.Type = typ

    Store(david) // 序列化成功

    dummy := &User{}
    Get(datajson, dummy) // 反序列化时会 panic
}

type User struct {
    Name string
    TypeName string // 存储类型名称的字符串
}

func main() {
    david := &User{Name: "DavidMahon"}
    typ := reflect.TypeOf(david)
    david.TypeName = typ.String() // 将 reflect.Type 转换为字符串

    Store(david) // 序列化
    // 此时输出的 JSON 类似：{"Name":"DavidMahon","TypeName":"*main.User"}

    dummy := &User{}
    Get(datajson, dummy) // 反序列化
    // 此时 dummy.TypeName 将正确地包含 "*main.User"
}

package main

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

var datajson []byte

// 定义一个类型注册表
var typeRegistry = make(map[string]reflect.Type)

// 注册已知类型，以便后续通过名称查找
func init() {
    typeRegistry[reflect.TypeOf(&User{}).String()] = reflect.TypeOf(&User{})
    typeRegistry[reflect.TypeOf(0).String()] = reflect.TypeOf(0)
    // 可以注册更多你希望能够识别的类型
}

type User struct {
    Name string
    TypeName string
}

func MustJSONEncode(i interface{}) []byte {
    result, err := json.Marshal(i)
    if err != nil {
        panic(err)
    }
    return result
}
func MustJSONDecode(b []byte, i interface{}) {
    err := json.Unmarshal(b, i)
    if err != nil {
        panic(err)
    }
}
func Store(a interface{}) {
    datajson = MustJSONEncode(a)
    fmt.Printf("Serialized JSON: %s\n", datajson)
}

func Get(a []byte, b interface{}) {
    MustJSONDecode(a, b)
    fmt.Printf("Deserialized Object: %+v\n", b)
}

func main() {
    david := &User{Name: "DavidMahon"}
    typ := reflect.TypeOf(david)
    david.TypeName = typ.String() // 存储类型名称字符串

    Store(david)

    dummy := &User{}
    Get(datajson, dummy)

    fmt.Printf("Deserialized User TypeName: %s\n", dummy.TypeName)

    // 从注册表尝试获取 reflect.Type 实例
    if retrievedType, ok := typeRegistry[dummy.TypeName]; ok {
        fmt.Printf("Successfully retrieved reflect.Type from registry: %s\n", retrievedType.String())
        // 现在你可以使用 retrievedType 进行进一步的反射操作
        // 例如：创建一个新实例
        newVal := reflect.New(retrievedType.Elem()).Interface()
        fmt.Printf("Created new instance of retrieved type: %+v\n", newVal)
    } else {
        fmt.Printf("Type '%s' not found in registry.\n", dummy.TypeName)
    }

    // 尝试序列化一个不同类型的 User
    jane := &User{Name: "JaneDoe"}
    intType := reflect.TypeOf(123)
    jane.TypeName = intType.String() // 存储 int 类型的名称
    Store(jane)

    dummy2 := &User{}
    Get(datajson, dummy2) // datajson 现在是 jane 的数据
    fmt.Printf("Deserialized User2 TypeName: %s\n", dummy2.TypeName)
    if retrievedType, ok := typeRegistry[dummy2.TypeName]; ok {
        fmt.Printf("Successfully retrieved reflect.Type from registry: %s\n", retrievedType.String())
    } else {
        fmt.Printf("Type '%s' not found in registry.\n", dummy2.TypeName) // 预期输出此行，因为 int 类型未注册
    }
}