Go语言使用Json的方法实现
作者：比猪聪明
本文主要介绍了Go语言使用Json的方法实现
在Go语言中，处理JSON数据通常涉及编码（将Go结构体转换为JSON字符串）和解码（将JSON字符串转换为Go结构体）。Go标准库中的encoding/json包提供了这些功能。第三方插件可以使用"github.com/goccy/go-json"也有同样的功能
Marshal函数将会递归遍历整个对象，依次按成员类型对这个对象进行编码，类型转换规则如下：
bool类型 转换为JSON的Boolean整数，浮点数等数值类型 转换为
JSON的Numberstring转换为JSON的字符串(带""引号)struct转换为JSON的Object，再根据各个成员的类型递归打包数组或切片 转换为
JSON的Array[]byte会先进行base64编码然后转换为JSON字符串map转换为JSON的Object，key必须是stringinterface{}按照内部的实际类型进行转换nil转为JSON的nullchannel,func等类型 会返回UnsupportedTypeError
1、使用标准库中的encoding/json包
字符串输出&格式化输出&解码
package main
import (
"encoding/json"
"fmt"
)
type ColorGroup struct {
ID int
Name string
Colors []string
}
// 创建一个ColorGroup类型的变量来保存解码后的数据
var decodedGroup ColorGroup
func 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 main
import (
"fmt"
"github.com/goccy/go-json"
"os"
)
type ColorGroup struct {
ID int
Name string
Colors []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 main
import (
"fmt"
"github.com/goccy/go-json"
)
// Animal 定义结构体来表示单个JSON对象
type Animal struct {
Name string
Order string
}
func main() {
//创建一个JSON字节切片
var jsonBlob = []byte(`[
{"Name": "Platypus", "Order": "Monotremata"},
{"Name": "Quoll", "Order": "Dasyuromorphia"}
]`)
var animals []Animal
err := 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 main
import (
"encoding/json"
"fmt"
)
type Message struct {
Name string
Body string
Time int64
inner 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 main
import (
"encoding/json"
"fmt"
)
type Message struct {
Name string `json:"msg_name"` // 对应JSON的msg_name
Body 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 main
import (
"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 string
if err := json.Unmarshal(data, &s); err != nil {
return err
}
// 解析自定义时间格式
parsedTime, err := time.Parse(time.RFC3339, s)
if err != nil {
return err
}
ct.Time = parsedTime
return nil
}
func main() {
// 模拟从HTTP请求中获取的JSON数据
jsonData := []byte(`{
"username": "johndoe",
"email": "john.doe@example.com",
"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: john.doe@example.com
// Last Seen: 2023-04-01 12:34:56 +0000 UTC
//Active: false
}5、更灵活地使用JSON
使用json.RawMessage
json.RawMessage其实就是[]byte类型的重定义。可以进行强制类型转换。
现在有这么一种场景，结构体中的其中一个字段的格式是未知的：
type Command struct {
ID int
Cmd string
Args *json.RawMessage
}使用json.RawMessage的话，Args字段在Unmarshal时不会被解析，直接将字节数据赋值给Args。我们可以能先解包第一层的JSON数据，然后根据Cmd的值，再确定Args的具体类型进行第二次Unmarshal。
这里要注意的是，一定要使用指针类型*json.RawMessage，否则在Args会被认为是[]byte类型，在打包时会被打包成base64编码的字符串。
案例一
package main
import (
"encoding/json"
"fmt"
"log"
)
type Command struct {
ID int
Cmd string
Args *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 []string
if 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 main
import (
"encoding/json"
"fmt"
"log"
)
type Command struct {
ID int
Cmd string
Args *json.RawMessage // 未解析的JSON片段
}
// UnmarshalJSON 自定义JSON解码方法，Command实现了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {
fmt.Println("--------------使用自定义解码--------------")
// 定义一个辅助结构体，用于解码除Args外的其他字段
type alias Command
var 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.RawMessage
if err := json.Unmarshal(data, &m); err != nil {
// 如果这里出错，可能是因为JSON格式不正确，但我们可能仍然想要保留已经解析的字段
// 因此，我们可以只记录一个错误，但不返回它
log.Printf("Error parsing Args field: %v", err)
} else {
// 如果Args字段存在，将其赋值给c.Args
if rawArgs, ok := m["Args"]; ok {
c.Args = &rawArgs // 注意这里我们取了rawArgs的地址
var args []string
if err := json.Unmarshal(*c.Args, &args); err != nil {
log.Printf("Error parsing Args contents: %v", err)
} else {
fmt.Printf("Args: %v\n", args)
}
}
}
// 如果没有错误，返回nil
return 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 main
import (
"encoding/json"
"fmt"
"log"
)
type Command struct {
ID int
Cmd string
Args *json.RawMessage // 未解析的JSON片段
}
// UnmarshalJSON 自定义JSON解码方法，Command实现了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {
fmt.Println("--------------使用自定义解码--------------")
// 检查JSON中是否有Args字段，并处理它
var m map[string]json.RawMessage
if err := json.Unmarshal(data, &m); err != nil {
// 如果这里出错，可能是因为JSON格式不正确，但我们可能仍然想要保留已经解析的字段
// 因此，我们可以只记录一个错误，但不返回它
log.Printf("Error parsing Args field: %v", err)
} else {
// 如果Args字段存在，将其赋值给c.Args
if rawArgs, ok := m["Args"]; ok {
c.Args = &rawArgs // 注意这里我们取了rawArgs的地址
var args []string
if err := json.Unmarshal(*c.Args, &args); err != nil {
log.Printf("Error parsing Args contents: %v", err)
} else {
fmt.Printf("Args: %v\n", args)
}
}
}
// 如果没有错误，返回nil
return 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 数据。具体步骤如下：
json.Unmarshal接收一个字节切片（包含 JSON 数据）和一个目标值的指针。- 它首先会检查目标值的类型是否实现了
json.Unmarshaler接口。 - 如果实现了
json.Unmarshaler接口，json.Unmarshal就会调用该类型的UnmarshalJSON方法，并将 JSON 数据的字节切片作为参数传递给它。 - 如果目标值没有实现
json.Unmarshaler接口，json.Unmarshal就会使用默认的解码逻辑来填充目标值的字段。
这种机制使得开发者能够灵活地控制 JSON 数据到 Go 结构体之间的转换过程。通过实现 json.Unmarshaler 接口，您可以：
- 处理 JSON 数据中不存在的字段。
- 自定义字段名称的映射规则。
- 处理 JSON 数据中的嵌套对象或数组。
- 执行额外的验证或数据处理逻辑。
以下是简单的示例，展示了如何为一个类型实现 json.Unmarshaler 接口
处理 JSON 数据中不存在的字段
假设我们有一个结构体，它能够处理JSON中可能缺失的字段，并且为这些字段提供默认值。
在这个例子中，Age 字段在JSON中不存在，因此它将被赋予其类型的零值（对于int类型是0）。
package main
import (
"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 的零值 0
jsonData := []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
}自定义字段名称的映射规则
使用结构体标签中的json键来指定JSON字段名。
在这个例子中，结构体的字段名和JSON字段名不匹配，我们通过在结构体标签中指定json来实现映射。
package main
import (
"encoding/json"
"fmt"
"log"
)
type User struct {
Username string `json:"user_name"`
Password string `json:"pass"`
}
func main() {
var user User
jsonData := []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 main
import (
"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 User
jsonData := []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 main
import (
"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 // 影子类型，避免递归调用 UnmarshalJSON
aux := &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 User
jsonData := []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{}。
到此这篇关于Go语言使用Json的方法实现的文章就介绍到这了,更多相关Go 使用Json内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！