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

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

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

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

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

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

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

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

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

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

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

• channel,func等類型 會返回UnsupportedTypeError

?1、使用標準庫中的encoding/json包

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

package mainimport ("encoding/json""fmt"
)type ColorGroup struct {ID     intName   stringColors []string
}// 創(chuàng)建一個ColorGroup類型的變量來保存解碼后的數(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、使用第三方包

標準輸出&格式化輸出&解碼

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é)表示）寫入到標準輸出fmt.Println("---------------格式化輸出----------------")// 使用 MarshalIndent 來格式化輸出b2, err := json.MarshalIndent(group, "", "  ") // 第二個參數(shù)是空字符串，表示不添加前綴；第三個參數(shù)是縮進字符串if err != nil {fmt.Println("error:", err)return}// 使用 fmt.Println 來打印字符串// MarshalIndent返回的是字節(jié)切片，我們需要使用string(b2)來將其轉(zhuǎn)換為字符串fmt.Println(string(b2)) // 將字節(jié)切片轉(zhuǎn)換為字符串并打印// 輸出將會是格式化后的 JSON 字符串// 創(chuàng)建一個ColorGroup類型的變量來保存解碼后的數(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])
}

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

3、decode??

package mainimport ("fmt""github.com/goccy/go-json"
)// Animal 定義結(jié)構(gòu)體來表示單個JSON對象
type Animal struct {Name  stringOrder string
}func main() {//創(chuàng)建一個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)體必須是大寫字母開頭的成員才會被JSON處理到，小寫字母開頭的成員不會有影響。

Mashal時，結(jié)構(gòu)體的成員變量名將會直接作為JSON?Object的key打包成JSON；Unmashal時，會自動匹配對應的變量名進行賦值，大小寫不敏感。

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

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)體標簽

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

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

案例一

package mainimport ("encoding/json""fmt"
)type Message struct {Name string `json:"msg_name"`       // 對應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"
)// 定義一個用于JSON映射的結(jié)構(gòu)體
type User struct {Name     string     `json:"username"` // 自定義字段名稱映射Email    string     `json:"email"`LastSeen CustomTime `json:"last_seen"` // 嵌套對象Active   bool       `json:"-"`         // 忽略此字段，即使JSON中存在也不解碼
}// CustomTime 是一個用于表示時間的結(jié)構(gòu)體
type CustomTime struct {time.Time
}// 實現(xiàn) json.Unmarshaler 接口的 UnmarshalJSON 方法
func (ct *CustomTime) UnmarshalJSON(data []byte) error {var s stringif err := json.Unmarshal(data, &s); err != nil {return err}// 解析自定義時間格式parsedTime, err := time.Parse(time.RFC3339, s)if err != nil {return err}ct.Time = parsedTimereturn nil
}func main() {// 模擬從HTTP請求中獲取的JSON數(shù)據(jù)jsonData := []byte(`{"username": "johndoe","email": "john.doe@example.com","last_seen": "2023-04-01T12:34:56Z","active": true}`)// 創(chuàng)建一個 User 實例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 字段將不會被解碼，即使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其實就是[]byte類型的重定義。可以進行強制類型轉(zhuǎn)換。

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

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

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

這里要注意的是，一定要使用指針類型*json.RawMessage，否則在Args會被認為是[]byte類型，在打包時會被打包成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)// 如果需要，可以進一步處理cmd.Args字段// 例如，將其解析為特定的Go類型var args []stringif err := json.Unmarshal(*cmd.Args, &args); err != nil {log.Printf("解析錯誤: %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實現(xiàn)了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {fmt.Println("--------------使用自定義解碼--------------")// 定義一個輔助結(jié)構(gòu)體，用于解碼除Args外的其他字段type alias Commandvar aux struct {alias // 嵌入別名類型以獲取其他字段}// 先解碼除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)體中的字段復制到c中*c = Command(aux.alias)// 檢查JSON中是否有Args字段，并處理它var m map[string]json.RawMessageif err := json.Unmarshal(data, &m); err != nil {// 如果這里出錯，可能是因為JSON格式不正確，但我們可能仍然想要保留已經(jīng)解析的字段// 因此，我們可以只記錄一個錯誤，但不返回它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)}}}// 如果沒有錯誤，返回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實現(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 {// 如果這里出錯，可能是因為JSON格式不正確，但我們可能仍然想要保留已經(jīng)解析的字段// 因此，我們可以只記錄一個錯誤，但不返回它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)}}}// 如果沒有錯誤，返回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，為什么會調(diào)用UnmarshalJSON

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

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

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

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

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

以下是簡單的示例，展示了如何為一個類型實現(xiàn)?json.Unmarshaler?接口

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

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

在這個例子中，Age 字段在JSON中不存在，因此它將被賦予其類型的零值（對于int類型是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 中沒有 "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
}

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

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

在這個例子中，結(jié)構(gòu)體的字段名和JSON字段名不匹配，我們通過在結(jié)構(gòu)體標簽中指定json來實現(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ù)中的嵌套對象或數(shù)組

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

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

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"` // 嵌套對象
}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í)行額外的驗證或數(shù)據(jù)處理邏輯

在UnmarshalJSON方法中添加額外的驗證邏輯。

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

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                         // 影子類型，避免遞歸調(diào)用 UnmarshalJSONaux := &Alias{Name: u.Name, Age: u.Age} // 使用輔助結(jié)構(gòu)體來解耦if err := json.Unmarshal(data, aux); err != nil {return err}*u = User(*aux) // 將解耦的結(jié)構(gòu)體賦值給當前結(jié)構(gòu)體if u.Age < 0 {  //年齡不能為負數(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類型實現(xiàn)了?json.Unmarshaler?接口的?UnmarshalJSON?方法，使得?json.Unmarshal?函數(shù)在解碼 JSON 數(shù)據(jù)時會調(diào)用這個方法，而不是使用默認的解碼邏輯。這允許我們自定義解碼邏輯，例如只接受特定格式的 JSON 數(shù)據(jù)。?

?使用interface{}

interface{}類型在Unmarshal時，會自動將JSON轉(zhuǎn)換為對應的數(shù)據(jù)類型：

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

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