Golang encoding/json库JSON序列化与反序列化

P粉602998670

发布时间：2025-09-16 08:05:01

556人浏览过

来源于php中文网

原创

答案是使用Go的encoding/json库通过json.Marshal和json.Unmarshal实现序列化与反序列化，利用结构体标签控制字段映射，omitempty忽略零值字段，优先使用具体结构体而非interface{}以提升性能，并通过检查错误类型实现健壮的错误处理。

golang encoding/json库json序列化与反序列化

Go语言的

encoding/json

库，说白了，就是它处理JSON数据序列化（把Go数据结构转成JSON字符串）和反序列化（把JSON字符串转回Go数据结构）的标准工具箱。在我看来，它不仅是标准，更是Go生态里处理外部数据交互的核心基石之一，用起来直观，但深挖下去，又会发现它藏着不少值得玩味的设计哲学和实用技巧。

解决方案

要使用Go的

encoding/json

库，核心就是两个函数：

json.Marshal

和

json.Unmarshal

。它们分别负责将Go类型编码成JSON和将JSON解码成Go类型。

序列化（Go -> JSON）：

当你有一个Go结构体或任何可序列化的Go值，想把它变成JSON字符串时，

json.Marshal

就是你的首选。它会返回一个字节切片（

[]byte

）和可能的错误。

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

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Email string `json:"email,omitempty"` // omitempty表示如果Email为空字符串，则不包含此字段
    Age  int    `json:"-"`               // "-"表示忽略此字段
    CreatedAt string `json:"created_at"` // 字段名转换为snake_case
}

func main() {
    user := User{
        ID:   1,
        Name: "张三",
        // Email: "zhangsan@example.com", // 如果不设置，omitempty会生效
        Age:  30, // 这个字段会被忽略
        CreatedAt: "2023-10-26T10:00:00Z",
    }

    jsonData, err := json.Marshal(user)
    if err != nil {
        log.Fatalf("序列化失败: %v", err)
    }
    fmt.Printf("序列化结果: %s\n", jsonData)

    // 如果想格式化输出，可以用MarshalIndent
    jsonDataIndent, err := json.MarshalIndent(user, "", "  ")
    if err != nil {
        log.Fatalf("格式化序列化失败: %v", err)
    }
    fmt.Printf("格式化序列化结果:\n%s\n", jsonDataIndent)
}

反序列化（JSON -> Go）：

反过来，当你从文件、网络请求等地方拿到一个JSON字符串（或字节切片），想把它还原成Go结构体时，

json.Unmarshal

就派上用场了。你需要提供一个指针指向目标Go结构体，这样库才能把解析出来的数据填充进去。

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

type Product struct {
    SKU       string  `json:"sku"`
    Name      string  `json:"product_name"`
    Price     float64 `json:"price"`
    InStock   bool    `json:"in_stock"`
    Tags      []string `json:"tags,omitempty"`
}

func main() {
    jsonString := `{
        "sku": "PROD001",
        "product_name": "Go语言编程指南",
        "price": 99.99,
        "in_stock": true,
        "tags": ["编程", "Go", "技术"]
    }`

    var product Product
    err := json.Unmarshal([]byte(jsonString), &product)
    if err != nil {
        log.Fatalf("反序列化失败: %v", err)
    }
    fmt.Printf("反序列化结果: %+v\n", product)

    // 尝试反序列化一个缺少字段的JSON
    jsonStringMissing := `{
        "sku": "PROD002",
        "product_name": "简化版书籍",
        "price": 49.50
    }`
    var productMissing Product
    err = json.Unmarshal([]byte(jsonStringMissing), &productMissing)
    if err != nil {
        log.Fatalf("反序列化缺少字段失败: %v", err)
    }
    fmt.Printf("反序列化缺少字段结果: %+v\n", productMissing) // InStock会是false，Tags会是nil
}

Golang JSON序列化时如何处理字段可见性与命名约定？

这块是

encoding/json

最常用，也是最容易让人产生“啊哈！”体验的地方。Go语言的哲学是“显式优于隐式”，所以在JSON序列化时，它默认只会处理结构体中可导出的字段（即首字母大写的字段）。这是Go语言访问控制的基本规则，也延伸到了JSON处理上。如果你定义了一个小写字母开头的字段，

json.Marshal

会直接忽略它，不会出现在JSON输出里。

至于命名约定，外部系统往往倾向于使用

snake_case

（比如

user_name

），而Go社区普遍遵循

camelCase

（

userName

）。

encoding/json

提供了一个非常优雅的解决方案：结构体标签（
struct tags
）。通过在字段后面加上反引号包围的

json:"your_json_field_name"

，你就可以自定义该字段在JSON中的名称。

比如：

type Order struct {
    OrderID    string    `json:"order_id"`      // 自定义JSON字段名为order_id
    TotalPrice float64   `json:"total_price"`   // 自定义JSON字段名为total_price
    Status     string    `json:"status,omitempty"` // 如果Status为空字符串，则忽略该字段
    internalID string    // 小写字母开头，会被忽略
}

这里

omitempty

也是一个非常实用的标签。我个人觉得，它简直是API设计者的福音。当你的结构体字段是零值（比如字符串为空、整型为0、布尔为false、切片或映射为nil）时，

omitempty

会让

json.Marshal

在输出JSON时跳过这个字段。这能有效减小JSON负载，尤其在处理可选字段时，避免了发送大量空值。但要小心，如果

或

false

本身就是有意义的值，你可能就不该用

omitempty

了。

还有一个不常用但偶尔能救命的标签是

json:",string"

。它会将字段的值序列化为JSON字符串，而不是其原始类型。这对于一些需要特殊处理的类型，比如将

int

类型强制输出为字符串，或者将

time.Time

类型以特定格式的字符串输出时非常有用。当然，这通常意味着你需要自己实现

MarshalJSON

和

UnmarshalJSON

接口，以获得更精细的控制。

JSON.NET 简单的使用中文WORD版

本文档主要讲述的是JSON.NET 简单的使用；JSON.NET使用来将.NET中的对象转换为JSON字符串（序列化），或者将JSON字符串转换为.NET中已有类型的对象（反序列化？）。希望本文档会给有需要的朋友带来帮助；感兴趣的朋友可以过来看看

下载

Golang JSON反序列化时如何应对未知字段或类型不匹配的问题？

反序列化，也就是

json.Unmarshal

，在处理外部不确定性数据时，它的表现可以说既宽容又严格。

首先，对于JSON中存在但Go结构体中没有对应字段的键值对，

json.Unmarshal

默认会直接忽略它们。这在处理只关心部分数据的场景下非常方便，你不需要为每个可能的JSON字段都定义一个Go结构体字段。但有时候，这种“静默忽略”可能会让你错过一些重要信息，比如外部系统发送了你未预期的字段，可能意味着API版本不兼容或者数据结构发生了变化。如果需要严格校验，你可以考虑先反序列化到

map[string]interface{}

，然后手动检查。

类型不匹配是另一个常见的坑。如果JSON中的字段类型与Go结构体中定义的类型不一致，

json.Unmarshal

会返回一个错误，通常是

*json.UnmarshalTypeError

。比如，JSON里一个字段是

"age": "30"

（字符串），而Go结构体里定义的是

Age int

，那么就会报错。

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"` // 期望是数字
}

func main() {
    jsonBadAge := `{"name": "Alice", "age": "thirty"}` // age是字符串
    var p Person
    err := json.Unmarshal([]byte(jsonBadAge), &p)
    if err != nil {
        fmt.Printf("反序列化错误: %v\n", err) // 会报错：json: cannot unmarshal string into Go struct field Person.age of type int
    }
}

解决这类问题，除了确保JSON数据源的正确性外，你还可以：

使用
interface{}
：如果你事先不知道JSON数据的确切结构，或者某些字段的类型可能动态变化，可以反序列化到
```
map[string]interface{}
```
或
```
[]interface{}
```
。这提供了极大的灵活性，但缺点是后续需要进行类型断言，代码会变得复杂且容易出错。
自定义
UnmarshalJSON
方法：这是处理复杂类型转换、数据校验，甚至在反序列化过程中实现特定业务逻辑的终极武器。通过实现
```
json.Unmarshaler
```
接口，你可以完全控制某个类型如何从JSON中解析。例如，你可以手动解析一个可能为字符串也可能为数字的字段。
使用
json.RawMessage
：如果你想延迟解析JSON的某个子部分，或者想在反序列化时保留原始JSON片段，
```
json.RawMessage
```
非常有用。它会把JSON的某个子树当作一个原始字节切片处理，你可以之后再对其进行单独的
```
Unmarshal
```
。

我个人觉得，在处理未知字段和类型不匹配时，最重要的是预设你的数据边界。如果数据源是你可控的，那就严格定义结构体，让

Unmarshal

帮你校验。如果数据源不可控，或者结构高度动态，那么

map[string]interface{}

和自定义

UnmarshalJSON

就是你的救命稻草，只是要权衡好灵活性和代码复杂性。

在Golang中处理JSON时，性能优化与错误处理的最佳实践是什么？

处理JSON，尤其是在高并发或大数据量的场景下，性能和稳健的错误处理是绕不开的话题。

性能优化：

使用

json.Encoder

和
json.Decoder
处理流数据：当你在处理大量JSON数据，或者需要从网络流中直接读写JSON时，避免将整个JSON数据一次性加载到内存中。

json.NewEncoder(writer)

和

json.NewDecoder(reader)

是更好的选择。它们直接与

io.Writer

和

io.Reader

交互，按需读写，显著减少内存占用，特别是在处理大文件或HTTP请求/响应体时。

// 示例：使用Encoder写入JSON到HTTP响应
// func handler(w http.ResponseWriter, r *http.Request) {
//     data := MyStruct{...}
//     w.Header().Set("Content-Type", "application/json")
//     if err := json.NewEncoder(w).Encode(data); err != nil {
//         http.Error(w, err.Error(), http.StatusInternalServerError)
//         return
//     }
// }

避免不必要的
```
interface{}
```
：虽然
```
interface{}
```
提供了极大的灵活性，但其在内部需要进行类型断言和反射操作，这些操作相比于直接操作具体类型会有性能开销。在性能敏感的路径上，尽量使用具体结构体进行序列化和反序列化。如果必须使用
```
interface{}
```
，考虑在解析后尽快将其转换为具体类型。
重用
```
json.Encoder
```
和
json.Decoder
实例（带缓冲区）：在某些特定场景下，比如在一个循环中反复进行JSON编解码，可以考虑使用
```
sync.Pool
```
来重用
```
json.Encoder
```
和
```
json.Decoder
```
实例，或者至少确保它们背后的
```
bufio.Writer
```
或
```
bufio.Reader
```
被有效利用，减少内存分配和GC压力。不过，这通常是微优化，在大多数应用中，直接创建新的实例并不会成为瓶颈。
结构体字段顺序：这更像是一个Go语言本身的优化，而非
```
encoding/json
```
特有。将结构体中相同类型的字段放在一起，或者将占用内存较小的字段放在一起，可以减少内存对齐的填充，从而使结构体更紧凑。但这对于JSON库的性能影响通常微乎其微。

错误处理：

错误处理在任何I/O操作中都至关重要，JSON编解码也不例外。

始终检查

error

返回值：这是最基本也是最重要的原则。

json.Marshal

和

json.Unmarshal

都会返回一个

error

，你必须检查它。忽视错误会导致程序在运行时出现意料之外的行为。

data, err := json.Marshal(myStruct)
if err != nil {
    log.Printf("JSON序列化失败: %v", err)
    // 根据业务需求处理错误，例如返回HTTP 500
    return
}

err = json.Unmarshal(jsonData, &myStruct)
if err != nil {
    log.Printf("JSON反序列化失败: %v", err)
    // 根据业务需求处理错误，例如返回HTTP 400 Bad Request
    return
}

区分错误类型：

encoding/json

库会返回一些特定的错误类型，例如：

```
*json.UnmarshalTypeError
```
：当JSON值与Go结构体字段类型不匹配时。
```
*json.InvalidUnmarshalError
```
：当
```
Unmarshal
```
的目标不是一个非nil的指针时。
```
*json.SyntaxError
```
：当JSON格式本身不合法时。

通过使用

errors.As

或类型断言来识别这些错误，可以进行更精细的错误处理，例如，对于

UnmarshalTypeError

，你可能可以向用户返回一个更友好的“数据格式不正确”的提示。

var unmarshalTypeError *json.UnmarshalTypeError
if errors.As(err, &unmarshalTypeError) {
    fmt.Printf("JSON类型不匹配错误：字段 '%s' 期望类型为 %s，但实际为 %s\n",
        unmarshalTypeError.Field, unmarshalTypeError.Type, unmarshalTypeError.Value)
} else if err != nil {
    fmt.Printf("其他JSON反序列化错误: %v\n", err)
}

处理
```
json.Decoder
```
的
io.EOF
：当使用
```
json.NewDecoder
```
从流中读取多个JSON对象时，循环读取直到遇到
```
io.EOF
```
通常是正确的做法。但要确保只在没有其他错误时才将
```
io.EOF
```
视为正常结束信号。
自定义
```
MarshalJSON
```
和
UnmarshalJSON
中的错误：如果你自定义了编解码逻辑，确保在这些方法内部也进行充分的错误检查，并返回有意义的错误。这能让你的自定义逻辑同样健壮。