GolangJSON处理技巧序列化与反序列化-Golang-PHP中文网

Golang通过encoding/json包实现JSON处理，核心包括使用json.Marshal和Unmarshal进行序列化与反序列化，利用结构体标签控制字段映射、省略零值及字符串转换，支持自定义类型通过实现Marshaler和Unmarshaler接口，使用Encoder/Decoder处理流式数据，并借助map[string]interface{}和json.RawMessage应对不确定结构，提升灵活性与性能。

golangjson处理技巧序列化与反序列化

Golang处理JSON，无论是将Go结构体转换为JSON字符串（序列化，或称编码）还是将JSON字符串解析回Go结构体（反序列化，或称解码），核心都围绕着标准库的

encoding/json

登录后复制

包。这不仅仅是调用

json.Marshal

登录后复制

和

json.Unmarshal

登录后复制

那么简单，更深层次的技巧在于如何优雅地处理复杂数据类型、优化性能，以及在面对不确定数据结构时的灵活应对。掌握这些，能让你的Go应用在处理数据交换时更加健壮和高效。

解决方案

Golang的

encoding/json

登录后复制

包提供了一套强大而灵活的API来处理JSON数据。以下是其核心用法和一些高级技巧：

1. 基本序列化与反序列化

最常见的操作是将Go结构体与JSON字符串之间进行转换。

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

package main

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

type User struct {
    ID        int    `json:"id"`
    Username  string `json:"username"`
    Email     string `json:"email,omitempty"` // omitempty：如果为空，则在JSON中省略
    IsActive  bool   `json:"is_active"`
    CreatedAt string `json:"created_at,string"` // string：将非字符串类型序列化/反序列化为字符串
    Tags      []string `json:"tags"`
}

func main() {
    // 序列化 (Marshal)
    user := User{
        ID:        1,
        Username:  "gopher",
        Email:     "", // Email为空，会被omitempty忽略
        IsActive:  true,
        CreatedAt: "2023-10-27T10:00:00Z",
        Tags:      []string{"golang", "backend"},
    }

    jsonData, err := json.Marshal(user)
    if err != nil {
        log.Fatalf("Error marshaling: %v", err)
    }
    fmt.Printf("Serialized JSON: %s\n", jsonData)
    // Output: {"id":1,"username":"gopher","is_active":true,"created_at":"2023-10-27T10:00:00Z","tags":["golang","backend"]}

    // 反序列化 (Unmarshal)
    jsonStr := `{"id":2,"username":"jane.doe","email":"jane@example.com","is_active":false,"created_at":"2023-10-26T15:30:00Z","tags":["frontend"]}`
    var newUser User
    err = json.Unmarshal([]byte(jsonStr), &newUser)
    if err != nil {
        log.Fatalf("Error unmarshaling: %v", err)
    }
    fmt.Printf("Deserialized User: %+v\n", newUser)
    // Output: Deserialized User: {ID:2 Username:jane.doe Email:jane@example.com IsActive:false CreatedAt:2023-10-26T15:30:00Z Tags:[frontend]}

    // 注意CreatedAt字段的string标签在反序列化时也会起作用，但这里CreatedAt本身就是字符串，所以效果不明显。
    // 如果CreatedAt是time.Time类型，而JSON中是字符串，则string标签能帮助转换。
}

登录后复制

2. 自定义序列化与反序列化

当默认的JSON处理逻辑无法满足需求时，你可以实现

json.Marshaler

登录后复制

和

json.Unmarshaler

登录后复制

接口。这在处理自定义类型（如特殊的日期格式、枚举类型或加密数据）时非常有用。

package main

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

// CustomTime 自定义时间类型，用于特殊格式的JSON处理
type CustomTime time.Time

// MarshalJSON 实现json.Marshaler接口
func (ct CustomTime) MarshalJSON() ([]byte, error) {
    t := time.Time(ct)
    // 将时间格式化为 "YYYY/MM/DD HH:MM:SS"
    formatted := t.Format("2006/01/02 15:04:05")
    return []byte(strconv.Quote(formatted)), nil // 需要用双引号包裹
}

// UnmarshalJSON 实现json.Unmarshaler接口
func (ct *CustomTime) UnmarshalJSON(data []byte) error {
    var s string
    if err := json.Unmarshal(data, &s); err != nil {
        return err
    }
    // 解析 "YYYY/MM/DD HH:MM:SS" 格式的时间
    t, err := time.Parse("2006/01/02 15:04:05", s)
    if err != nil {
        return err
    }
    *ct = CustomTime(t)
    return nil
}

type Event struct {
    Name string     `json:"name"`
    Time CustomTime `json:"event_time"`
}

func main() {
    event := Event{
        Name: "Go Meetup",
        Time: CustomTime(time.Now()),
    }

    jsonData, err := json.Marshal(event)
    if err != nil {
        log.Fatalf("Error marshaling event: %v", err)
    }
    fmt.Printf("Serialized Event: %s\n", jsonData)
    // Output: {"name":"Go Meetup","event_time":"2023/10/27 10:30:00"} (时间会是当前时间)

    jsonStr := `{"name":"Launch Party","event_time":"2023/12/25 18:00:00"}`
    var newEvent Event
    err = json.Unmarshal([]byte(jsonStr), &newEvent)
    if err != nil {
        log.Fatalf("Error unmarshaling event: %v", err)
    }
    fmt.Printf("Deserialized Event: %+v\n", newEvent)
    // Output: Deserialized Event: {Name:Launch Party Time:2023-12-25 18:00:00 +0000 UTC}
}

登录后复制

3. 处理流式数据

对于大型JSON文件或网络流，使用

json.Encoder

登录后复制

和

json.Decoder

登录后复制

可以更高效地处理数据，避免一次性将所有数据加载到内存中。

package main

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

type Product struct {
    ID    int     `json:"id"`
    Name  string  `json:"name"`
    Price float64 `json:"price"`
}

func main() {
    // 使用Encoder序列化到io.Writer
    var buf bytes.Buffer
    encoder := json.NewEncoder(&buf)
    encoder.SetIndent("", "  ") // 可以设置缩进，使输出更易读

    products := []Product{
        {ID: 101, Name: "Laptop", Price: 1200.00},
        {ID: 102, Name: "Mouse", Price: 25.00},
    }

    fmt.Println("Encoding products:")
    for _, p := range products {
        if err := encoder.Encode(p); err != nil {
            log.Fatalf("Error encoding product: %v", err)
        }
    }
    fmt.Printf("%s\n", buf.String())
    /* Output:
    Encoding products:
    {
      "id": 101,
      "name": "Laptop",
      "price": 1200
    }
    {
      "id": 102,
      "name": "Mouse",
      "price": 25
    }
    */

    // 使用Decoder从io.Reader反序列化
    jsonStream := `{"id":201,"name":"Keyboard","price":75.00}
    {"id":202,"name":"Monitor","price":300.00}` // 注意这里是两行独立的JSON对象

    decoder := json.NewDecoder(bytes.NewReader([]byte(jsonStream)))

    fmt.Println("\nDecoding products:")
    for decoder.More() { // 检查是否有更多JSON对象可供解码
        var p Product
        if err := decoder.Decode(&p); err != nil {
            log.Fatalf("Error decoding product: %v", err)
        }
        fmt.Printf("Decoded: %+v\n", p)
    }
    /* Output:
    Decoding products:
    Decoded: {ID:201 Name:Keyboard Price:75}
    Decoded: {ID:202 Name:Monitor Price:300}
    */
}

登录后复制

为什么我的JSON序列化结果和预期不符？深入理解

json

登录后复制

标签的妙用

这是我自己在开发中遇到的最常见的问题之一，JSON输出和我想象的不一样，或者反序列化的时候总有字段是空的。究其原因，往往是对Go的结构体字段可见性以及

json

登录后复制

标签的理解不够深入。

首先，Go语言有一个非常基本的规则：只有导出字段（即首字母大写的字段）才能被

encoding/json

登录后复制

包访问和处理。如果你有一个小写字母开头的字段，它在序列化时会被直接忽略，反序列化时也无法被赋值。这是很多初学者会踩的第一个坑。

其次，

json

登录后复制

标签提供了对序列化和反序列化过程的精细控制。

```
json:"field_name"
```
登录后复制
: 这是最常用的，用于将Go结构体字段名映射到JSON键名。例如，
```
Username string
```
登录后复制
json:"user_name"`
```
会将Go的
```
登录后复制
Username
```
字段序列化为JSON的
```
登录后复制
"user_name"
```
。如果JSON键名与Go字段名不一致，或者需要遵循特定的命名规范（如
```
登录后复制
snake_case`），这个标签就显得尤为重要。

序列猴子开放平台
具有长序列、多模态、单模型、大数据等特点的超大规模语言模型

0

查看详情
```
json:"-"
```
登录后复制
: 简单粗暴，这个标签会告诉
```
encoding/json
```
登录后复制
包完全忽略这个字段。无论序列化还是反序列化，它都不会被处理。当你的结构体中包含一些只用于内部逻辑、不希望暴露给外部JSON的字段时，它就派上用场了。
```
json:",omitempty"
```
登录后复制
: 这个标签非常实用，它会在字段值是其类型的“零值”时，在JSON输出中省略该字段。零值包括：
```
nil
```
登录后复制
（对于指针、切片、映射、接口）、
```
""
```
登录后复制
（对于字符串）、
```
0
```
登录后复制
（对于数字）、
```
false
```
登录后复制
（对于布尔值）。
- 举个例子，
```
Email string
```
  登录后复制
  json:"email,omitempty"`
```
，如果
```
  登录后复制
  Email`字段是空字符串，它就不会出现在最终的JSON中。这有助于生成更简洁的JSON，尤其是在处理可选字段时。
- 但这里有个小陷阱：如果你的布尔字段默认为
```
false
```
  登录后复制
  ，并且你希望它总是出现，那么
```
omitempty
```
  登录后复制
  就不适用。同理，数字
```
0
```
  登录后复制
  也会被省略。你需要根据实际业务需求来决定是否使用它。
```
json:",string"
```
登录后复制
: 这个标签有点特别，它指示
```
encoding/json
```
登录后复制
包将字段的值编码为JSON字符串，或者从JSON字符串解码。这在处理一些需要与JavaScript或特定API兼容的场景下很有用。例如，JavaScript在处理大整数时可能会遇到精度问题，将其作为字符串传输可以避免这种问题。
- ```
ID int
```
  登录后复制
  json:"id,string"`
```
，会将
```
  登录后复制
  ID
```
字段（整数）在JSON中表示为
```
  登录后复制
  "id": "123"
```
而不是
```
  登录后复制
  "id": 123
```
。反之，当JSON中的
```
  登录后复制
  "id": "123"`被反序列化时，它也会尝试将其解析为整数。
匿名嵌入字段: 当你将一个结构体匿名嵌入到另一个结构体中时，它的字段默认会被提升到外部结构体的顶层。如果你想让它们作为嵌套对象出现，需要给嵌入的结构体本身一个
```
json
```
登录后复制
标签。

理解并正确运用这些标签，能够让你对JSON的生成和解析拥有极大的控制力，避免那些“为什么不一样”的困惑。

如何优雅地处理复杂或不确定的JSON结构？

interface{}

登录后复制

与

RawMessage

登录后复制

的实战考量

在与外部API交互时，我们经常会遇到JSON结构不固定、某些字段类型多变，或者数据量庞大但我们只关心其中一部分的情况。这时，死板地定义一个精确的Go结构体可能会变得非常困难，甚至不切实际。

interface{}

登录后复制

和

json.RawMessage

登录后复制

是Golang处理这类挑战的利器。

map[string]interface{}

登录后复制

：灵活性至上

当JSON的结构完全不可预测，或者你只需要动态地读取一些顶层字段时，

map[string]interface{}

登录后复制

是你的首选。

encoding/json

登录后复制

包在反序列化到

interface{}

登录后复制

时，会将JSON对象映射到

map[string]interface{}

登录后复制

，JSON数组映射到

[]interface{}

登录后复制

，JSON布尔值映射到

bool

登录后复制

，数字映射到

float64

登录后复制

，字符串映射到

string

登录后复制

，

null

登录后复制

映射到

nil

登录后复制

。

package main

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

func main() {
    dynamicJSON := `{"name": "Alice", "age": 30, "isStudent": true, "courses": ["Math", "Science"], "address": {"city": "New York", "zip": "10001"}}`

    var data map[string]interface{}
    err := json.Unmarshal([]byte(dynamicJSON), &data)
    if err != nil {
        log.Fatalf("Error unmarshaling dynamic JSON: %v", err)
    }

    fmt.Println("Dynamically parsed JSON:")
    for key, value := range data {
        fmt.Printf("Key: %s, Value: %v, Type: %T\n", key, value, value)
    }

    // 访问特定字段需要进行类型断言
    if name, ok := data["name"].(string); ok {
        fmt.Printf("Name: %s\n", name)
    }
    if age, ok := data["age"].(float64); ok { // JSON数字默认解析为float64
        fmt.Printf("Age: %.0f\n", age)
    }
    if address, ok := data["address"].(map[string]interface{}); ok {
        if city, ok := address["city"].(string); ok {
            fmt.Printf("City: %s\n", city)
        }
    }
}

登录后复制

实战考量：

优点： 极度灵活，可以处理任何JSON结构，无需预先定义结构体。
缺点： 缺乏类型安全，每次访问字段都需要进行类型断言，这会增加代码的复杂性和出错的可能性。性能上通常不如直接反序列化到结构体。
适用场景： 当JSON结构真的完全未知，或者你只需要快速检查几个顶层字段时。例如，一个日志系统接收各种格式的JSON日志。

json.RawMessage

登录后复制

：延迟解析与局部控制

json.RawMessage

登录后复制

是一个

[]byte

登录后复制

类型，它表示一个未解析的原始JSON值。当你将一个字段声明为

json.RawMessage

登录后复制

时，

encoding/json

登录后复制

包在反序列化时会直接将该字段对应的JSON子串（包括其内部的结构）原封不动地存储为字节切片，而不会进行进一步的解析。你需要手动对这个

RawMessage

登录后复制

进行二次解析。

package main

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

// APIResponse 模拟一个API响应，其中data字段可以是任意类型
type APIResponse struct {
    Status  string          `json:"status"`
    Message string          `json:"message"`
    Data    json.RawMessage `json:"data"` // Data字段延迟解析
}

// UserData 针对Data字段可能的结构之一
type UserData struct {
    ID       int    `json:"id"`
    Username string `json:"username"`
}

// ProductData 针对Data字段可能的结构之二
type ProductData struct {
    ProductID   string `json:"product_id"`
    ProductName string `json:"product_name"`
    Price       float64 `json:"price"`
}

func main() {
    // 示例1：Data字段是UserData
    userResponse := `{"status":"success","message":"User fetched","data":{"id":1,"username":"gopher"}}`
    var resp1 APIResponse
    err := json.Unmarshal([]byte(userResponse), &resp1)
    if err != nil {
        log.Fatalf("Error unmarshaling user response: %v", err)
    }
    fmt.Printf("Response 1 Status: %s, Message: %s\n", resp1.Status, resp1.Message)

登录后复制

以上就是GolangJSON处理技巧序列化与反序列化的详细内容，更多请关注php中文网其它相关文章！