保持未解析JSON字段的Go语言最佳实践-Golang-PHP中文网

保持未解析JSON字段的Go语言最佳实践

碧海醫心

发布： 2025-10-29 13:51:01

原创

297人浏览过

保持未解析json字段的go语言最佳实践

本文介绍了在Go语言中处理JSON数据时，如何在结构体解码后，保留JSON中未被结构体定义的动态字段，并在重新编码为JSON时，将这些字段一并保留。文章探讨了利用`json.RawMessage`类型以及自定义`Unmarshaler`和`Marshaler`接口的实现方式，并简要提及了其他库提供的解决方案，旨在帮助开发者在处理复杂JSON数据时，兼顾结构化数据的便捷性和动态字段的完整性。

在Go语言中，使用encoding/json包处理JSON数据是非常常见的操作。然而，在某些场景下，我们希望能够将JSON数据解码到结构体中，对结构体中的字段进行操作，然后将修改后的结构体重新编码为JSON。但与此同时，JSON数据中可能包含一些结构体未定义的、动态的字段，我们希望在重新编码时，这些字段能够被完整地保留下来。本文将探讨几种实现这一目标的方法。

使用 json.RawMessage

json.RawMessage 类型允许我们延迟对JSON数据的解析。我们可以将JSON数据的一部分定义为json.RawMessage类型，这样在解码时，这部分数据就不会被立即解析，而是以原始JSON字符串的形式存储。在重新编码时，这部分数据会被原封不动地输出。

例如，假设我们有以下JSON数据：

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

{
  "name": "Joe Smith",
  "age": 42,
  "phone": "614-555-1212",
  "debug": true,
  "codeword": "wolf"
}

登录后复制

我们定义一个结构体Person，其中Address字段使用json.RawMessage类型：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name    string          `json:"name"`
    Age     uint            `json:"age"`
    Phone   string          `json:"phone"`
    Address json.RawMessage `json:"-"` // 使用 "-" 忽略 Address 字段，稍后手动处理
}

func main() {
    jsonData := []byte(`{
    "name": "Joe Smith",
    "age": 42,
    "phone": "614-555-1212",
    "debug": true,
    "codeword": "wolf"
}`)

    var p Person
    err := json.Unmarshal(jsonData, &p)
    if err != nil {
        fmt.Println("Error unmarshaling:", err)
        return
    }

    // 手动解析剩余字段到 Address
    var temp map[string]interface{}
    err = json.Unmarshal(jsonData, &temp)
    if err != nil {
        fmt.Println("Error unmarshaling to map:", err)
        return
    }

    // 删除已解析的字段
    delete(temp, "name")
    delete(temp, "age")
    delete(temp, "phone")

    // 将剩余字段重新编码为 json.RawMessage
    remainingData, err := json.Marshal(temp)
    if err != nil {
        fmt.Println("Error marshaling remaining data:", err)
        return
    }
    p.Address = remainingData

    // Happy birthday
    p.Age++

    data, err := json.Marshal(p)
    if err != nil {
        fmt.Println("Error marshaling:", err)
        return
    }

    fmt.Println(string(data))
}

登录后复制

在这个例子中，Address字段存储了JSON数据中除了name, age, phone之外的所有字段。在重新编码时，Address字段的内容会被原样输出，从而保留了未解析的字段。

Superflow Rewrite

AI辅助高效网站设计、协作、注释工具，迭代和发布网站的最快方式

查看详情

注意事项：

需要手动将未解析的字段解析到json.RawMessage中，这需要一些额外的代码。
json.RawMessage 实际上存储的是字节数组，因此在需要访问其中的数据时，需要再次进行解析。

实现自定义 Unmarshaler 和 Marshaler

另一种方法是实现自定义的 Unmarshaler 和 Marshaler 接口。通过自定义解码和编码逻辑，我们可以控制JSON数据的解析和生成过程。

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name    string                 `json:"name"`
    Age     uint                   `json:"age"`
    Phone   string                 `json:"phone"`
    Extra   map[string]interface{} `json:"-"` // 使用 "-" 忽略 Extra 字段，稍后手动处理
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (p *Person) UnmarshalJSON(data []byte) error {
    // 定义一个临时类型，避免递归调用 UnmarshalJSON
    type Alias Person
    aux := &Alias{}
    if err := json.Unmarshal(data, aux); err != nil {
        return err
    }

    // 将基本字段复制到 Person 结构体
    p.Name = aux.Name
    p.Age = aux.Age
    p.Phone = aux.Phone

    // 将 JSON 数据解码到 map[string]interface{} 中
    var temp map[string]interface{}
    if err := json.Unmarshal(data, &temp); err != nil {
        return err
    }

    // 将结构体中已经存在的字段从 map 中删除
    delete(temp, "name")
    delete(temp, "age")
    delete(temp, "phone")

    // 将剩余的字段存储到 Extra 字段中
    p.Extra = temp
    return nil
}

// MarshalJSON implements the json.Marshaler interface.
func (p *Person) MarshalJSON() ([]byte, error) {
    // 定义一个临时类型，避免递归调用 MarshalJSON
    type Alias Person
    aux := &Alias{
        Name:  p.Name,
        Age:   p.Age,
        Phone: p.Phone,
    }

    // 将 Person 结构体编码为 JSON 数据
    data, err := json.Marshal(aux)
    if err != nil {
        return nil, err
    }

    // 将 JSON 数据解码到 map[string]interface{} 中
    var temp map[string]interface{}
    if err := json.Unmarshal(data, &temp); err != nil {
        return nil, err
    }

    // 将 Extra 字段中的数据添加到 map 中
    for k, v := range p.Extra {
        temp[k] = v
    }

    // 将 map 重新编码为 JSON 数据
    return json.Marshal(temp)
}

func main() {
    jsonData := []byte(`{
    "name": "Joe Smith",
    "age": 42,
    "phone": "614-555-1212",
    "debug": true,
    "codeword": "wolf"
}`)

    var p Person
    err := json.Unmarshal(jsonData, &p)
    if err != nil {
        fmt.Println("Error unmarshaling:", err)
        return
    }

    // Happy birthday
    p.Age++

    data, err := json.Marshal(p)
    if err != nil {
        fmt.Println("Error marshaling:", err)
        return
    }

    fmt.Println(string(data))
}

登录后复制

在这个例子中，UnmarshalJSON 方法首先将JSON数据解码到结构体的基本字段中，然后将剩余的字段存储到 Extra 字段中。MarshalJSON 方法首先将结构体的基本字段编码为JSON数据，然后将 Extra 字段中的数据添加到JSON数据中，最后将整个JSON数据返回。

注意事项：

实现 Unmarshaler 和 Marshaler 接口需要编写更多的代码，但可以更灵活地控制JSON数据的解析和生成过程。
需要注意避免递归调用 UnmarshalJSON 和 MarshalJSON 方法，可以使用类型别名来解决这个问题。

总结

本文介绍了在Go语言中保持未解析JSON字段的两种方法：使用 json.RawMessage 和实现自定义 Unmarshaler 和 Marshaler 接口。选择哪种方法取决于具体的应用场景和需求。如果只需要简单地保留未解析的字段，可以使用 json.RawMessage。如果需要更灵活地控制JSON数据的解析和生成过程，可以实现自定义 Unmarshaler 和 Marshaler 接口。

此外，一些第三方库也提供了类似的功能，例如 labix.org/v2/mgo/bson 库中的 inline tag flag，可以方便地将未解析的字段合并到结构体中。开发者可以根据自己的需求选择合适的解决方案。

以上就是保持未解析JSON字段的Go语言最佳实践的详细内容，更多请关注php中文网其它相关文章！