在Go语言中，可以这样使用Json

在Go语言中，处理JSON数据通常涉及编码（将Go结构体转换为JSON字符串）和解码（将JSON字符串转换为Go结构体）。Go标准库中的encoding/json包提供了这些功能。第三方插件可以使用"github.com/goccy/go-json"也有同样的功能

 Marshal函数将会递归遍历整个对象，依次按成员类型对这个对象进行编码，类型转换规则如下：

• bool类型 转换为JSON的Boolean

• 整数，浮点数等数值类型 转换为JSON的Number

• string 转换为JSON的字符串(带""引号)

• struct 转换为JSON的Object，再根据各个成员的类型递归打包

• 数组或切片 转换为JSON的Array

• []byte 会先进行base64编码然后转换为JSON字符串

• map转换为JSON的Object，key必须是string

• interface{} 按照内部的实际类型进行转换

• nil 转为JSON的null

• channel,func等类型 会返回UnsupportedTypeError

 1、使用标准库中的encoding/json包

字符串输出&格式化输出&解码

package mainimport ("encoding/json""fmt"
)type ColorGroup struct {ID     intName   stringColors []string
}// 创建一个ColorGroup类型的变量来保存解码后的数据
var decodedGroup ColorGroupfunc main() {group := ColorGroup{ID:     1,Name:   "Reds",Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},}// 将结构体编码为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结构体中err = json.Unmarshal([]byte(jsonData1), &decodedGroup)if err != nil {fmt.Println("error:", err)return}// 打印解码后的数据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)将字节切片b（即JSON字符串的字节表示）写入到标准输出fmt.Println("---------------格式化输出----------------")// 使用 MarshalIndent 来格式化输出b2, err := json.MarshalIndent(group, "", "  ") // 第二个参数是空字符串，表示不添加前缀；第三个参数是缩进字符串if err != nil {fmt.Println("error:", err)return}// 使用 fmt.Println 来打印字符串// MarshalIndent返回的是字节切片，我们需要使用string(b2)来将其转换为字符串fmt.Println(string(b2)) // 将字节切片转换为字符串并打印// 输出将会是格式化后的 JSON 字符串// 创建一个ColorGroup类型的变量来保存解码后的数据var decodedGroup ColorGroup// 将JSON字符串解码到ColorGroup结构体中err = json.Unmarshal([]byte(b1), &decodedGroup)if err != nil {fmt.Println("error:", err)return}// 打印解码后的数据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字符串转换为[]byte，并且传入结构体的指针（使用&）。这样，解码后的数据才会被写入到结构体中 

3、decode  

package mainimport ("fmt""github.com/goccy/go-json"
)// Animal 定义结构体来表示单个JSON对象
type Animal struct {Name  stringOrder string
}func main() {//创建一个JSON字节切片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()// 打印解码后的数据for _, animal := range animals {fmt.Printf("Name: %s, Order: %s\n", animal.Name, animal.Order)}
}

4、注意

结构体

结构体必须是大写字母开头的成员才会被JSON处理到，小写字母开头的成员不会有影响。

Mashal时，结构体的成员变量名将会直接作为JSON Object的key打包成JSON；Unmashal时，会自动匹配对应的变量名进行赋值，大小写不敏感。

Unmarshal时，如果JSON中有多余的字段，会被直接抛弃掉；如果JSON缺少某个字段，则直接忽略不对结构体中变量赋值，不会报错。

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/结构体标签

如果希望手动配置结构体的成员和JSON字段的对应关系，可以在定义结构体的时候给成员打标签：

使用omitempty熟悉，如果该字段为nil或0值（数字0,字符串"",空数组[]等），则打包的JSON结果不会有这个字段。

案例一

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映射的结构体
type User struct {Name     string     `json:"username"` // 自定义字段名称映射Email    string     `json:"email"`LastSeen CustomTime `json:"last_seen"` // 嵌套对象Active   bool       `json:"-"`         // 忽略此字段，即使JSON中存在也不解码
}// CustomTime 是一个用于表示时间的结构体
type CustomTime struct {time.Time
}// 实现 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数据jsonData := []byte(`{"username": "johndoe","email": "[e-mail]","last_seen": "2023-04-01T12:34:56Z","active": true}`)// 创建一个 User 实例var user User// 使用 json.Unmarshal 解码 JSON 数据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: [e-mail]//	Last Seen: 2023-04-01 12:34:56 +0000 UTC//Active: false
}

5、更灵活地使用JSON

使用json.RawMessage

json.RawMessage其实就是[]byte类型的重定义。可以进行强制类型转换。

现在有这么一种场景，结构体中的其中一个字段的格式是未知的：

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

使用json.RawMessage的话，Args字段在Unmarshal时不会被解析，直接将字节数据赋值给Args。我们可以能先解包第一层的JSON数据，然后根据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字节切片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实现了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {fmt.Println("--------------使用自定义解码--------------")// 定义一个辅助结构体，用于解码除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)// 将别名结构体中的字段复制到c中*c = Command(aux.alias)// 检查JSON中是否有Args字段，并处理它var m map[string]json.RawMessageif err := json.Unmarshal(data, &m); err != nil {// 如果这里出错，可能是因为JSON格式不正确，但我们可能仍然想要保留已经解析的字段// 因此，我们可以只记录一个错误，但不返回它log.Printf("Error parsing Args field: %v", err)} else {// 如果Args字段存在，将其赋值给c.Argsif rawArgs, ok := m["Args"]; ok {c.Args = &rawArgs // 注意这里我们取了rawArgs的地址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字节切片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实现了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格式不正确，但我们可能仍然想要保留已经解析的字段// 因此，我们可以只记录一个错误，但不返回它log.Printf("Error parsing Args field: %v", err)} else {// 如果Args字段存在，将其赋值给c.Argsif rawArgs, ok := m["Args"]; ok {c.Args = &rawArgs // 注意这里我们取了rawArgs的地址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字节切片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)}
}

 调用的json.Unmarshal，并不是调用json.Unmarshaler，为什么会调用UnmarshalJSON

调用 json.Unmarshal 函数时，您并没有直接调用 json.Unmarshaler 接口的方法。但是，json.Unmarshal 函数在内部会检查目标类型是否实现了 json.Unmarshaler 接口。如果实现了该接口，json.Unmarshal 就会使用您为该类型定义的 UnmarshalJSON 方法来解码 JSON 数据。

这是 json.Unmarshal 函数内部逻辑的一部分，用于确定如何解码 JSON 数据。具体步骤如下：

1. json.Unmarshal 接收一个字节切片（包含 JSON 数据）和一个目标值的指针。
2. 它首先会检查目标值的类型是否实现了 json.Unmarshaler 接口。
3. 如果实现了 json.Unmarshaler 接口，json.Unmarshal 就会调用该类型的 UnmarshalJSON 方法，并将 JSON 数据的字节切片作为参数传递给它。
4. 如果目标值没有实现 json.Unmarshaler 接口，json.Unmarshal 就会使用默认的解码逻辑来填充目标值的字段。

这种机制使得开发者能够灵活地控制 JSON 数据到 Go 结构体之间的转换过程。通过实现 json.Unmarshaler 接口，您可以：

• 处理 JSON 数据中不存在的字段。
• 自定义字段名称的映射规则。
• 处理 JSON 数据中的嵌套对象或数组。
• 执行额外的验证或数据处理逻辑。

以下是简单的示例，展示了如何为一个类型实现 json.Unmarshaler 接口

处理 JSON 数据中不存在的字段

假设我们有一个结构体，它能够处理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": "[e-mail]"}`)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: [e-mail]
}

 自定义字段名称的映射规则

使用结构体标签中的json键来指定JSON字段名。

在这个例子中，结构体的字段名和JSON字段名不匹配，我们通过在结构体标签中指定json来实现映射。

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 数据中的嵌套对象或数组

解码一个包含嵌套结构体的JSON数据。

在这个例子中，Address 是一个嵌套在 User 结构体中的对象。

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
}

 执行额外的验证或数据处理逻辑

在UnmarshalJSON方法中添加额外的验证逻辑。

在这个例子中，我们为User类型实现了自定义的UnmarshalJSON方法。在解码过程中，如果Age字段的值是负数，将返回一个错误，这是一个额外的验证逻辑。

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                         // 影子类型，避免递归调用 UnmarshalJSONaux := &Alias{Name: u.Name, Age: u.Age} // 使用辅助结构体来解耦if err := json.Unmarshal(data, aux); err != nil {return err}*u = User(*aux) // 将解耦的结构体赋值给当前结构体if u.Age < 0 {  //年龄不能为负数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类型实现了 json.Unmarshaler 接口的 UnmarshalJSON 方法，使得 json.Unmarshal 函数在解码 JSON 数据时会调用这个方法，而不是使用默认的解码逻辑。这允许我们自定义解码逻辑，例如只接受特定格式的 JSON 数据。 

 使用interface{}

interface{}类型在Unmarshal时，会自动将JSON转换为对应的数据类型：

JSON的boolean 转换为bool
JSON的数值 转换为float64
JSON的字符串 转换为string
JSON的Array 转换为[]interface{}
JSON的Object 转换为map[string]interface{}
JSON的null 转换为nil

需要注意的有两个。一个是所有的JSON数值自动转换为float64类型，使用时需要再手动转换为需要的int，int64等类型。第二个是JSON的object自动转换为map[string]interface{}类型，访问时直接用JSON ``Object的字段名作为key进行访问。再不知道JSON数据的格式时，可以使用interface{}。