Go语言中如何将嵌套JSON对象解组为原始字符串或字节切片

本文探讨了在go语言中，当需要将json数据中的嵌套对象作为原始字节切片或字符串处理，而非进行完整解析时的解决方案。通过引入`encoding/json`包中的`json.rawmessage`类型，可以有效地避免“无法将对象解组到go值类型[]uint8”的错误，实现对特定json字段的延迟解码或作为不透明数据传输。

在Go语言中处理JSON数据是日常开发中的常见任务。encoding/json包提供了强大的序列化（Marshal）和反序列化（Unmarshal）功能。然而，在某些特定场景下，我们可能不希望对JSON结构中的所有嵌套对象都进行完整的类型解析，而是希望将某个嵌套对象直接视为一个原始的JSON字符串或字节切片。例如，当JSON结构中包含一个我们暂时不需要解析、或者其内部结构不确定的动态字段时，这种需求尤为突出。

遇到的问题

假设我们有以下JSON数据：

{
    "id"  : 15,
    "foo" : { "foo": 123, "bar": "baz" }
}

我们希望将其解组到一个Go结构体中，其中id字段正常解析为int64，而foo字段（一个嵌套的JSON对象）则被视为一个原始的字节切片（[]byte）或字符串，而不是将其内部的foo和bar字段进一步解析。

如果直接尝试将foo字段定义为[]byte类型：

立即学习“go语言免费学习笔记（深入）”；

type Bar struct {
    ID  int64  `json:"id"`
    Foo []byte `json:"foo"`
}

在执行json.Unmarshal时，Go运行时会尝试将JSON对象{"foo": 123, "bar": "baz"}直接解组到[]byte类型中，这通常会导致以下错误：

json: cannot unmarshal object into Go value of type []uint8

这个错误明确指出，JSON解码器无法将一个JSON对象直接转换为Go语言的字节切片类型，因为它期望的是一个JSON数组或字符串，而非对象。

解决方案：使用 json.RawMessage

为了解决这个问题，Go语言的encoding/json包提供了一个特殊的类型：json.RawMessage。

云雀语言模型

云雀是一款由字节跳动研发的语言模型，通过便捷的自然语言交互，能够高效的完成互动对话

54

查看详情

json.RawMessage是一个[]byte类型，它实现了json.Marshaler和json.Unmarshaler接口。它的核心作用是：

• 延迟解码： 当json.Unmarshal遇到json.RawMessage类型的字段时，它不会尝试解析该字段的JSON内容，而是直接将其原始的JSON字节数据存储到RawMessage中。
• 预计算编码： 同样，当json.Marshal遇到json.RawMessage时，它会直接将RawMessage中存储的字节数据作为JSON输出，而不会再次进行编码。

这意味着，json.RawMessage允许我们“捕获”JSON结构中的一部分，并将其作为原始的JSON字节流保存起来，以便后续按需处理。

实施示例

下面是使用json.RawMessage来解决上述问题的完整Go语言示例：

package main

import (
    "encoding/json"
    "fmt"
)

// 模拟的JSON数据
var jsonStr = []byte(`{
    "id"  : 15,
    "foo" : { "foo": 123, "bar": "baz" }
}`)

// 定义结构体，使用 json.RawMessage 来存储嵌套对象
type Bar struct {
    ID  int64           `json:"id"`
    Foo json.RawMessage `json:"foo"` // 使用 json.RawMessage 存储原始JSON对象
}

func main() {
    var bar Bar

    // 执行JSON解组
    err := json.Unmarshal(jsonStr, &bar)
    if err != nil {
        panic(fmt.Errorf("解组失败: %w", err))
    }

    // 打印解组后的结构体
    fmt.Printf("解组结果: %+v\n", bar)
    // 打印 Foo 字段的类型和内容（原始字节）
    fmt.Printf("Foo 字段类型: %T\n", bar.Foo)
    fmt.Printf("Foo 字段内容 (字符串形式): %s\n", bar.Foo)

    // 如果需要，可以进一步解组 Foo 字段
    type NestedFoo struct {
        Foo int    `json:"foo"`
        Bar string `json:"bar"`
    }
    var nested NestedFoo
    err = json.Unmarshal(bar.Foo, &nested)
    if err != nil {
        panic(fmt.Errorf("进一步解组 Foo 失败: %w", err))
    }
    fmt.Printf("进一步解组 Foo 结果: %+v\n", nested)
}

输出结果：

解组结果: {ID:15 Foo:[123 32 34 102 111 111 34 58 32 49 50 51 44 32 34 98 97 114 34 58 32 34 98 97 122 34 32 125]}
Foo 字段类型: json.RawMessage
Foo 字段内容 (字符串形式): { "foo": 123, "bar": "baz" }
进一步解组 Foo 结果: {Foo:123 Bar:baz}

从输出可以看出，Foo字段成功地存储了原始的JSON对象字节，并且可以后续根据需要进行二次解组。

注意事项与应用场景

1. 延迟解析： json.RawMessage非常适合处理那些结构不固定、或者只有在特定条件下才需要解析的JSON字段。它允许你先获取整个JSON，然后根据业务逻辑决定是否以及如何解析其中的某些部分。
2. 传递原始JSON： 在构建API网关或代理服务时，你可能需要接收一个JSON请求，提取部分信息，然后将请求体中的某个嵌套JSON对象原封不动地转发给另一个微服务。json.RawMessage是实现这一目标的高效方式。
3. 性能考量： 对于非常大的JSON数据，如果其中只有一小部分是我们需要立即处理的，使用json.RawMessage可以避免对不必要的部分进行完整的解码，从而提高性能。
4. 错误处理： 当使用json.RawMessage存储原始数据后，对其进行二次解组时，仍然需要进行适当的错误处理，因为原始数据本身可能不符合预期的结构。

总结

json.RawMessage是Go语言encoding/json包中一个强大且实用的工具，它为处理复杂的、动态的或部分未知的JSON结构提供了优雅的解决方案。通过将嵌套的JSON对象解组为json.RawMessage，开发者可以有效地控制JSON数据的解析粒度，实现延迟解码，并避免因类型不匹配而导致的解组错误。掌握json.RawMessage的使用，将显著提升你在Go语言中处理JSON数据的灵活性和健壮性。

以上就是Go语言中如何将嵌套JSON对象解组为原始字符串或字节切片的详细内容，更多请关注php中文网其它相关文章！