Golang通过encoding/json包实现JSON处理，核心包括使用json.Marshal和Unmarshal进行序列化与反序列化，利用结构体标签控制字段映射、省略零值及字符串转换，支持自定义类型通过实现Marshaler和Unmarshaler接口，使用Encoder/Decoder处理流式数据，并借助map[string]interface{}和json.RawMessage应对不确定结构，提升灵活性与性能。
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`），这个标签就显得尤为重要。json:"-"
: 简单粗暴，这个标签会告诉encoding/json
包完全忽略这个字段。无论序列化还是反序列化，它都不会被处理。当你的结构体中包含一些只用于内部逻辑、不希望暴露给外部JSON的字段时，它就派上用场了。-
json:",omitempty"
: 这个标签非常实用，它会在字段值是其类型的“零值”时，在JSON输出中省略该字段。零值包括：nil
（对于指针、切片、映射、接口）、""
（对于字符串）、0
（对于数字）、false
（对于布尔值）。 -
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处理这类挑战的利器。
1. 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日志。
2. 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) 
