对未知数据类型进行反序列化

Golang小白一枚，正在不断学习积累知识，现将学习到的知识记录一下，也是将我的所得分享给大家！而今天这篇文章《对未知数据类型进行反序列化》带大家来了解一下##content_title##，希望对大家的知识积累有所帮助，从而弥补自己的不足，助力实战开发！

我正在 go 中编写一个包，以使用特定类型的传输在服务之间发送消息。

我希望程序包不理解所发送消息的类型。 我的第一个想法是将消息对象序列化为 json，发送该消息，在接收端反序列化，然后将 go 对象（作为 interface{}）传递给订阅代码。

序列化不是问题，但我不知道通用包代码如何反序列化消息，因为它不知道类型。我想到使用 reflect typeof() ，并将该值作为消息的一部分传递。但我不知道如何实现这一点，因为 type 是一个接口，并且实现的 rtype 未导出。

如果接收应用获得 interface{}，它无论如何都必须检查类型，所以也许它应该只进行反序列化。或者接收者可以提供反射类型以便包可以反序列化？

或者它可以为接收者提供字段名称到值的映射，但我更喜欢实际类型。

有什么建议吗？

让我添加一个例子：

我有一个用于发送不同类型对象的更改通知的 go 通道。由于 go 不支持标记联合，因此我将通道类型定义为：

type UpdateInfo struct {
    UpdateType UpdateType
    OldObject interface{}
    NewObject interface{}
}

通道的接收端获取一个 updateinfo，其中 oldobject 和 newobject 作为发送的实际具体对象类型。

我想将其扩展到应用程序之间的工作，其中传输将通过消息队列来支持发布/订阅、多个消费者等。

解决方案

tl;dr

只需使用 json.unmarshal。您可以使用您的传输协议对其进行简单包装，并在调用者的预构建 json 字节和 v 接口{} 参数上调用 json.unmarshal（或使用 json.decoder 实例，使用 d.decode）。

有点长，有一个例子

考虑一下 json.Unmarshal 如何发挥自己的魔力。它的第一个参数是 json (data []byte)，但第二个参数的类型是 interface{}:

func unmarshal(data []byte, v interface{}) error

正如文档继续所述，如果 v 确实只是一个 接口{}：

要将 json 解组为接口值，unmarshal 将以下内容之一存储在接口值中：

bool, for json booleans
float64, for json numbers
string, for json strings
[]interface{}, for json arrays
map[string]interface{}, for json objects
nil for json null

但如果 v 具有底层具体类型，例如 type mydata struct { ... }，则它会更奇特。仅当 v 的基础类型是 interface{} 时，它才会执行上述操作。

它的 actual implementation 特别复杂，因为它经过优化可以同时进行去 json 化和分配到目标对象中。但原则上，它主要是接口值的底层（具体）类型上的一个大类型转换。

同时，您在问题中描述的是，您将首先反序列化为通用 json（这实际上意味着 interface{} 类型的变量），然后执行您自己的分配out将 json 预解码为 interface{} 类型的另一个变量，其中您自己的解码器的类型签名为：

func xxxdecoder(/* maybe some args here, */ v interface{}) error {
    var predecoded interface{}

    // get some json bytes from somewhere into variable `data`
    err := json.unmarshal(data, &predecoded)

    // now emulate json.unmarshal by getting field names and assigning
    ... this is the hard part ...
}

然后您可以通过编写以下内容调用此代码：

type mydata struct {
    field1 int    `xxx:"field1"`
    field2 string `xxx:"field2"`
}

以便您知道 json 对象键“field1”应使用整数填充您的 field1 字段，并且 json 对象键“field2”应使用字符串填充您的 field2 字段：

func whatever() {
    var x mydata
    err := xxxdecode(..., &x)
    if err != nil { ... handle error ... }
    ... use x.field1 and x.field2 ...
}

但这很愚蠢。你可以直接写：

type mydata struct {
    field1 int    `json:"field1"`
    field2 string `json:"field2"`
}

（或者甚至省略标签，因为字段名称是默认的 json 标签），然后执行以下操作：

func xxxdecode(..., v interface{}) error {
    ... get data bytes as before ...
    return json.unmarshal(data, v)
}

换句话说，只需在相关数据结构中提供 json 标签，让 json.unmarshal 完成所有工作。您仍然可以从 json.marshal 和 json.unmarshal 获取并通过特殊传输传输 json 数据字节。你负责发送和接收。 json.marshal 和 json.unmarshal 完成所有艰苦的工作：您不必碰它！

了解 json.unmarshal 的工作原理仍然很有趣

跳转到 around line 660 of encoding/json/decode.go，您将在其中找到处理 json“对象”的内容（{ 后跟 } 或表示键的字符串），例如：

func (d *decodestate) object(v reflect.value) error {

有一些机制可以处理极端情况（包括 v 可能不可设置和/或可能是应该遵循的指针），然后确保 v 是 map[t1]t2 或 struct ，如果它是一个映射，那么它是合适的 - t1 和 t2 在解码对象中的“key”:value 项时都可以工作。

如果一切顺利，它将进入从第 720 行开始的 json 键值扫描循环（for {，它将根据需要中断或返回）。每次执行此循环时，代码都会首先读取 json 键，将 : 和值部分留到稍后使用。

如果我们解码为 struct，解码器现在使用结构体的字段（名称和 json:"..." 标签）来查找 reflect.value，我们将使用它直接存储到字段中。 ¹ 这是 subv，通过调用 v.field(i) 来找到正确的 i，并使用一些稍微复杂的 goo 来处理嵌入的匿名 structs 和指针跟随。不过，其核心只是 subv = v.field(i)，其中 i 是结构中此键命名的任何字段。因此 subv 现在是一个 reflect.value ，它表示实际的结构实例的值，我们应该在解码 json 键值对的值部分后设置该值。

如果我们解码为映射，我们将首先将值解码为临时值，然后在解码后将其存储到映射中。与结构体字段存储共享这一点会很好，但我们需要一个不同的 reflect 函数来将存储存储到地图中：v.SetMapIndex，其中 v 是地图的 reflect.value 。这就是为什么对于地图，subv 指向临时 elem。

我们现在已准备好将实际值转换为目标类型，因此我们返回到 json 字节并使用冒号 : 字符并读取 json 值。我们获取该值并将其存储到我们的存储位置（subv）。这是从第 809 行开始的代码（if destring {）。实际的分配是通过解码器函数（第 908 行的 d.literalstore 或第 412 行的 d.value）完成的，这些函数在存储时实际上对 json 值进行解码。请注意，只有 d.literalstore 真正存储值 - d.value 调用 d.array、d.object 或 d.literalstore 来递归执行工作（如果需要）。

d.literalstore 因此包含许多 switch v.kind()s：它解析 null 或 true 或 false 或整数、字符串或数组，然后确保它可以将结果值存储到 v 中。种类（ )，并根据刚刚解码的内容和实际 v.kind() 的组合选择如何将该结果值存储到 v.kind() 中。所以这里有一些组合爆炸，但它完成了工作。

如果所有这些都有效，并且我们正在解码为映射，那么我们现在可能需要处理临时的类型，找到真正的键，并将转换后的值存储到映射中。这就是第 830 行 (if v.kind() == reflect.map {) 到第 867 处最后一个大括号的内容。

¹要查找字段，我们首先查看 encoding/json/encode.go 以查找 cachedtypefields。它是 typeFields 的缓存版本。这是找到 json 标签并将其放入切片的位置。结果通过 cachedtypefields 缓存在由 struct 类型的反射类型值索引的映射中。因此，我们第一次使用 struct 类型时得到的是缓慢查找，然后是快速查找，以获得有关如何进行解码的信息片段。该信息片从 json-tag-or-field name 映射到： field;类型;是否是匿名结构的子字段；等等：我们需要知道如何正确解码它或在编码方面对其进行编码的所有信息。 （我并没有仔细研究这段代码。）

您可以在同一缓冲区上对多个消息进行编码/解码，无论是“gob”还是“json”还是其他编码。

p>

假设您想要支持一组有限的具体类型，您始终可以首先对类型标记进行编码，然后对实际对象进行编码。这样decode就可以先解码type标签，然后根据它的值，决定如何解码下一项。

// encoder side

enc := json.NewEncoder(buffer) // or gob.NewEncoder(buffer)
enc.Encode("player")
enc.Encode(playerInstance)


// decoder side

dec := json.NewDecoder(buffer) // or gob.NewDecoder(buffer)
var tag string
dec.Decode(&tag)
switch tag {
    case "player":
        var playerInstance Player
        dec.Decode(&player)
        // do something with it
    case "somethingelse":
        // decode something else
}

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。