开发者

Go语言使用Json的方法实现

开发者 https://www.devze.com 2024-08-14 15:03 出处：网络 作者： 比猪聪明
目录 1、使用标准库中的encoding/json包 2、使用第三方包3、decode  4、注意5、更灵活地使用JSON使用json.RawMessage使用interface{}在Go语言中，处理JSON数据通常涉及编码（将Go结构体转换为JS
相关专题：Go 使用Json
目录
  •  1、使用标准库中的encoding/json包
  •  2、使用第三方包
  • 3、decode  
  • 4、注意
  • 5、更灵活地使用JSON
    • 使用json.RawMessage
    • 使用interface{}

在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 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(decodedGroupandroid.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"` // 嵌套对象
	javascriptActive   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, &ajavascriptmp;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"]; javascriptok {
			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 {
python		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内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！

0

上一篇:

:下一篇

更多 开发 相关资讯：

精彩评论

暂无评论...
登录 注册
Qedev.com
验证码 换一张
取 消

关注公众号

热门标签

图文推荐

SpringBoot整合Liquibase实现对数据库管理和迁移

SpringBoot整合Liquibase实现对数据库管理和迁移
javacv ffmpeg使用原生ffmpeg命令方式

javacv ffmpeg使用原生ffmpeg命令方式
Linux管道揭秘之匿名管道连接进程世界的方法

Linux管道揭秘之匿名管道连接进程世界的方法
SpringBoot配置文件启动加载顺序的方法步骤

SpringBoot配置文件启动加载顺序的方法步骤
SpringBoot前后端传输加密设计实现方案

SpringBoot前后端传输加密设计实现方案
SpringBoot参数校验的一些实战应用

SpringBoot参数校验的一些实战应用
Springboot3集成Knife4j的步骤以及使用(最完整版)

Springboot3集成Knife4j的步骤以及使用(最完整版)
SpringBoot中的@Configuration、@MapperScan注解

SpringBoot中的@Configuration、@MapperScan注解

开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9