如何在 Go 中高效解码大型流式 JSON？

如何在 Go 中解码流式 JSON

处理大型 JSON 响应时，在解码之前将整个响应加载到内存中并不理想。处理大型 JSON 有效负载时，使用 ioutil.ReadAll 函数可能会导致内存问题。本文将探讨如何在 JSON 数据流入时对其进行动态解码，避免内存消耗问题。

使用 json.Decoder 进行 JSON 流

Go 标准库中的 json.Decoder 提供了增量解析 JSON 流的能力。这是通过 Decoder.Token() 方法实现的。

Decoder.Token() 方法返回 JSON 流中的下一个令牌，而不消耗它。这允许选择性解析 JSON 数据和事件驱动处理。

处理 JSON 结构

事件驱动解析需要状态机来跟踪 JSON 结构中的当前位置。我们可以使用此状态机来处理流中出现的 JSON 数据的不同部分。

例如，假设我们收到以下格式的 JSON 响应：

{
    "property1": "value1",
    "property2": "value2",
    "array": [
        { "item1": "value3" },
        { "item2": "value4" }
    ]
}

我们可以编写一个函数来增量解析此 JSON 流并单独处理数组元素：

func processJSONStream(stream io.Reader) {
    decoder := json.NewDecoder(stream)

    state := "start"
    for decoder.More() {
        token, err := decoder.Token()
        if err != nil {
            log.Fatal(err)
        }

        switch state {
        case "start":
            if delim, ok := token.(json.Delim); ok && delim == '{' {
                state = "object"
            } else {
                log.Fatal("Expected object")
            }
        case "object":
            switch t := token.(type) {
            case json.Delim:
                if t == '}' {
                    // End of object
                    state = "end"
                } else if t == ',' {
                    // Next property
                    continue
                } else if t == '[' {
                    // Array found
                    state = "array"
                }

                if t == ':' {
                    // Property value expected
                    state = "prop_value"
                }
            case string:
                // Property name
                fmt.Printf("Property '%s'\n", t)
            default:
                // Property value
                fmt.Printf("Value: %v\n", t)
            }
        case "array":
            if delim, ok := token.(json.Delim); ok && delim == ']' {
                // End of array
                state = "object"
            } else if token == json.Delim('{') {
                // Array item object
                fmt.Printf("Item:\n")
                state = "item"
            }
        case "item":
            switch t := token.(type) {
            case json.Delim:
                if t == '}' {
                    // End of item object
                    fmt.Printf("\n")
                    state = "array"
                } else if t == ',' {
                    // Next item property
                    fmt.Printf(",\n")
                    continue
                }
            case string:
                // Item property name
                fmt.Printf("\t'%s'", t)
            default:
                // Item property value
                fmt.Printf(": %v", t)
            }
        case "prop_value":
            // Decode the property value
            var value interface{}
            if err := decoder.Decode(&value); err != nil {
                log.Fatal(err)
            }
            fmt.Printf("Value: %v\n", value)
            state = "object"
        }
    }
}

当使用 JSON 响应调用时，此函数将打印属性名称和值，以及数组中的各个项目。

结论

在事件驱动处理中使用 json.Decoder 和 Decoder.Token() 允许我们解析大数据JSON 增量响应，避免内存消耗问题，并在数据流入时实现高效处理。

以上是如何在 Go 中高效解码大型流式 JSON？的详细内容。更多信息请关注PHP中文网其他相关文章！