利用 Go 实现泛型类型的 JSON 扁平化的方法

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

我正在尝试在 go 中实现 hal，只是想看看是否可以。这意味着我有一个 hal 类型，它在有效负载上是通用的，并且还包含 _links：

type hal[t any] struct {
    payload t
    links   linkset `json:"_links,omitempty"`
}

在 hal 规范中，有效负载实际上位于顶层，而不是嵌套在其中 - 例如塞壬会的。这意味着给出以下内容：

type testpayload struct {
    name   string `json:"name"`
    answer int    `json:"answer"`
}

    hal := hal[testpayload]{
        payload: testpayload{
            name:   "graham",
            answer: 42,
        },
        links: linkset{
            "self": {
                {href: "/"},
            },
        },
    }

生成的 json 应该是：

{
    "name": "Graham",
    "answer": 42,
    "_links": {
      "self": {"href": "/"}
    }
}

但是我找不到一个好的方法来让这个 json 编组工作。

我看到了将有效负载嵌入为匿名成员的建议，如果它不是通用的，那么效果很好。不幸的是，您不能以这种方式嵌入泛型类型，因此这是行不通的。

我可能可以编写一个 marshaljson 方法来完成这项工作，但我想知道是否有任何标准方法可以实现此目的？

我有一个包含此工作代码的演示链接，看看它是否有帮助：https://go.dev/play/p/lork5wv-tri

干杯

正确答案

是的，遗憾的是您无法嵌入类型参数 t。我还认为，在一般情况下，您不应该尝试展平输出 json。通过使用 any 约束 t，您实际上承认任何类型，但并非所有类型都有字段可以提升到您的 hal 结构中。

这在语义上是不一致的。

如果您尝试嵌入不带字段的类型，则输出 json 将有所不同。使用 reflect.structof 的解决方案作为示例，没有什么可以阻止我实例化 hal[[]int]{ payload: []int{1,2,3}, links: ... }，在这种情况下，输出将是：

{"x":[1,2,3],"links":{"self":{"href":"/"}}}

这会使您的 json 序列化更改为用于实例化 t 的类型，这对于阅读您代码的人来说不容易发现。代码不太可预测，并且您正在有效地对抗类型参数提供的泛化。

使用命名字段 payload t 更好，如下：

• 输出 json 始终（对于大多数意图和目的）与实际结构一致
• 解组还可以保持可预测的行为
• 代码的可扩展性不是问题，因为您不必重复 hal 的所有字段来构建匿名结构

otoh，如果您的要求是精确将结构编组为扁平化，并且使用键来编组其他所有内容（就像 hal 类型的情况一样），至少通过检查 reflect 使其显而易见marshaljson 实现中的 .valueof(hal.payload).kind() ==reflect.struct ，并为 t 可能的其他内容提供默认情况。必须在 jsonunmarshal 中重复。

这是一个带有反射的解决方案，当 t 不是结构时，该解决方案可以工作，并且当您向主结构添加更多字段时可以进行缩放：

// necessary to marshal hal without causing infinite loop
// can't declare inside the method due to a current limitation with go generics
type tmp[t any] hal[t]

func (h hal[t]) marshaljson() ([]byte, error) {
    // examine payload, if it isn't a struct, i.e. no embeddable fields, marshal normally
    v := reflect.valueof(h.payload)
    if v.kind() == reflect.pointer || v.kind() == reflect.interface {
        v = v.elem()
    }
    if v.kind() != reflect.struct {
        return json.marshal(tmp[t](h))
    }

    // flatten all fields into a map
    m := make(map[string]any)
    // flatten payload first
    for i := 0; i < v.numfield(); i++ {
        key := jsonkey(v.type().field(i))
        m[key] = v.field(i).interface()
    }
    // flatten the other fields
    w := reflect.valueof(h)
    // start at 1 to skip the payload field
    for i := 1; i < w.numfield(); i++ {
        key := jsonkey(w.type().field(i))
        m[key] = w.field(i).interface()
    }
    return json.marshal(m)
}

func jsonkey(field reflect.structfield) string {
    // trickery to get the json tag without omitempty and whatnot
    tag := field.tag.get("json")
    tag, _, _ = strings.cut(tag, ",")
    if tag == "" {
        tag = field.name
    }
    return tag
}

使用 hal[testpayload] 或 hal[*testpayload] 输出：

{"answer":42,"name":"graham","_links":{"self":{"href":"/"}}}

使用 hal[[]int] 输出：

{"payload":[1,2,3],"_links":{"self":{"href":"/"}}}

演示：https://go.dev/play/p/bWGXWj_rC5F

我会制作一个自定义 json 编解码器，在为有效负载生成的 json 末尾插入 _links 字段。

编组员。

type link struct {
    href string `json:"href"`
}

type linkset map[string]link

type hal[t any] struct {
    payload t
    links   linkset `json:"_links,omitempty"`
}

func (h hal[t]) marshaljson() ([]byte, error) {
    payloadjson, err := json.marshal(h.payload)
    if err != nil {
        return nil, err
    }
    if len(payloadjson) == 0 {
        return nil, fmt.errorf("empty payload")
    }
    if h.links != nil {
        return appendfield(payloadjson, "_links", h.links)
    }
    return payloadjson, nil
}

func appendfield[t any](raw []byte, fieldname string, v t) ([]byte, error) {
    // the json data must be braced in {}
    if raw[0] != '{' || raw[len(raw)-1] != '}' {
        return nil, fmt.errorf("not an object: %s", string(raw))
    }
    valjson, err := json.marshal(v)
    if err != nil {
        return nil, err
    }
    // add the field at the end of the json text
    result := bytes.newbuffer(raw[:len(raw)-1])
    // append `"<fieldname>":value`
    // insert comma if the `raw` object is not empty
    if len(raw) > 2 {
        result.writebyte(',')
    }
    // tag
    result.writebyte('"')
    result.writestring(fieldname)
    result.writebyte('"')
    // colon
    result.writebyte(':')
    // value
    result.write(valjson)
    // closing brace
    result.writebyte('}')
    return result.bytes(), nil
}

如果 payload 序列化为 json 对象以外的其他内容，编组器将返回错误。原因是编解码器只能将 _links 字段添加到对象。

解组器：

func (h *hal[t]) unmarshaljson(raw []byte) error {
    // unmarshal fields of the payload first.
    // unmarshal the whole json into the payload, it is safe:
    // decorer ignores unknow fields and skips "_links".
    if err := json.unmarshal(raw, &h.payload); err != nil {
        return err
    }
    // get "_links": scan trough json until "_links" field
    links := make(linkset)
    exists, err := extractfield(raw, "_links", &links)
    if err != nil {
        return err
    }
    if exists {
        h.links = links
    }
    return nil
}

func extractfield[t any](raw []byte, fieldname string, v *t) (bool, error) {
    // scan through json until field is found
    decoder := json.newdecoder(bytes.newreader(raw))
    t := must(decoder.token())
    // should be `{`
    if t != json.delim('{') {
        return false, fmt.errorf("not an object: %s", string(raw))
    }
    t = must(decoder.token())
    if t == json.delim('}') {
        // empty object
        return false, nil
    }
    for decoder.more() {
        name, ok := t.(string)
        if !ok {
            return false, fmt.errorf("must never happen: expected string, got `%v`", t)
        }
        if name != fieldname {
            skipvalue(decoder)
        } else {
            if err := decoder.decode(v); err != nil {
                return false, err
            }
            return true, nil
        }
        if decoder.more() {
            t = must(decoder.token())
        }
    }
    return false, nil
}

func skipvalue(d *json.decoder) {
    bracecnt := 0
    for d.more() {
        t := must(d.token())
        if t == json.delim('{') || t == json.delim('[') {
            bracecnt++
        }
        if t == json.delim('}') || t == json.delim(']') {
            bracecnt--
        }
        if bracecnt == 0 {
            return
        }
    }
}

解组器在非对象上也失败。需要读取_links字段。为此，输入必须是一个对象。

完整示例：https://go.dev/play/p/E3NN2T7Fbnm

func main() {
    hal := hal[testpayload]{
        payload: testpayload{
            name:   "graham",
            answer: 42,
        },
        links: linkset{
            "self": link{href: "/"},
        },
    }
    bz := must(json.marshal(hal))
    println(string(bz))

    var halout hal[testpayload]
    err := json.unmarshal(bz, &halout)
    if err != nil {
        println("decode failed: ", err.error())
    }
    fmt.printf("%#v\n", halout)
}

输出：

{"name":"Graham","answer":42,"_links":{"self":{"href":"/"}}}
main.HAL[main.TestPayload]{Payload:main.TestPayload{Name:"Graham", Answer:42}, Links:main.Linkset{"self":main.Link{Href:"/"}}}

到这里，我们也就讲完了《利用 Go 实现泛型类型的 JSON 扁平化的方法》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！