在 Go 中维护未解析的 JSON 字段的最佳方法-Golang-PHP中文网

在 Go 中维护未解析的 JSON 字段的最佳方法

花韻仙語

发布： 2025-10-29 14:31:13

原创

914人浏览过

在 go 中维护未解析的 json 字段的最佳方法

本文探讨了在 Go 语言中使用 `encoding/json` 包处理 JSON 数据时，如何保留结构体中未定义的、动态的 JSON 字段。我们将介绍使用 `json.RawMessage` 类型以及自定义 `Unmarshaler` 和 `Marshaler` 接口的两种方法，以便在解码和编码 JSON 数据时，能够灵活地处理未知字段，从而避免完全使用 `map[string]interface{}` 带来的复杂性。

在 Go 语言中处理 JSON 数据时，我们经常会遇到需要将 JSON 数据解码到结构体中，进行一些操作，然后再将修改后的数据编码回 JSON 格式的需求。然而，JSON 数据中可能包含一些我们预先不知道或者不需要在结构体中定义的字段。如果我们简单地使用 json.Unmarshal 将 JSON 数据解码到结构体中，那么这些未定义的字段将会丢失。本文将介绍几种在 Go 中维护这些未解析 JSON 字段的方法，以便在重新编码时能够保留这些字段。

使用 json.RawMessage

json.RawMessage 类型允许我们将 JSON 数据的一部分表示为原始的 JSON 数据，而不进行具体的解码。这使得我们可以在结构体中定义一个 json.RawMessage 类型的字段，用于存储我们不关心的 JSON 部分。

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

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

登录后复制

我们只想处理 name、age 和 address 字段，而保留 debug 和 codeword 字段。我们可以定义如下结构体：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name    string          `json:"name"`
    Age     uint            `json:"age"`
    Address json.RawMessage `json:"address"` // Store unknown fields
}

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

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

    fmt.Printf("Name: %s, Age: %d\n", p.Name, p.Age)

    // Happy birthday
    p.Age++

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

    fmt.Println(string(data))
}

登录后复制

在这个例子中，Address 字段是一个 json.RawMessage 类型，它会存储 JSON 数据中 address 字段的原始 JSON 数据。当我们使用 json.Marshal 重新编码结构体时，Address 字段中的原始 JSON 数据会被保留。

输出:

Find JSON Path Online

Easily find JSON paths within JSON objects using our intuitive Json Path Finder

查看详情

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

登录后复制

注意事项:

json.RawMessage 实际上是一个 []byte 类型，因此在使用它时需要注意类型转换。
json.RawMessage 存储的是原始的 JSON 数据，因此在处理时需要小心，避免出现 JSON 格式错误。
json.RawMessage 适用于存储嵌套的 JSON 对象或数组，对于简单的键值对，使用 map[string]interface{} 可能更方便。

使用自定义 Unmarshaler 和 Marshaler 接口

另一种方法是实现自定义的 Unmarshaler 和 Marshaler 接口。Unmarshaler 接口允许我们自定义 JSON 解码的行为，Marshaler 接口允许我们自定义 JSON 编码的行为。

通过实现这两个接口，我们可以在解码时将未知的字段存储到一个 map[string]interface{} 类型的字段中，然后在编码时将这些字段重新添加到 JSON 数据中。

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name    string                 `json:"name"`
    Age     uint                   `json:"age"`
    Phone   string                 `json:"phone"`
    UnknownFields map[string]interface{} `json:"-"` // Ignore during standard marshaling
}

func (p *Person) UnmarshalJSON(data []byte) error {
    // Define a type to avoid recursion
    type Alias Person
    aux := &Alias{}

    if err := json.Unmarshal(data, &aux); err != nil {
        return err
    }

    *p = Person(*aux)

    // Unmarshal to a map to capture unknown fields
    var m map[string]interface{}
    if err := json.Unmarshal(data, &m); err != nil {
        return err
    }

    // Remove known fields from the map
    delete(m, "name")
    delete(m, "age")
    delete(m, "phone")

    // Store unknown fields
    p.UnknownFields = m

    return nil
}

func (p Person) MarshalJSON() ([]byte, error) {
    // Define a type to avoid recursion
    type Alias Person
    aux := &Alias{
        Name: p.Name,
        Age:  p.Age,
        Phone: p.Phone,
    }

    data, err := json.Marshal(aux)
    if err != nil {
        return nil, err
    }

    var m map[string]interface{}
    if err := json.Unmarshal(data, &m); err != nil {
        return nil, err
    }

    // Add unknown fields to the map
    for k, v := range p.UnknownFields {
        m[k] = v
    }

    return json.Marshal(m)
}

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:", err)
        return
    }

    fmt.Printf("Name: %s, Age: %d, Phone: %s\n", p.Name, p.Age, p.Phone)

    // Happy birthday
    p.Age++

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

    fmt.Println(string(data))
}

登录后复制

输出:

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

登录后复制

注意事项:

在实现 UnmarshalJSON 和 MarshalJSON 接口时，需要注意避免无限递归调用。
UnknownFields 字段使用了 json:"-" 标签，这意味着在默认的编码过程中，该字段会被忽略。
这种方法需要编写更多的代码，但提供了更大的灵活性，可以自定义解码和编码的行为。

总结

本文介绍了两种在 Go 语言中维护未解析 JSON 字段的方法：使用 json.RawMessage 和使用自定义 Unmarshaler 和 Marshaler 接口。选择哪种方法取决于具体的需求和场景。如果只需要保留部分 JSON 数据，json.RawMessage 是一个简单有效的选择。如果需要更灵活地处理 JSON 数据，可以考虑实现自定义的 Unmarshaler 和 Marshaler 接口。无论选择哪种方法，都需要仔细考虑 JSON 数据的结构和字段，以便正确地处理未知字段。

以上就是在 Go 中维护未解析的 JSON 字段的最佳方法的详细内容，更多请关注php中文网其它相关文章！