本文介绍了在 Go 语言中使用 `encoding/json` 包处理 JSON 数据时，如何保留未解析的动态字段。针对需要在 Go 结构体中解码、操作后再编码回 JSON，但又不想丢失原始 JSON 中结构体未定义的字段的情况，提供了使用 `json.RawMessage` 类型和自定义 `Unmarshaler`/`Marshaler` 接口的解决方案，并简要提及了其他库（如 `mgo/bson`）中类似功能的实现。
在使用 Go 语言处理 JSON 数据时，经常会遇到这样的场景：我们需要将 JSON 数据解码到 Go 结构体中进行操作，然后再将修改后的结构体编码回 JSON。然而，原始 JSON 数据中可能包含一些我们事先未知的、或者暂时不需要处理的字段。如果直接使用 json.Unmarshal 将 JSON 数据解码到结构体中，这些未定义的字段就会被忽略，导致信息丢失。
那么，如何在 Go 中既能方便地使用结构体进行数据操作，又能保留原始 JSON 数据中的未解析字段呢？本文将介绍几种可行的方案。
使用 json.RawMessage 类型
json.RawMessage 是 encoding/json 包提供的一个类型，它本质上是 []byte 的别名。我们可以将结构体中的某个字段定义为 json.RawMessage 类型，这样在解码 JSON 数据时，该字段对应的 JSON 片段会被原封不动地存储为字节数组，而不会被进一步解析。
例如，假设我们有以下 JSON 数据：
{
"name": "Joe Smith",
"age": 42,
"phone": "614-555-1212",
"debug": true,
"codeword": "wolf"
}我们希望将其中的 name、age 和 address 字段解码到结构体中，而保留其他字段。可以定义如下结构体：
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string `json:"name"`
Age uint `json:"age"`
Address json.RawMessage `json:"address"` // 包含 "phone", "debug", "codeword" 等字段
}
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\n", p.Name)
fmt.Printf("Age: %d\n", p.Age)
fmt.Printf("Address (Raw): %s\n", string(p.Address)) // 输出原始 JSON 片段
// 修改 Age
p.Age++
// 重新编码为 JSON
newData, err := json.Marshal(p)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Printf("New JSON: %s\n", string(newData))
}在这个例子中，Address 字段被定义为 json.RawMessage 类型。在解码 JSON 数据时，address 字段对应的 JSON 对象 { "phone": "614-555-1212", "debug": true, "codeword": "wolf" } 会被存储到 p.Address 中。当我们重新编码 Person 结构体为 JSON 时，address 字段的内容会被原封不动地放回 JSON 数据中。
注意事项：
- 使用 json.RawMessage 时，需要确保 JSON 数据中的对应字段是一个有效的 JSON 片段。
- 如果需要对 json.RawMessage 中存储的 JSON 数据进行进一步处理，需要手动进行解码。
自定义 Unmarshaler 和 Marshaler 接口
另一种方案是实现自定义的 Unmarshaler 和 Marshaler 接口。这种方案更加灵活，可以实现更复杂的逻辑，但同时也需要编写更多的代码。
Unmarshaler 接口定义了 UnmarshalJSON 方法，该方法用于将 JSON 数据解码到对象中。Marshaler 接口定义了 MarshalJSON 方法，该方法用于将对象编码为 JSON 数据。
我们可以实现自定义的 UnmarshalJSON 方法，将 JSON 数据解码到一个 map[string]interface{} 中，然后将需要处理的字段提取到结构体中，并将剩余的字段存储到 map[string]interface{} 中。在实现 MarshalJSON 方法时，将结构体中的字段和 map[string]interface{} 中的字段合并，然后编码为 JSON 数据。
以下是一个示例：
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string `json:"name"`
Age uint `json:"age"`
Extra map[string]interface{} `json:"-"` // 忽略，用于存储未解析的字段
}
// UnmarshalJSON 自定义解码逻辑
func (p *Person) UnmarshalJSON(data []byte) error {
// 定义一个中间类型，避免无限递归
type Alias Person
aux := &struct {
*Alias
}{
Alias: (*Alias)(p),
}
// 先将 JSON 数据解码到 map[string]interface{} 中
var tmp map[string]interface{}
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
// 将需要处理的字段提取到结构体中
if name, ok := tmp["name"].(string); ok {
p.Name = name
delete(tmp, "name")
}
if age, ok := tmp["age"].(float64); ok { // 注意：JSON 中数字默认是 float64
p.Age = uint(age)
delete(tmp, "age")
}
// 将剩余的字段存储到 Extra 中
p.Extra = tmp
return nil
}
// MarshalJSON 自定义编码逻辑
func (p *Person) MarshalJSON() ([]byte, error) {
// 创建一个新的 map，包含结构体中的字段和 Extra 中的字段
tmp := make(map[string]interface{})
tmp["name"] = p.Name
tmp["age"] = p.Age
for k, v := range p.Extra {
tmp[k] = v
}
// 将 map 编码为 JSON 数据
return json.Marshal(tmp)
}
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\n", p.Name)
fmt.Printf("Age: %d\n", p.Age)
fmt.Printf("Extra: %+v\n", p.Extra)
// 修改 Age
p.Age++
// 添加新的字段
p.Extra["new_field"] = "new_value"
// 重新编码为 JSON
newData, err := json.Marshal(p)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Printf("New JSON: %s\n", string(newData))
}在这个例子中，Person 结构体包含一个 Extra 字段，类型为 map[string]interface{}。UnmarshalJSON 方法将 JSON 数据解码到 map[string]interface{} 中，并将 name 和 age 字段提取到结构体中，将剩余的字段存储到 Extra 中。MarshalJSON 方法将结构体中的字段和 Extra 中的字段合并，然后编码为 JSON 数据。
注意事项：
- 在实现 UnmarshalJSON 方法时，需要注意处理 JSON 数据中的类型转换。例如，JSON 中的数字默认是 float64 类型，需要将其转换为 uint 类型。
- 为了避免无限递归，可以在 UnmarshalJSON 方法中使用一个中间类型。
其他库
除了 encoding/json 包，还有一些其他的库也提供了类似的功能。例如，labix.org/v2/mgo/bson 库的 inline tag flag 可以将结构体中的字段内联到 BSON 文档中，从而实现保留未解析字段的功能。
总结
本文介绍了在 Go 语言中使用 encoding/json 包处理 JSON 数据时，如何保留未解析的动态字段。我们可以使用 json.RawMessage 类型或者自定义 Unmarshaler 和 Marshaler 接口来实现这个功能。选择哪种方案取决于具体的应用场景和需求。如果只需要简单地保留未解析的字段，可以使用 json.RawMessage 类型。如果需要实现更复杂的逻辑，可以自定义 Unmarshaler 和 Marshaler 接口。
