在不使用反射或复制代码的情况下从多个 JSON 数组解组实体

Question

我正在制作一个需要获取分页结果的 JSON API 包装器客户端，其中 URL 到下一页是由上一页提供的。为了减少共享相同响应格式的 100 多个实体的代码重复，我希望有一个客户端方法可以从所有分页页面中获取和解组不同的实体。

我目前在简化（伪）版本中的方法（没有错误等）：

type ListResponse struct {
    Data struct {
        Results []interface{} `json:"results"`
        Next    string        `json:"__next"`
    } `json:"d"`
}

func (c *Client) ListRequest(uri string) listResponse ListResponse {
    // Do a http request to uri and get the body
    body := []byte(`{ "d": { "__next": "URL", "results": []}}`)
    json.NewDecoder(body).Decode(&listResponse)
}

func (c *Client) ListRequestAll(uri string, v interface{}) {
    a := []interface{}
    f := c.ListRequest(uri)
    a = append(a, f.Data.Results...)

    var next = f.Data.Next
    for next != "" {
        r := c.ListRequest(next)
        a = append(a, r.Data.Results...)
        next = r.Data.Next
    }

    b, _ := json.Marshal(a)
    json.Unmarshal(b, v)
}

// Then in a method requesting all results for a single entity
var entities []Entity1
client.ListRequestAll("https://foo.bar/entities1.json", &entities)

// and somewehere else
var entities []Entity2
client.ListRequestAll("https://foo.bar/entities2.json", &entities)

然而，问题是这种方法效率低下并且使用太多内存等，即首先在一般 ListResponse 中解组，结果为 []interface{}（查看下一个 URL并将结果连接到一个切片中），然后编组 []interface{} 以便在 []Entity1.

的目标切片中直接向后解组

我也许可以使用 reflect 包来动态生成这些实体的新切片，直接解组到它们中，然后 concat/append 它们，但是如果我理解正确，我最好不要使用 reflect 除非绝对必要...

Answer 1

看看 encoding/json 包中的 RawMessage 类型。它允许您将 json 值的解码推迟到以后。例如：

Results []json.RawMessage `json:"results"`

甚至...

Results json.RawMessage `json:"results"`

由于 json.RawMessage 只是一个字节片段，这将比您要解组的中间 []interface{} 更有效。

至于第二部分，关于如何在给定多个页面读取的情况下将这些 assemble 放入单个切片中，您可以通过让调用者使用切片类型的切片来向调用者提出这个问题。

// Then in a method requesting all results for a single entity
var entityPages [][]Entity1
client.ListRequestAll("https://foo.bar/entities1.json", &entityPages)

这仍然存在您的一般设计存在的无限内存消耗问题，但是，因为您必须一次加载所有页面/项目。您可能需要考虑更改为 Open/Read 抽象，例如处理文件。您将有一些 Open 方法，returns 另一种类型，如 os.File，提供了一种一次读取数据子集的方法，同时根据需要在内部请求页面和缓冲。

也许是这样的（未经测试）：

type PagedReader struct {
  c *Client

  buffer []json.RawMessage

  next string
}

func (r *PagedReader) getPage() {
  f := r.c.ListRequest(r.next)
  r.next = f.Data.Next
  r.buffer = append(r.buffer, f.Data.Results...)
}

func (r *PagedReader) ReadItems(output []interface{}) int {
  for len(output) > len(buffer) && r.next != "" {
    r.getPage()
  }

  n := 0
  for i:=0;i<len(output)&&i< len(r.buffer);i++ {
    json.Unmarshal(r.buffer[i], output[i] )
    n++
  }
  r.buffer = r.buffer[n:]
  return n
}

在不使用反射或复制代码的情况下从多个 JSON 数组解组实体

Unmarshalling Entities from multiple JSON arrays without using reflect or duplicating code

json

go

unmarshalling

go-reflect