在Go語(yǔ)言中，處理JSON數(shù)據(jù)通常涉及編碼（將Go結(jié)構(gòu)體轉(zhuǎn)換為JSON字符串）和解碼（將JSON字符串轉(zhuǎn)換為Go結(jié)構(gòu)體）。Go標(biāo)準(zhǔn)庫(kù)中的encoding/json包提供了這些功能。第三方插件可以使用"github.com/goccy/go-json"也有同樣的功能

?Marshal函數(shù)將會(huì)遞歸遍歷整個(gè)對(duì)象，依次按成員類(lèi)型對(duì)這個(gè)對(duì)象進(jìn)行編碼，類(lèi)型轉(zhuǎn)換規(guī)則如下：

• bool類(lèi)型 轉(zhuǎn)換為JSON的Boolean

• 整數(shù)，浮點(diǎn)數(shù)等數(shù)值類(lèi)型 轉(zhuǎn)換為JSON的Number

• string?轉(zhuǎn)換為JSON的字符串(帶""引號(hào))

• struct?轉(zhuǎn)換為JSON的Object，再根據(jù)各個(gè)成員的類(lèi)型遞歸打包

• 數(shù)組或切片 轉(zhuǎn)換為JSON的Array

• []byte?會(huì)先進(jìn)行base64編碼然后轉(zhuǎn)換為JSON字符串

• map轉(zhuǎn)換為JSON的Object，key必須是string

• interface{}?按照內(nèi)部的實(shí)際類(lèi)型進(jìn)行轉(zhuǎn)換

• nil?轉(zhuǎn)為JSON的null

• channel,func等類(lèi)型 會(huì)返回UnsupportedTypeError

?1、使用標(biāo)準(zhǔn)庫(kù)中的encoding/json包

字符串輸出&格式化輸出&解碼

package mainimport ("encoding/json""fmt"
)type ColorGroup struct {ID     intName   stringColors []string
}// 創(chuàng)建一個(gè)ColorGroup類(lèi)型的變量來(lái)保存解碼后的數(shù)據(jù)
var decodedGroup ColorGroupfunc main() {group := ColorGroup{ID:     1,Name:   "Reds",Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},}// 將結(jié)構(gòu)體編碼為JSON字符串jsonData1, err := json.Marshal(group)jsonData2, err := json.MarshalIndent(group, "", "	")if err != nil {fmt.Println("error:", err)return}// 打印JSON字符串fmt.Println(string(jsonData1))fmt.Println(string(jsonData2))// Output://{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}//	{//		"ID": 1,//		"Name": "Reds",//		"Colors": [//			"Crimson",//			"Red",//			"Ruby",//			"Maroon"//		]//	}// 將JSON字符串解碼到ColorGroup結(jié)構(gòu)體中err = json.Unmarshal([]byte(jsonData1), &decodedGroup)if err != nil {fmt.Println("error:", err)return}// 打印解碼后的數(shù)據(jù)fmt.Printf("ID: %d, Name: %s, Colors: %v\n", decodedGroup.ID, decodedGroup.Name, decodedGroup.Colors)// Output: ID: 1, Name: Reds, Colors: [Crimson Red Ruby Maroon]fmt.Println(decodedGroup.Colors[0])fmt.Println(decodedGroup.Colors[1])
}

?2、使用第三方包

標(biāo)準(zhǔn)輸出&格式化輸出&解碼

package mainimport ("fmt""github.com/goccy/go-json""os"
)type ColorGroup struct {ID     intName   stringColors []string
}func main() {group := ColorGroup{ID:     1,Name:   "Reds",Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},}b1, err := json.Marshal(group)if err != nil {fmt.Println("error:", err)}println(os.Stdout.Write(b1)) //os.Stdout.Write(b1)將字節(jié)切片b（即JSON字符串的字節(jié)表示）寫(xiě)入到標(biāo)準(zhǔn)輸出fmt.Println("---------------格式化輸出----------------")// 使用 MarshalIndent 來(lái)格式化輸出b2, err := json.MarshalIndent(group, "", "  ") // 第二個(gè)參數(shù)是空字符串，表示不添加前綴；第三個(gè)參數(shù)是縮進(jìn)字符串if err != nil {fmt.Println("error:", err)return}// 使用 fmt.Println 來(lái)打印字符串// MarshalIndent返回的是字節(jié)切片，我們需要使用string(b2)來(lái)將其轉(zhuǎn)換為字符串fmt.Println(string(b2)) // 將字節(jié)切片轉(zhuǎn)換為字符串并打印// 輸出將會(huì)是格式化后的 JSON 字符串// 創(chuàng)建一個(gè)ColorGroup類(lèi)型的變量來(lái)保存解碼后的數(shù)據(jù)var decodedGroup ColorGroup// 將JSON字符串解碼到ColorGroup結(jié)構(gòu)體中err = json.Unmarshal([]byte(b1), &decodedGroup)if err != nil {fmt.Println("error:", err)return}// 打印解碼后的數(shù)據(jù)fmt.Printf("ID: %d, Name: %s, Colors: %v\n", decodedGroup.ID, decodedGroup.Name, decodedGroup.Colors)// Output: ID: 1, Name: Reds, Colors: [Crimson Red Ruby Maroon]fmt.Println(decodedGroup.Colors[0])fmt.Println(decodedGroup.Colors[1])
}

請(qǐng)注意，在解碼時(shí)，你需要將JSON字符串轉(zhuǎn)換為[]byte，并且傳入結(jié)構(gòu)體的指針（使用&）。這樣，解碼后的數(shù)據(jù)才會(huì)被寫(xiě)入到結(jié)構(gòu)體中?

3、decode??

package mainimport ("fmt""github.com/goccy/go-json"
)// Animal 定義結(jié)構(gòu)體來(lái)表示單個(gè)JSON對(duì)象
type Animal struct {Name  stringOrder string
}func main() {//創(chuàng)建一個(gè)JSON字節(jié)切片var jsonBlob = []byte(`[   {"Name": "Platypus", "Order": "Monotremata"},   {"Name": "Quoll", "Order": "Dasyuromorphia"}   ]`)var animals []Animalerr := json.Unmarshal(jsonBlob, &animals)if err != nil {fmt.Println("error:", err)}fmt.Printf("%+v", animals)fmt.Println()// 打印解碼后的數(shù)據(jù)for _, animal := range animals {fmt.Printf("Name: %s, Order: %s\n", animal.Name, animal.Order)}
}

4、注意

結(jié)構(gòu)體

結(jié)構(gòu)體必須是大寫(xiě)字母開(kāi)頭的成員才會(huì)被JSON處理到，小寫(xiě)字母開(kāi)頭的成員不會(huì)有影響。

Mashal時(shí)，結(jié)構(gòu)體的成員變量名將會(huì)直接作為JSON?Object的key打包成JSON；Unmashal時(shí)，會(huì)自動(dòng)匹配對(duì)應(yīng)的變量名進(jìn)行賦值，大小寫(xiě)不敏感。

Unmarshal時(shí)，如果JSON中有多余的字段，會(huì)被直接拋棄掉；如果JSON缺少某個(gè)字段，則直接忽略不對(duì)結(jié)構(gòu)體中變量賦值，不會(huì)報(bào)錯(cuò)。

package mainimport ("encoding/json""fmt"
)type Message struct {Name  stringBody  stringTime  int64inner string
}func main() {var m = Message{Name:  "Alice",Body:  "Hello",Time:  1294706395881547000,inner: "ok",}b := []byte(`{"nAmE":"Bob","Food":"Pickle", "inner":"changed"}`)err := json.Unmarshal(b, &m)if err != nil {fmt.Printf(err.Error())return}fmt.Printf("%v", m)//Output: {Bob Hello 1294706395881547000 ok}
}

StructTag/結(jié)構(gòu)體標(biāo)簽

如果希望手動(dòng)配置結(jié)構(gòu)體的成員和JSON字段的對(duì)應(yīng)關(guān)系，可以在定義結(jié)構(gòu)體的時(shí)候給成員打標(biāo)簽：

使用omitempty熟悉，如果該字段為nil或0值（數(shù)字0,字符串"",空數(shù)組[]等），則打包的JSON結(jié)果不會(huì)有這個(gè)字段。

案例一

package mainimport ("encoding/json""fmt"
)type Message struct {Name string `json:"msg_name"`       // 對(duì)應(yīng)JSON的msg_nameBody string `json:"body,omitempty"` // 如果為空置則忽略字段Time int64  `json:"-"`              // 直接忽略字段
}func main() {var m = Message{Name: "Alice",Body: "",Time: 1294706395881547000,}data, err := json.Marshal(m)if err != nil {fmt.Printf(err.Error())return}fmt.Println(string(data))//Output:{"msg_name":"Alice"}
}

案例二?

package mainimport ("encoding/json""fmt""log""time"
)// 定義一個(gè)用于JSON映射的結(jié)構(gòu)體
type User struct {Name     string     `json:"username"` // 自定義字段名稱(chēng)映射Email    string     `json:"email"`LastSeen CustomTime `json:"last_seen"` // 嵌套對(duì)象Active   bool       `json:"-"`         // 忽略此字段，即使JSON中存在也不解碼
}// CustomTime 是一個(gè)用于表示時(shí)間的結(jié)構(gòu)體
type CustomTime struct {time.Time
}// 實(shí)現(xiàn) json.Unmarshaler 接口的 UnmarshalJSON 方法
func (ct *CustomTime) UnmarshalJSON(data []byte) error {var s stringif err := json.Unmarshal(data, &s); err != nil {return err}// 解析自定義時(shí)間格式parsedTime, err := time.Parse(time.RFC3339, s)if err != nil {return err}ct.Time = parsedTimereturn nil
}func main() {// 模擬從HTTP請(qǐng)求中獲取的JSON數(shù)據(jù)jsonData := []byte(`{"username": "johndoe","email": "john.doe@example.com","last_seen": "2023-04-01T12:34:56Z","active": true}`)// 創(chuàng)建一個(gè) User 實(shí)例var user User// 使用 json.Unmarshal 解碼 JSON 數(shù)據(jù)if err := json.Unmarshal(jsonData, &user); err != nil {log.Fatal("Error unmarshaling JSON:", err)}// 打印解碼后的信息fmt.Printf("Name: %s\n", user.Name)fmt.Printf("Email: %s\n", user.Email)fmt.Printf("Last Seen: %v\n", user.LastSeen)// Active 字段將不會(huì)被解碼，即使JSON中存在fmt.Printf("Active: %v\n", user.Active)//輸出：//Name: johndoe//Email: john.doe@example.com//	Last Seen: 2023-04-01 12:34:56 +0000 UTC//Active: false
}

5、更靈活地使用JSON

使用json.RawMessage

json.RawMessage其實(shí)就是[]byte類(lèi)型的重定義?？梢赃M(jìn)行強(qiáng)制類(lèi)型轉(zhuǎn)換。

現(xiàn)在有這么一種場(chǎng)景，結(jié)構(gòu)體中的其中一個(gè)字段的格式是未知的：

type Command struct {ID   intCmd  stringArgs *json.RawMessage
}

使用json.RawMessage的話(huà)，Args字段在Unmarshal時(shí)不會(huì)被解析，直接將字節(jié)數(shù)據(jù)賦值給Args。我們可以能先解包第一層的JSON數(shù)據(jù)，然后根據(jù)Cmd的值，再確定Args的具體類(lèi)型進(jìn)行第二次Unmarshal。

這里要注意的是，一定要使用指針類(lèi)型*json.RawMessage，否則在Args會(huì)被認(rèn)為是[]byte類(lèi)型，在打包時(shí)會(huì)被打包成base64編碼的字符串。

案例一

package mainimport ("encoding/json""fmt""log"
)type Command struct {ID   intCmd  stringArgs *json.RawMessage // 未解析的JSON片段
}func main() {//json字節(jié)切片jsonData := []byte(`{  "ID": 1,  "Cmd": "example",  "Args": ["arg1", "arg2"]  }`)var cmd Command//解碼/反序列化if err := json.Unmarshal(jsonData, &cmd); err != nil {log.Fatalf("Error unmarshaling JSON: %v", err)}fmt.Printf("Command: %+v\n", cmd)// 如果需要，可以進(jìn)一步處理cmd.Args字段// 例如，將其解析為特定的Go類(lèi)型var args []stringif err := json.Unmarshal(*cmd.Args, &args); err != nil {log.Printf("解析錯(cuò)誤: %v", err)} else {fmt.Printf("Args: %v\n", args)}//輸出//Command: {ID:1 Cmd:example Args:0xc0000080f0}//Args: [arg1 arg2]
}

案例二

package mainimport ("encoding/json""fmt""log"
)type Command struct {ID   intCmd  stringArgs *json.RawMessage // 未解析的JSON片段
}// UnmarshalJSON 自定義JSON解碼方法，Command實(shí)現(xiàn)了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {fmt.Println("--------------使用自定義解碼--------------")// 定義一個(gè)輔助結(jié)構(gòu)體，用于解碼除Args外的其他字段type alias Commandvar aux struct {alias // 嵌入別名類(lèi)型以獲取其他字段}// 先解碼除Args外的所有字段if err := json.Unmarshal(data, &aux); err != nil {return err}fmt.Printf("Command ID: %+v, Cmd: %+v\n", aux.alias.ID, aux.alias.Cmd)// 將別名結(jié)構(gòu)體中的字段復(fù)制到c中*c = Command(aux.alias)// 檢查JSON中是否有Args字段，并處理它var m map[string]json.RawMessageif err := json.Unmarshal(data, &m); err != nil {// 如果這里出錯(cuò)，可能是因?yàn)镴SON格式不正確，但我們可能仍然想要保留已經(jīng)解析的字段// 因此，我們可以只記錄一個(gè)錯(cuò)誤，但不返回它log.Printf("Error parsing Args field: %v", err)} else {// 如果Args字段存在，將其賦值給c.Argsif rawArgs, ok := m["Args"]; ok {c.Args = &rawArgs // 注意這里我們?nèi)×藃awArgs的地址var args []stringif err := json.Unmarshal(*c.Args, &args); err != nil {log.Printf("Error parsing Args contents: %v", err)} else {fmt.Printf("Args: %v\n", args)}}}// 如果沒(méi)有錯(cuò)誤，返回nilreturn nil
}func main() {//json字節(jié)切片jsonData := []byte(`{  "ID": 1,  "Cmd": "example",  "Args": ["arg1", "arg2"]  }`)var cmd Command//解碼/反序列化if err := json.Unmarshal(jsonData, &cmd); err != nil {log.Fatalf("Error unmarshaling JSON: %v", err)}
}

案例三?

package mainimport ("encoding/json""fmt""log"
)type Command struct {ID   intCmd  stringArgs *json.RawMessage // 未解析的JSON片段
}// UnmarshalJSON 自定義JSON解碼方法，Command實(shí)現(xiàn)了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {fmt.Println("--------------使用自定義解碼--------------")// 檢查JSON中是否有Args字段，并處理它var m map[string]json.RawMessageif err := json.Unmarshal(data, &m); err != nil {// 如果這里出錯(cuò)，可能是因?yàn)镴SON格式不正確，但我們可能仍然想要保留已經(jīng)解析的字段// 因此，我們可以只記錄一個(gè)錯(cuò)誤，但不返回它log.Printf("Error parsing Args field: %v", err)} else {// 如果Args字段存在，將其賦值給c.Argsif rawArgs, ok := m["Args"]; ok {c.Args = &rawArgs // 注意這里我們?nèi)×藃awArgs的地址var args []stringif err := json.Unmarshal(*c.Args, &args); err != nil {log.Printf("Error parsing Args contents: %v", err)} else {fmt.Printf("Args: %v\n", args)}}}// 如果沒(méi)有錯(cuò)誤，返回nilreturn nil
}func main() {//json字節(jié)切片jsonData := []byte(`{  "ID": 1,  "Cmd": "example",  "Args": ["arg1", "arg2"]  }`)var cmd Command//解碼/反序列化if err := json.Unmarshal(jsonData, &cmd); err != nil {log.Fatalf("Error unmarshaling JSON: %v", err)}
}

?調(diào)用的json.Unmarshal，并不是調(diào)用json.Unmarshaler，為什么會(huì)調(diào)用UnmarshalJSON

調(diào)用?json.Unmarshal?函數(shù)時(shí)，您并沒(méi)有直接調(diào)用?json.Unmarshaler?接口的方法。但是，json.Unmarshal?函數(shù)在內(nèi)部會(huì)檢查目標(biāo)類(lèi)型是否實(shí)現(xiàn)了?json.Unmarshaler?接口。如果實(shí)現(xiàn)了該接口，json.Unmarshal?就會(huì)使用您為該類(lèi)型定義的?UnmarshalJSON?方法來(lái)解碼 JSON 數(shù)據(jù)。

這是?json.Unmarshal?函數(shù)內(nèi)部邏輯的一部分，用于確定如何解碼 JSON 數(shù)據(jù)。具體步驟如下：

1. json.Unmarshal?接收一個(gè)字節(jié)切片（包含 JSON 數(shù)據(jù)）和一個(gè)目標(biāo)值的指針。
2. 它首先會(huì)檢查目標(biāo)值的類(lèi)型是否實(shí)現(xiàn)了?json.Unmarshaler?接口。
3. 如果實(shí)現(xiàn)了?json.Unmarshaler?接口，json.Unmarshal?就會(huì)調(diào)用該類(lèi)型的?UnmarshalJSON?方法，并將 JSON 數(shù)據(jù)的字節(jié)切片作為參數(shù)傳遞給它。
4. 如果目標(biāo)值沒(méi)有實(shí)現(xiàn)?json.Unmarshaler?接口，json.Unmarshal?就會(huì)使用默認(rèn)的解碼邏輯來(lái)填充目標(biāo)值的字段。

這種機(jī)制使得開(kāi)發(fā)者能夠靈活地控制 JSON 數(shù)據(jù)到 Go 結(jié)構(gòu)體之間的轉(zhuǎn)換過(guò)程。通過(guò)實(shí)現(xiàn)?json.Unmarshaler?接口，您可以：

• 處理 JSON 數(shù)據(jù)中不存在的字段。
• 自定義字段名稱(chēng)的映射規(guī)則。
• 處理 JSON 數(shù)據(jù)中的嵌套對(duì)象或數(shù)組。
• 執(zhí)行額外的驗(yàn)證或數(shù)據(jù)處理邏輯。

以下是簡(jiǎn)單的示例，展示了如何為一個(gè)類(lèi)型實(shí)現(xiàn)?json.Unmarshaler?接口

處理 JSON 數(shù)據(jù)中不存在的字段

假設(shè)我們有一個(gè)結(jié)構(gòu)體，它能夠處理JSON中可能缺失的字段，并且為這些字段提供默認(rèn)值。?

在這個(gè)例子中，Age 字段在JSON中不存在，因此它將被賦予其類(lèi)型的零值（對(duì)于int類(lèi)型是0）。

package mainimport ("encoding/json""fmt""log"
)type User struct {Name  string `json:"name"`Age   int    `json:"age"`Email string `json:"email,omitempty"`
}func main() {var user User// JSON 中沒(méi)有 "age" 字段，將使用 Age 的零值 0jsonData := []byte(`{"name": "John", "email": "john@example.com"}`)if err := json.Unmarshal(jsonData, &user); err != nil {log.Fatal(err)}fmt.Printf("Name: %s, Age: %d, Email: %s\n", user.Name, user.Age, user.Email)//Name: John, Age: 0, Email: john@example.com
}

?自定義字段名稱(chēng)的映射規(guī)則

使用結(jié)構(gòu)體標(biāo)簽中的json鍵來(lái)指定JSON字段名。

在這個(gè)例子中，結(jié)構(gòu)體的字段名和JSON字段名不匹配，我們通過(guò)在結(jié)構(gòu)體標(biāo)簽中指定json來(lái)實(shí)現(xiàn)映射。

package mainimport ("encoding/json""fmt""log"
)type User struct {Username string `json:"user_name"`Password string `json:"pass"`
}func main() {var user UserjsonData := []byte(`{"user_name": "johndoe", "pass": "secret"}`)if err := json.Unmarshal(jsonData, &user); err != nil {log.Fatal(err)}fmt.Printf("Username: %s, Password: %s\n", user.Username, user.Password)//Username: johndoe, Password: secret
}

?處理 JSON 數(shù)據(jù)中的嵌套對(duì)象或數(shù)組

解碼一個(gè)包含嵌套結(jié)構(gòu)體的JSON數(shù)據(jù)。

在這個(gè)例子中，Address 是一個(gè)嵌套在 User 結(jié)構(gòu)體中的對(duì)象。

package mainimport ("encoding/json""fmt""log"
)type Address struct {City    string `json:"city"`Country string `json:"country"`
}type User struct {Name    string  `json:"name"`Address Address `json:"address"` // 嵌套對(duì)象
}func main() {var user UserjsonData := []byte(`{"name": "Jane", "address": {"city": "New York", "country": "USA"}}`)if err := json.Unmarshal(jsonData, &user); err != nil {log.Fatal(err)}fmt.Printf("Name: %s, Lives in %s, %s\n", user.Name, user.Address.City, user.Address.Country)//Name: Jane, Lives in New York, USA
}

?執(zhí)行額外的驗(yàn)證或數(shù)據(jù)處理邏輯

在UnmarshalJSON方法中添加額外的驗(yàn)證邏輯。

在這個(gè)例子中，我們?yōu)?code>User類(lèi)型實(shí)現(xiàn)了自定義的UnmarshalJSON方法。在解碼過(guò)程中，如果Age字段的值是負(fù)數(shù)，將返回一個(gè)錯(cuò)誤，這是一個(gè)額外的驗(yàn)證邏輯。

package mainimport ("encoding/json""fmt""log"
)type User struct {Name string `json:"name"`Age  int    `json:"age"`
}func (u *User) UnmarshalJSON(data []byte) error {type Alias User                         // 影子類(lèi)型，避免遞歸調(diào)用 UnmarshalJSONaux := &Alias{Name: u.Name, Age: u.Age} // 使用輔助結(jié)構(gòu)體來(lái)解耦if err := json.Unmarshal(data, aux); err != nil {return err}*u = User(*aux) // 將解耦的結(jié)構(gòu)體賦值給當(dāng)前結(jié)構(gòu)體if u.Age < 0 {  //年齡不能為負(fù)數(shù)return fmt.Errorf("age cannot be negative")}return nil
}func main() {var user UserjsonData := []byte(`{"name": "Alice", "age": -5}`)if err := json.Unmarshal(jsonData, &user); err != nil {log.Fatal(err)}fmt.Printf("Name: %s, Age: %d\n", user.Name, user.Age)
}

?在上面的示例中，User類(lèi)型實(shí)現(xiàn)了?json.Unmarshaler?接口的?UnmarshalJSON?方法，使得?json.Unmarshal?函數(shù)在解碼 JSON 數(shù)據(jù)時(shí)會(huì)調(diào)用這個(gè)方法，而不是使用默認(rèn)的解碼邏輯。這允許我們自定義解碼邏輯，例如只接受特定格式的 JSON 數(shù)據(jù)。?

?使用interface{}

interface{}類(lèi)型在Unmarshal時(shí)，會(huì)自動(dòng)將JSON轉(zhuǎn)換為對(duì)應(yīng)的數(shù)據(jù)類(lèi)型：

JSON的boolean?轉(zhuǎn)換為bool
JSON的數(shù)值?轉(zhuǎn)換為float64
JSON的字符串?轉(zhuǎn)換為string
JSON的Array?轉(zhuǎn)換為[]interface{}
JSON的Object?轉(zhuǎn)換為map[string]interface{}
JSON的null?轉(zhuǎn)換為nil

需要注意的有兩個(gè)。一個(gè)是所有的JSON數(shù)值自動(dòng)轉(zhuǎn)換為float64類(lèi)型，使用時(shí)需要再手動(dòng)轉(zhuǎn)換為需要的int，int64等類(lèi)型。第二個(gè)是JSON的object自動(dòng)轉(zhuǎn)換為map[string]interface{}類(lèi)型，訪(fǎng)問(wèn)時(shí)直接用JSON ``Object的字段名作為key進(jìn)行訪(fǎng)問(wèn)。再不知道JSON數(shù)據(jù)的格式時(shí)，可以使用interface{}。