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 mainimport ( "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: %sn", 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: %+vn", 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 mainimport ( "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: %sn", 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: %+vn", newEvent) // Output: Deserialized Event: {Name:Launch Party Time:2023-12-25 18:00:00 +0000 UTC}}
3. 处理流式数据
对于大型JSON文件或网络流，使用
json.Encoder
和
json.Decoder
可以更高效地处理数据，避免一次性将所有数据加载到内存中。
package mainimport ( "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("%sn", 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: %+vn", p) } /* Output: Decoding products: Decoded: {ID:201 Name:Keyboard Price:75} Decoded: {ID:202 Name:Monitor Price:300} */}
为什么我的JSON序列化结果和预期不符？深入理解
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
（对于布尔值）。
举个例子，
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{}
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 mainimport ( "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: %Tn", key, value, value) } // 访问特定字段需要进行类型断言 if name, ok := data["name"].(string); ok { fmt.Printf("Name: %sn", name) } if age, ok := data["age"].(float64); ok { // JSON数字默认解析为float64 fmt.Printf("Age: %.0fn", age) } if address, ok := data["address"].(map[string]interface{}); ok { if city, ok := address["city"].(string); ok { fmt.Printf("City: %sn", city) } }}
实战考量：
优点： 极度灵活，可以处理任何JSON结构，无需预先定义结构体。缺点： 缺乏类型安全，每次访问字段都需要进行类型断言，这会增加代码的复杂性和出错的可能性。性能上通常不如直接反序列化到结构体。适用场景： 当JSON结构真的完全未知，或者你只需要快速检查几个顶层字段时。例如，一个日志系统接收各种格式的JSON日志。
2.
json.RawMessage
：延迟解析与局部控制
json.RawMessage
是一个
[]byte
类型，它表示一个未解析的原始JSON值。当你将一个字段声明为
json.RawMessage
时，
encoding/json
包在反序列化时会直接将该字段对应的JSON子串（包括其内部的结构）原封不动地存储为字节切片，而不会进行进一步的解析。你需要手动对这个
RawMessage
进行二次解析。
package mainimport ( "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: %sn", resp1.Status, resp1.Message)
以上就是GolangJSON处理技巧 序列化与反序列化的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1402193.html
微信扫一扫 
支付宝扫一扫 
