Go - 解码JSON,因为它仍然通过net/http流式传输

Question

在过去,我使用go以如下所示的方式从API端点解码JSON.

client := &http.Client{}

req, err := http.NewRequest("GET", "https://some/api/endpoint", nil)
res, err := client.Do(req)
defer res.Body.Close()

buf, _ := ioutil.ReadAll(res.Body)

// ... Do some error checking etc ...

err = json.Unmarshal(buf, &response)

我很快就要开发一个端点,它可以按以下格式向我发送几兆字节的JSON数据.

{
    "somefield": "value",
    "items": [
        { LARGE OBJECT },
        { LARGE OBJECT },
        { LARGE OBJECT },
        { LARGE OBJECT },
        ...
    ]
}

JSON在某些时候将包含一个大的,任意长度的对象数组.我想将这些对象中的每一个分别放入消息队列中.我不需要解码对象本身.

如果我使用我的常规方法,这将在解码之前将整个响应加载到内存中.

是否有一种很好的方法可以拆分每个LARGE OBJECT项目,因为响应仍在流入并将其发送到队列中？我这样做是为了避免在内存中保存尽可能多的数据.

谢谢!

Answer 1

可以使用解码JSON流json.Decoder.

有了Decoder.Decode(),我们可以读取(解组)单个值,而无需使用和解组整个流.这很酷,但您的输入是"单个"JSON对象,而不是一系列JSON对象,这意味着调用Decoder.Decode()将尝试用所有项(大对象)解组完整的JSON对象.

我们想要的是对单个JSON对象进行部分,即时处理.为此,我们可以使用Decoder.Token()哪个解析(提前)JSON输入流中的下一个后续标记并返回它.这称为事件驱动的解析.

当然,我们必须"处理"(解释并采取行动)令牌,并构建一个"状态机",以跟踪我们正在处理的JSON结构中的位置.

这是一个解决您问题的实现.

我们将使用以下JSON输入:

{
    "somefield": "value",
    "otherfield": "othervalue",
    "items": [
        { "id": "1", "data": "data1" },
        { "id": "2", "data": "data2" },
        { "id": "3", "data": "data3" },
        { "id": "4", "data": "data4" }
    ]
}

并阅读items,这种类型的"大对象":

type LargeObject struct {
    Id   string `json:"id"`
    Data string `json:"data"`
}

我们还将解析和解释JSON对象中的其他字段,但我们只会记录/打印它们.

为了简洁和简单的错误处理,我们将使用这个辅助错误处理函数:

he := func(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

现在让我们看看一些动作.在下面的示例中为了简洁起见并在Go Playground上进行工作演示,我们将从一个string值中读取.要从实际的HTTP响应体中读取,我们只需要更改一行,这就是我们创建的方式json.Decoder:

dec := json.NewDecoder(res.Body)

所以演示:

dec := json.NewDecoder(strings.NewReader(jsonStream))
// We expect an object
t, err := dec.Token()
he(err)
if delim, ok := t.(json.Delim); !ok || delim != '{' {
    log.Fatal("Expected object")
}

// Read props
for dec.More() {
    t, err = dec.Token()
    he(err)
    prop := t.(string)
    if t != "items" {
        var v interface{}
        he(dec.Decode(&v))
        log.Printf("Property '%s' = %v", prop, v)
        continue
    }

    // It's the "items". We expect it to be an array
    t, err := dec.Token()
    he(err)
    if delim, ok := t.(json.Delim); !ok || delim != '[' {
        log.Fatal("Expected array")
    }
    // Read items (large objects)
    for dec.More() {
        // Read next item (large object)
        lo := LargeObject{}
        he(dec.Decode(&lo))
        fmt.Printf("Item: %+v\n", lo)
    }
    // Array closing delim
    t, err = dec.Token()
    he(err)
    if delim, ok := t.(json.Delim); !ok || delim != ']' {
        log.Fatal("Expected array closing")
    }
}

// Object closing delim
t, err = dec.Token()
he(err)
if delim, ok := t.(json.Delim); !ok || delim != '}' {
    log.Fatal("Expected object closing")
}

这将产生以下输出:

2009/11/10 23:00:00 Property 'somefield' = value
2009/11/10 23:00:00 Property 'otherfield' = othervalue
Item: {Id:1 Data:data1}
Item: {Id:2 Data:data2}
Item: {Id:3 Data:data3}
Item: {Id:4 Data:data4}

在Go Playground上试试完整的工作示例.