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

🕗 发布于 2024-05-15 15:24 golang 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 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{}。

原文地址：https://blog.csdn.net/qq_39335595/article/details/138671341

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：golang配置使用代理拉取依赖库，Swagger 在线解析API文档，Go参数解析工具 pflag、cobra、viper 在项目中的高级用法
下一篇：SQL编程（变量的定义与使用）

字节青训-比赛配对问题、组成字符串ku的最大次数
支队伍开始，直到决出唯一获胜队伍为止，总共进行的配对次数。每次配对都会减少队伍的数量，直到只剩下一个队伍。小R想知道在比赛中进行的配对次数，直到决出唯一的获胜队伍为止。小R正在组织一个比赛，比赛中有。
阅读更多2024-11-09
Python 在PDF中绘制形状（线条、矩形、椭圆形等）
本文提供了几个示例来介绍如何使用Python 在PDF中绘制不同的图形，如实线、虚线、矩形、椭圆形等。
阅读更多2024-11-09
【深度学习】InstantIR：图片高清化修复
InstantIR（Instant Image Restoration）是一种创新的单张图像修复方法。它通过利用即时生成的参考信息，实现对受损图像的高质量修复。得益于先进的生成模型和视觉编码器，Ins
阅读更多2024-11-09
淘淘商城实战高并发分布式项目(有源码)
当商城业务量增长，比如促销活动期间订单量暴增时，只需对相应模块（如订单模块）的服务器进行扩容，而不会干扰到其他模块（如用户模块、商品模块）的正常运作。面对高并发挑战，项目采取了一系列精妙的应对策略。如
阅读更多2024-11-09
使用Ant Design的Layout布局不能撑满整个屏幕问题解决方法
修改最外框组件就可以使整个布局平铺页面。
阅读更多2024-11-09
Java 开发中的 9 个实用避坑技巧：实战案例解析
以上 9 个技巧涵盖了 Java 开发中常见的坑点，了解这些可以帮助你在日常开发中编写更健壮、可靠的代码。希望这篇实战避坑指南能够帮助你规避一些常见问题，提升开发效率和代码质量。
阅读更多2024-11-09
基于单片机的客车载客状况自动检测系统（论文+源码）
本课题为客车载客状况自动检测系统，在此以STM32单片机为核心控制器，结合压力传感器、红外传感器、蜂鸣器、语音提示模块、继电器、液晶等构成整个客车载客状况自动检测系统，整个系统架构如图2.1所示，在此
阅读更多2024-11-09
Java 开发中的 9 个异常处理的避坑技巧：实战案例解析
使用标准异常（如）有时无法准确表达业务问题。自定义异常可以帮助明确异常来源，便于调试和日志分析。案例throw new InsufficientFundsException("余额不足&qu
阅读更多2024-11-09
光耦合器在现代电子学中的关键应用
本文将介绍光耦合器的基本原理、工作方式以及其常见应用领域。
阅读更多2024-11-09
【回忆】JavaScript 中的 Map 有哪些方法
在 JavaScript 中，Map对象是一种键值对的集合，类似于对象，但“键”可以是任何数据类型（对象或原始值）。Map提供了多种方法来操作这些键值对。以下是Map。
阅读更多2024-11-09