MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Go语言struct标签与JSON序列化反序列化

2022-12-085.4k 阅读

Go语言struct标签基础

在Go语言中，struct标签（struct tag）是一种附着在结构体字段上的元数据。它们以字符串的形式存在，为结构体字段提供额外的信息。这些信息本身在Go的类型系统中并不直接使用，但对于像JSON序列化反序列化这样的特定库和工具而言，却是至关重要的。

结构体标签紧跟在字段类型声明之后，以反引号包裹。例如：

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

在上述代码中，json:"name" 和 json:"age" 就是结构体 Person 中字段 Name 和 Age 的标签。这里的 json 表示这个标签是为JSON处理相关的功能准备的，而 "name" 和 "age" 则是具体的配置信息。

JSON序列化中struct标签的作用

  1. 字段重命名 在JSON序列化时，我们常常希望结构体字段的名称与最终JSON输出的字段名称不同。例如，在Go代码中，我们习惯使用驼峰命名法，但在JSON中，通常使用蛇形命名法。通过struct标签，我们可以轻松实现这种转换。 
    package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    FirstName string `json:"first_name"`
    LastName  string `json:"last_name"`
    Age       int    `json:"age"`
}

func main() {
    user := User{
        FirstName: "John",
        LastName:  "Doe",
        Age:       30,
    }

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

    fmt.Println(string(data))
}
    在这段代码中，User 结构体的字段 FirstName 和 LastName 在JSON输出中分别被重命名为 first_name 和 last_name。运行该程序，输出如下： 
    {"first_name":"John","last_name":"Doe","age":30}
  2. 忽略字段 有时候，我们不希望某些结构体字段出现在JSON序列化的结果中。可以通过设置标签为 json:"-" 来实现。 
    package main

import (
    "encoding/json"
    "fmt"
)

type Employee struct {
    Name     string `json:"name"`
    Salary   int    `json:"salary"`
    Password string `json:"-"`
}

func main() {
    emp := Employee{
        Name:     "Alice",
        Salary:   5000,
        Password: "secret",
    }

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

    fmt.Println(string(data))
}
    在上述代码中，Password 字段由于标签 json:"-"，在JSON序列化时被忽略。输出结果为： 
    {"name":"Alice","salary":5000}
  3. 设置默认值 虽然Go的 encoding/json 包本身不直接支持设置默认值，但结合自定义的序列化逻辑和标签可以模拟实现。例如，我们可以定义一个包含默认值信息的标签，然后在自定义序列化函数中根据标签来设置默认值。 
    package main

import (
    "encoding/json"
    "fmt"
    "reflect"
    "strconv"
)

type Product struct {
    Name    string `json:"name"`
    Price   int    `json:"price"`
    InStock int    `json:"in_stock,default=10"`
}

func (p *Product) MarshalJSON() ([]byte, error) {
    type Alias Product
    temp := struct {
        *Alias
    }{
        Alias: (*Alias)(p),
    }

    value := reflect.ValueOf(p).Elem()
    for i := 0; i < value.NumField(); i++ {
        field := value.Type().Field(i)
        tag := field.Tag.Get("json")
        if tag != "" {
            parts := strings.Split(tag, ",")
            if len(parts) > 1 && parts[1] != "" && parts[1][:8] == "default=" {
                defValue, err := strconv.Atoi(parts[1][8:])
                if err == nil && value.Field(i).IsZero() {
                    value.Field(i).SetInt(int64(defValue))
                }
            }
        }
    }

    return json.Marshal(temp)
}

func main() {
    product := Product{
        Name:  "Widget",
        Price: 100,
    }

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

    fmt.Println(string(data))
}
    在这个例子中，InStock 字段如果在结构体实例化时未设置值，会根据标签中的默认值 10 进行设置。输出结果为： 
    {"name":"Widget","price":100,"in_stock":10}

JSON反序列化中struct标签的作用

  1. 匹配JSON字段到结构体字段 在反序列化时，encoding/json 包会根据struct标签来匹配JSON中的字段和结构体的字段。例如： 
    package main

import (
    "encoding/json"
    "fmt"
)

type Book struct {
    Title  string `json:"title"`
    Author string `json:"author"`
    Pages  int    `json:"pages"`
}

func main() {
    jsonData := `{"title":"Go Programming","author":"John Doe","pages":200}`
    var book Book
    err := json.Unmarshal([]byte(jsonData), &book)
    if err != nil {
        fmt.Println("Error unmarshalling JSON:", err)
        return
    }

    fmt.Printf("Title: %s, Author: %s, Pages: %d\n", book.Title, book.Author, book.Pages)
}
    这里JSON中的 "title"、"author" 和 "pages" 字段会根据struct标签分别匹配到 Book 结构体的 Title、Author 和 Pages 字段。
  2. 处理可选字段 在JSON数据中，某些字段可能不存在。通过struct标签，我们可以让反序列化过程更优雅地处理这种情况。例如： 
    package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age,omitempty"`
}

func main() {
    jsonData1 := `{"name":"Bob"}`
    var person1 Person
    err1 := json.Unmarshal([]byte(jsonData1), &person1)
    if err1 != nil {
        fmt.Println("Error unmarshalling JSON 1:", err1)
        return
    }
    fmt.Printf("Name: %s, Age: %d\n", person1.Name, person1.Age)

    jsonData2 := `{"name":"Alice","age":25}`
    var person2 Person
    err2 := json.Unmarshal([]byte(jsonData2), &person2)
    if err2 != nil {
        fmt.Println("Error unmarshalling JSON 2:", err2)
        return
    }
    fmt.Printf("Name: %s, Age: %d\n", person2.Name, person2.Age)
}
    在 Person 结构体中，Age 字段的标签 json:"age,omitempty" 表示这个字段在JSON数据中是可选的。当JSON数据中不存在 age 字段时，反序列化后 person1.Age 的值为0（int 类型的零值）。而当JSON数据中存在 age 字段时，person2.Age 会被正确赋值。
  3. 处理嵌套JSON结构 当JSON数据具有嵌套结构时，struct标签同样发挥着重要作用。 
    package main

import (
    "encoding/json"
    "fmt"
)

type Address struct {
    Street string `json:"street"`
    City   string `json:"city"`
}

type Customer struct {
    Name    string  `json:"name"`
    Address Address `json:"address"`
}

func main() {
    jsonData := `{"name":"Charlie","address":{"street":"123 Main St","city":"Anytown"}}`
    var customer Customer
    err := json.Unmarshal([]byte(jsonData), &customer)
    if err != nil {
        fmt.Println("Error unmarshalling JSON:", err)
        return
    }

    fmt.Printf("Name: %s, Street: %s, City: %s\n", customer.Name, customer.Address.Street, customer.Address.City)
}
    在这个例子中，Customer 结构体包含一个 Address 结构体类型的字段。json 标签帮助反序列化过程正确地将嵌套的JSON数据解析到对应的结构体字段中。

自定义JSON序列化和反序列化行为

  1. 自定义序列化 有时候，默认的JSON序列化行为不能满足我们的需求。例如，我们可能希望将一个结构体字段序列化为特定格式的字符串。我们可以通过在结构体上实现 MarshalJSON 方法来自定义序列化行为。 
    package main

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

type Event struct {
    Name    string    `json:"name"`
    Started time.Time `json:"started"`
}

func (e Event) MarshalJSON() ([]byte, error) {
    type Alias Event
    temp := struct {
        *Alias
        Started string `json:"started"`
    }{
        Alias: (*Alias)(&e),
        Started: e.Started.Format(time.RFC3339),
    }

    return json.Marshal(temp)
}

func main() {
    event := Event{
        Name:    "Conference",
        Started: time.Now(),
    }

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

    fmt.Println(string(data))
}
    在这个例子中，Event 结构体的 Started 字段是 time.Time 类型。默认情况下，encoding/json 包会将其序列化为特定的格式。但通过实现 MarshalJSON 方法，我们将其格式化为 time.RFC3339 格式的字符串。
  2. 自定义反序列化 类似地，我们可以通过实现 UnmarshalJSON 方法来自定义反序列化行为。例如，假设我们接收到的JSON数据中日期字段的格式与Go的默认解析格式不同。 
    package main

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

type Task struct {
    Name     string    `json:"name"`
    DueDate  time.Time `json:"due_date"`
}

func (t *Task) UnmarshalJSON(data []byte) error {
    type Alias Task
    temp := &struct {
        *Alias
        DueDate string `json:"due_date"`
    }{
        Alias: (*Alias)(t),
    }

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

    parsedDate, err := time.Parse("2006-01-02", temp.DueDate)
    if err != nil {
        return err
    }
    t.DueDate = parsedDate

    return nil
}

func main() {
    jsonData := `{"name":"Complete Report","due_date":"2023-12-31"}`
    var task Task
    err := json.Unmarshal([]byte(jsonData), &task)
    if err != nil {
        fmt.Println("Error unmarshalling JSON:", err)
        return
    }

    fmt.Printf("Name: %s, Due Date: %s\n", task.Name, task.DueDate.Format(time.RFC3339))
}
    在这个例子中，JSON数据中的 due_date 字段格式为 YYYY - MM - DD，而Go的 time.Time 默认解析格式不同。通过实现 UnmarshalJSON 方法，我们将其正确解析为 time.Time 类型。

标签解析的原理

Go语言的 encoding/json 包在进行序列化和反序列化时，会通过反射来获取结构体字段的标签信息。反射是Go语言中一个强大的特性，它允许程序在运行时检查和修改类型、变量和值。

在序列化过程中，json.Marshal 函数会遍历结构体的每个字段，通过反射获取字段的标签。根据标签中的配置，如字段名重命名、忽略字段等信息，决定如何将结构体字段转换为JSON格式。

在反序列化过程中，json.Unmarshal 函数同样使用反射。它根据JSON数据中的字段名，结合结构体字段的标签，找到对应的结构体字段，并将JSON数据的值赋给该字段。如果遇到 omitempty 标签，会检查JSON数据中该字段是否存在，若不存在则跳过赋值。

了解标签解析的原理有助于我们在遇到序列化或反序列化问题时进行调试，也能让我们更好地利用struct标签的特性来满足复杂的业务需求。

常见问题及解决方法

  1. 标签格式错误 一个常见的错误是struct标签的格式不正确。例如，忘记反引号或者标签内部的语法错误。 
    // 错误示例
type BadFormat struct {
    Field string json:"field" // 缺少反引号
}
    解决方法是仔细检查标签的语法，确保每个标签都正确地用反引号包裹，并且内部的键值对格式正确。
  2. 字段类型不匹配 当JSON数据的类型与结构体字段的类型不匹配时，会导致反序列化错误。例如，将一个字符串类型的JSON值反序列化为 int 类型的结构体字段。 
    package main

import (
    "encoding/json"
    "fmt"
)

type Data struct {
    Value int `json:"value"`
}

func main() {
    jsonData := `{"value":"not a number"}`
    var data Data
    err := json.Unmarshal([]byte(jsonData), &data)
    if err != nil {
        fmt.Println("Error unmarshalling JSON:", err)
        return
    }
}
    解决这种问题需要确保JSON数据的类型与结构体字段的类型兼容。在反序列化之前，可以对JSON数据进行预处理，或者在结构体上实现自定义的反序列化逻辑来处理类型转换。
  3. 嵌套结构体标签冲突 在嵌套结构体的情况下，可能会出现标签冲突的问题。例如，两个嵌套的结构体中有相同标签名的字段。 
    type Inner struct {
    Field string `json:"common_field"`
}

type Outer struct {
    Inner Inner  `json:"inner"`
    Field string `json:"common_field"`
}
    解决这种问题可以通过修改标签名，使其在整个结构中唯一，或者使用更明确的命名策略，避免标签冲突。

总结struct标签在JSON处理中的重要性

Go语言的struct标签在JSON序列化和反序列化过程中扮演着极其重要的角色。它们提供了一种灵活且强大的方式来控制结构体与JSON数据之间的转换。通过合理使用struct标签，我们可以轻松地实现字段重命名、忽略字段、处理可选字段以及自定义序列化和反序列化行为。

了解struct标签的原理、常见问题及解决方法，能够帮助我们在实际开发中更高效地处理JSON数据，编写出健壮、可维护的Go程序。无论是开发Web服务接收和返回JSON数据，还是处理配置文件等涉及JSON解析的场景，struct标签与JSON序列化反序列化的知识都是必不可少的。在日常编程中，不断积累使用struct标签的经验，将有助于提升我们处理JSON相关任务的能力，使我们的代码更加简洁、高效。