当前位置：首页 > 文章列表 > Golang > Go教程 > GolangJSON序列化反序列化测试技巧

GolangJSON序列化反序列化测试技巧

2025-10-30 16:36:39 0浏览收藏

本文深入探讨了 Golang 中 JSON 序列化与反序列化的测试方法，旨在确保数据转换的准确性和程序的健壮性。核心在于利用 `encoding/json` 和 `testing` 包，通过定义带有 `json` 标签的结构体，编写测试用例来验证 `Marshal` 和 `Unmarshal` 函数的结果。文章详细讲解了如何测试嵌套结构、指针字段，并覆盖 `omitempty` 标签的使用场景，以及如何处理错误输入和边界情况。此外，还介绍了使用表驱动测试来提升测试覆盖率，从而更全面地保障结构体与 JSON 之间的可靠转换。通过反射、错误处理和多种测试用例的结合，可以有效地避免潜在的 bug，确保数据在 Golang 应用中的正确传递和存储。

答案是测试Go中JSON序列化与反序列化需使用encoding/json和testing包，定义结构体并验证Marshal和Unmarshal结果。1. 定义带json标签的结构体如Person{Name, Age}，编写TestJSONMarshalUnmarshal函数：先将Person实例序列化为JSON字符串，比对输出是否符合预期；再反序列化到新变量，用reflect.DeepEqual检查数据一致性。2. 测试嵌套结构与指针字段，定义含Address、User等复杂类型，覆盖omitempty标签场景，构造非nil和nil值组合，验证字段正确编解码。3. 验证错误输入，传入类型不匹配的JSON（如age为字符串），确保Unmarshal返回错误。4. 使用表驱动测试提升覆盖率，遍历多个用例（正常数据、零值等），分别执行Marshal并比对结果。5. 注意nil指针、空切片、null处理等边界情况，确保程序健壮性。核心是结合反射、错误处理和多种测试用例，保障结构体与JSON准确转换。

Golang如何测试JSON序列化与反序列化

测试 Go 中的 JSON 序列化与反序列化，关键在于验证结构体能否正确地转换为 JSON 字符串，以及从 JSON 字符串还原为结构体。主要使用 encoding/json 包配合 testing 包来完成。

定义结构体并编写基础测试

先定义一个简单的结构体，并使用 JSON 标签。然后编写测试函数，验证序列化和反序列化的结果是否符合预期。

package main

import (
    "encoding/json"
    "reflect"
    "testing"
)

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

func TestJSONMarshalUnmarshal(t *testing.T) {
    p := Person{Name: "Alice", Age: 25}

    // 序列化
    data, err := json.Marshal(p)
    if err != nil {
        t.Fatalf("序列化失败: %v", err)
    }

    expected := `{"name":"Alice","age":25}`
    if string(data) != expected {
        t.Errorf("序列化结果不符: 得到 %s, 期望 %s", data, expected)
    }

    // 反序列化
    var p2 Person
    if err := json.Unmarshal(data, &p2); err != nil {
        t.Fatalf("反序列化失败: %v", err)
    }

    if !reflect.DeepEqual(p, p2) {
        t.Errorf("反序列化后数据不一致: %v ≠ %v", p, p2)
    }
}

测试嵌套结构与指针字段

复杂结构如嵌套结构体、指针或切片也需要覆盖。注意 nil 值在 JSON 中的表现。

type Address struct {
    City  string `json:"city"`
    Zip   string `json:"zip,omitempty"`
}

type User struct {
    Person
    Email   *string    `json:"email,omitempty"`
    Address *Address   `json:"address,omitempty"`
    Tags    []string   `json:"tags,omitempty"`
}

测试时构造包含 nil 和非 nil 的情况：

func TestNestedStructJSON(t *testing.T) {
    email := "bob@example.com"
    addr := &Address{City: "Beijing"}

    u := User{
        Person:  Person{Name: "Bob", Age: 30},
        Email:   &email,
        Address: addr,
        Tags:    []string{"dev", "go"},
    }

    data, err := json.Marshal(u)
    if err != nil {
        t.Fatal(err)
    }

    var u2 User
    if err := json.Unmarshal(data, &u2); err != nil {
        t.Fatal(err)
    }

    if u2.Name != u.Name || u2.Age != u.Age {
        t.Error("基本字段丢失")
    }
    if u2.Email == nil || *u2.Email != *u.Email {
        t.Error("Email 不一致")
    }
    if u2.Address.City != addr.City {
        t.Error("地址信息错误")
    }
}

测试错误输入与边界情况

验证非法 JSON 是否能被正确捕获，比如格式错误或类型不匹配。

func TestInvalidJSON(t *testing.T) {
    invalidJSON := `{"name":"Alice","age":"not_a_number"}`

    var p Person
    err := json.Unmarshal([]byte(invalidJSON), &p)
    if err == nil {
        t.Fatal("应返回错误，但未报错")
    }
}

还可测试空值、null 处理等特殊情况。

使用表驱动测试提升覆盖率

用表驱动方式批量测试多种输入，代码更清晰，维护方便。

func TestPerson_Marshal(t *testing.T) {
    tests := []struct {
        name     string
        input    Person
        expected string
    }{
        {"正常数据", Person{Name: "Tom", Age: 20}, `{"name":"Tom","age":20}`},
        {"零值", Person{}, `{"name":"","age":0}`},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            data, _ := json.Marshal(tt.input)
            if string(data) != tt.expected {
                t.Errorf("期望 %s, 得到 %s", tt.expected, data)
            }
        })
    }
}

基本上就这些。核心是构造典型数据，正向验证序列化输出，反向确认能还原。结合反射和错误处理，确保结构稳定可靠。不复杂但容易忽略细节。

好了，本文到此结束，带大家了解了《GolangJSON序列化反序列化测试技巧》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！