Golang中接口数据的序列化与反序列化实践

反序列化一个像这样的 struct：

type Cage struct {
    contains Animal
}

其中 Animal 是一个可能是 Cat 或 Dog 的 interface，这就是问题所在。

你有想要反序列化到那个结构体的 JSON 数据示例吗？

以及，这种尝试用非面向对象语言处理基于继承的数据是学术性质的，还是附带有实际的问题？

编辑：所以，一个通用的反序列化器无法从 Go 代码中获得足够的信息来分析传入的 JSON 数据。没有这些数据，或者没有合适的标准化元数据，反序列化器实际上没有机会。

对于这种情况，像 gojsonq 这样的包会是一个可行的选择吗？

简而言之，jsonq 解析任何 JSON 并提供查询接口，而不是填充好的结构体。

其余部分（即了解数据的结构以及如何查询所需信息）则留给包的用户。

在Go中处理接口的序列化与反序列化确实需要一些技巧，因为接口类型在运行时才能确定具体类型。下面是一个实践示例，展示如何通过自定义JSON编解码来处理多种格式的接口数据。

首先，定义接口和实现结构体：

package main

import (
    "encoding/json"
    "fmt"
    "gopkg.in/yaml.v3"
)

type Animal interface {
    Speak() string
}

type Dog struct {
    Name string `json:"name" yaml:"name"`
    Breed string `json:"breed" yaml:"breed"`
}

func (d Dog) Speak() string {
    return "Woof!"
}

type Cat struct {
    Name string `json:"name" yaml:"name"`
    Color string `json:"color" yaml:"color"`
}

func (c Cat) Speak() string {
    return "Meow!"
}

对于JSON序列化，使用类型包装器：

type AnimalWrapper struct {
    Type string `json:"type"`
    Data json.RawMessage `json:"data"`
}

func MarshalAnimal(a Animal) ([]byte, error) {
    var wrapper AnimalWrapper
    
    switch v := a.(type) {
    case *Dog:
        wrapper.Type = "dog"
        data, err := json.Marshal(v)
        if err != nil {
            return nil, err
        }
        wrapper.Data = data
    case *Cat:
        wrapper.Type = "cat"
        data, err := json.Marshal(v)
        if err != nil {
            return nil, err
        }
        wrapper.Data = data
    default:
        return nil, fmt.Errorf("unknown animal type")
    }
    
    return json.Marshal(wrapper)
}

func UnmarshalAnimal(data []byte) (Animal, error) {
    var wrapper AnimalWrapper
    if err := json.Unmarshal(data, &wrapper); err != nil {
        return nil, err
    }
    
    switch wrapper.Type {
    case "dog":
        var dog Dog
        if err := json.Unmarshal(wrapper.Data, &dog); err != nil {
            return nil, err
        }
        return &dog, nil
    case "cat":
        var cat Cat
        if err := json.Unmarshal(wrapper.Data, &cat); err != nil {
            return nil, err
        }
        return &cat, nil
    default:
        return nil, fmt.Errorf("unknown animal type: %s", wrapper.Type)
    }
}

对于YAML支持，实现类似的编解码：

func MarshalAnimalYAML(a Animal) ([]byte, error) {
    var result map[string]interface{}
    
    switch v := a.(type) {
    case *Dog:
        result = map[string]interface{}{
            "type": "dog",
            "data": v,
        }
    case *Cat:
        result = map[string]interface{}{
            "type": "cat",
            "data": v,
        }
    default:
        return nil, fmt.Errorf("unknown animal type")
    }
    
    return yaml.Marshal(result)
}

func UnmarshalAnimalYAML(data []byte) (Animal, error) {
    var wrapper struct {
        Type string `yaml:"type"`
        Data map[string]interface{} `yaml:"data"`
    }
    
    if err := yaml.Unmarshal(data, &wrapper); err != nil {
        return nil, err
    }
    
    switch wrapper.Type {
    case "dog":
        dataBytes, _ := json.Marshal(wrapper.Data)
        var dog Dog
        if err := json.Unmarshal(dataBytes, &dog); err != nil {
            return nil, err
        }
        return &dog, nil
    case "cat":
        dataBytes, _ := json.Marshal(wrapper.Data)
        var cat Cat
        if err := json.Unmarshal(dataBytes, &cat); err != nil {
            return nil, err
        }
        return &cat, nil
    default:
        return nil, fmt.Errorf("unknown animal type: %s", wrapper.Type)
    }
}

使用示例：

func main() {
    // JSON序列化示例
    dog := &Dog{Name: "Rex", Breed: "German Shepherd"}
    
    jsonData, err := MarshalAnimal(dog)
    if err != nil {
        panic(err)
    }
    fmt.Printf("JSON: %s\n", jsonData)
    
    animal, err := UnmarshalAnimal(jsonData)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Animal speaks: %s\n", animal.Speak())
    
    // YAML序列化示例
    cat := &Cat{Name: "Whiskers", Color: "Black"}
    
    yamlData, err := MarshalAnimalYAML(cat)
    if err != nil {
        panic(err)
    }
    fmt.Printf("YAML:\n%s\n", yamlData)
    
    animal2, err := UnmarshalAnimalYAML(yamlData)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Animal speaks: %s\n", animal2.Speak())
}

对于BSON格式，可以使用类似的方法，只需替换编解码器。这种模式的关键是使用类型字段来标识具体类型，并在反序列化时根据类型字段创建正确的结构体实例。