19 go语言（golang） - 通过反射手动实现json序列化

最新推荐文章于 2025-01-05 21:24:29 发布
最新推荐文章于 2025-01-05 21:24:29 发布
阅读量1.3k 收藏 13
点赞数 30
分类专栏： golang 文章标签： golang json 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_39743356/article/details/144355025
版权

一、json

在 Go 语言中，JSON 序列化和反序列化通常通过标准库 encoding/json 来实现。这个包提供了简单易用的接口来将 Go 数据结构转换为 JSON 格式字符串（序列化），以及从 JSON 字符串解析出 Go 数据结构（反序列化）。

1.1 序列化（将 Go 对象转换为 JSON）

使用 json.Marshal() 函数可以将一个 Go 对象转换为 JSON 字符串。

import (
	"encoding/json"
	"fmt"
	"testing"
)

type TestJson struct {
	UserId       int    `json:"user_id"` // 使用结构体标签可以指定字段在 JSON 中的键名
	UserNickname string // 如果没有指定标签，则默认使用字段名。
	UserAge      int    `json:"age,omitempty"` // 使用omitempty可以在序列化时忽略空值
}

func Test1(t *testing.T) {
	tJson1 := TestJson{1, "Jackson", 18}
	tJson2 := new(TestJson)
	jsonStr1, _ := json.Marshal(tJson1)
	jsonStr2, _ := json.Marshal(tJson2)

	fmt.Println(string(jsonStr1))
	fmt.Println(string(jsonStr2))
}

输出

{"user_id":1,"UserNickname":"Jackson","age":18}
{"user_id":0,"UserNickname":""}

美观打印的序列化

如果需要生成格式良好的、可读性更高的输出，可以使用 json.MarshalIndent()

func Test2(t *testing.T) {
	tJson1 := TestJson{1, "Jackson", 18}
	jsonStr1, _ := json.MarshalIndent(tJson1, "", "\t")

	fmt.Println(string(jsonStr1))
}

输出

{
	"user_id": 1,
	"UserNickname": "Jackson",
	"age": 18
}

1.2 反序列化（将 JSON 转换为 Go 对象）

使用 json.Unmarshal() 函数可以将一个 JSON 字符串解析到相应的 Go 数据结构中。

func Test3(t *testing.T) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18
		}`
	var tJson TestJson

	// 将字符串转为字节数组，再传入解析后的对象指针
	// 第二个参数必须是指向目标数据类型变量的指针，以便函数能够修改该变量。
	err := json.Unmarshal([]byte(jsonStr), &tJson)

	if err != nil {
		fmt.Println("解析错误：", err)
	} else {
		fmt.Println(tJson)
	}
}

输出

{1 Jackson 18}

1.3 注意

  • 字段导出：只有导出的字段（即首字母大写）才能被编码/解码。

  • 错误处理：始终检查返回错误，以确保数据正确处理。

  • 多余的信息：解析的结构体之外的字段会被丢弃

    func Test5(t *testing.T) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18,
			"addr": ["地址1","地址2"],
			"info":{
				"id":"2",
				"name":"a"
			}
		}`
	var tJson TestJson

	err := json.Unmarshal([]byte(jsonStr), &tJson)

	if err != nil {
		fmt.Println("解析错误：", err)
	} else {
		fmt.Println(tJson)
	}
}

    输出

    {1 Jackson 18}

  • 灵活性：对于未知或动态数据，可以考虑使用 map 或 interface{} 来接收解码结果，但这会丧失一些类型安全特性。

    func Test4(t *testing.T) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18,
			"addr": ["地址1","地址2"],
			"info":{
				"id":"2",
				"name":"a"
			}
		}`
	var tJson map[string]any

	err := json.Unmarshal([]byte(jsonStr), &tJson)

	if err != nil {
		fmt.Println("解析错误：", err)
	} else {
		fmt.Println(tJson)
	}
}

    输出

    map[UserNickname:Jackson addr:[地址1 地址2] age:18 info:map[id:2 name:a] user_id:1]

二、反射手动实现

encoding/json 包在内部大量使用了反射来实现其功能。

JSON 序列化中的反射

  • 在调用 json.Marshal() 时，Go 使用反射来检查传入对象的类型。
  • 通过 reflect.TypeOf() 和 reflect.ValueOf() 获取类型信息和实际值。
  • 遍历结构体字段，读取标签（如 json:"name"），并根据字段类型生成相应的 JSON 字符串。

JSON 反序列化中的反射

  • 在调用 json.Unmarshal() 时，Go 使用目标变量指针，通过反射确定需要填充的数据结构。
  • 根据 JSON 数据中的键名，通过标签映射找到对应结构体字段，并设置其值。

2.1 json简单序列化

思路：模仿 encoding/json 库，读取结构体标签指定序列化的字段名

  1. 反射传入的结构体
  2. 获取字段
  3. 判断字段的标签
  4. 拼接字符串
func serializeSimple(data interface{}) string {
	var resultStr string = "{"

	//1、反射传入的结构体
	reflectDataValue := reflect.ValueOf(data)
	reflectDataType := reflectDataValue.Type()
	if reflectDataValue.Kind() == reflect.Ptr {
		reflectDataValue = reflectDataValue.Elem()
	}
	if reflectDataType.Kind() == reflect.Ptr {
		reflectDataType = reflectDataType.Elem()
	}

	//2、获取字段
	for i := 0; i < reflectDataType.NumField(); i++ {
		field := reflectDataType.Field(i)

		// 字段名
		var filedName = field.Name
		// 字段的值
		filedValue := reflectDataValue.Field(i).Interface()

		//3、判断字段的标签
		if value, ok := field.Tag.Lookup("json"); ok {
			// 如果有json标签，则使用其定义的命名
			filedName = strings.ReplaceAll(value, ",omitempty", "")

			// 是否忽略空值
			if strings.Contains(value, "omitempty") {
				if filedValue == "" || filedValue == 0 {
					continue
				}
			}
		}

		// 拼接json
		resultStr += fmt.Sprintf("\"%s\":\"%v\"", filedName, filedValue)
		resultStr += ","

	}

	//4、拼接字符串
	resultStr += "}"
	// 去掉结尾的,号
	return strings.ReplaceAll(resultStr, ",}", "}")
}

func Test6(t *testing.T) {
	tJson1 := TestJson{1, "Jackson", 18}
	tJson2 := new(TestJson)
	jsonStr1, _ := json.Marshal(tJson1)
	jsonStr2, _ := json.Marshal(tJson2)

	fmt.Println(string(jsonStr1))
	fmt.Println(string(jsonStr2))

	fmt.Println("=========自定义实现=========")

	fmt.Println(serializeSimple(tJson1))
	fmt.Println(serializeSimple(tJson2))

}

输出

{"user_id":1,"UserNickname":"Jackson","age":18}
{"user_id":0,"UserNickname":""}
=========自定义实现=========
{"user_id":"1","UserNickname":"Jackson","age":"18"}
{"user_id":"0","UserNickname":""}

2.2 json简单反序列化

思路

  1. 切割传入的字符串，拆分成key value的键值对
  2. 反射结构体，判断结构体标签后生成一个字段和值的map
  3. 判断字段类型，set进对应类型的值
func parseSimple(str string, dataTemp interface{}) {
	// 判断是否标准的json格式数据
	if str != "" && str[0] == '{' && str[len(str)-1] == '}' {

		// 替换掉前后的{}
		str = strings.ReplaceAll(strings.ReplaceAll(str, "{", ""), "}", "")

		// 将结构体的标签解析后，塞入map中备用 ：map [字段名] 字段地址
		structMap := map[string]reflect.Value{}
		// 通过反射获取字段名
		rValue := reflect.ValueOf(dataTemp)
		if rValue.Kind() == reflect.Ptr {
			rValue = rValue.Elem()
		}
		rType := rValue.Type()
		for i := 0; i < rType.NumField(); i++ {
			name := rType.Field(i).Name
			// 如果有定义标签，则使用标签的字段名
			if lookup, ok := rType.Field(i).Tag.Lookup("json"); ok {
				name = strings.ReplaceAll(lookup, ",omitempty", "")
			}
			// 将字段名和值映射起来
			structMap[name] = rValue.Field(i)
		}

		// 按照,切割每个键值对
		splitList := strings.Split(str, ",")
		for i := range splitList {
			s := splitList[i]

			// 按照:切割出key 和 value
			keyValue := strings.Split(s, ":")
			key := keyValue[0]
			key = strings.ReplaceAll(strings.TrimSpace(key), "\"", "") // 去除前后的空格
			value := keyValue[1]
			value = strings.ReplaceAll(strings.TrimSpace(value), "\"", "")

			// 按照key将value塞回结构体
			switch structMap[key].Type().Kind() {
			// 注意判断类型，目前只写int和string，其他的类似
			case reflect.Int:
				intValue, _ := strconv.Atoi(value)
				structMap[key].SetInt(int64(intValue))
			case reflect.String:
				structMap[key].SetString(value)
			default:
				panic("暂不支持的数据类型")
			}

		}
	}

}
func Test7(t *testing.T) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18
		}`
	var tJson1 TestJson
	var tJson2 TestJson

	err := json.Unmarshal([]byte(jsonStr), &tJson1)

	if err != nil {
		fmt.Println("解析错误：", err)
	} else {
		fmt.Println(tJson1)
	}

	fmt.Println("=========自定义实现=========")
	parseSimple(jsonStr, &tJson2)
	fmt.Println(tJson2)

}

2.3 问题

  1. 只能处理结构体类型的数据，不支持嵌套复杂数据结构（如切片或映射）
  2. 在序列化的实现中，整数或布尔值会被转换为带引号的字符串形式。
  3. 复杂的结构体不支持，可能会出问题

所以手动实现 JSON 序列化和反序列化只是帮助我们更好地理解数据格式与程序语言之间的映射关系，在实际开发中，使用标准库 encoding/json 是更高效且可靠的方法，因为它已经考虑了许多复杂情况，并进行了性能优化。

2.4 总结

2.4.1 单引号和双引号定义的字符串有什么区别

在 json简单反序列化的例子中，使用了单引号和双引号定义不同类型的字符数据。具体的区别是啥呢？

  1. 单引号 (')：

    • 单引号用于表示一个字符（rune）。在 Go 中，rune 是一个别名，代表 int32 类型，用于表示 Unicode 码点。
    • 一个用单引号括起来的字符常量只能包含一个字符。例如：'a', '中', '😊'。

  2. 双引号 (")：

    • 双引号用于定义字符串（string）。字符串是由一系列字节组成的数据类型，可以包含零个或多个字符。
    • 字符串可以包括转义序列，例如：\n, \t, \" 等。
    • 例如：“hello”, “世界”, “Go is fun\n”.

2.4.2 string如何转为int

在 json简单反序列化的例子中，使用了strconv.Atoi函数将字符串（string）转换为整数（int），除此之外还有strconv.ParseInt

  • strconv.Atoi 函数将字符串转换为int类型。如果转换成功，它返回转换后的整数和nil错误；如果失败，它返回0和错误。

  • strconv.ParseInt 函数将字符串转换为int64类型，并且允许你指定基数和位大小。如果你需要转换为int类型，你可能需要根据平台（32位或64位）来决定如何处理结果。

    func Test8(t *testing.T) {
	str := "123"
	// 第二个参数是基数，10表示十进制
	// 第三个参数是位大小，0表示int64，32表示int32，使用32或64取决于你的系统架构
	num, err := strconv.ParseInt(str, 10, 0)
	if err != nil {
		fmt.Println("转换错误:", err)
	} else {
		fmt.Println("转换结果:", num)
		// 如果你需要int32，可以这样转换
		num32 := int32(num)
		fmt.Println("转换为int32结果:", num32)
		// 如果你需要int，可以这样转换（注意：在32位系统上这将是int32，在64位系统上这将是int64）
		numInt := int(num)
		fmt.Println("转换为int结果:", numInt)
	}
}

    输出：

    转换结果: 123
转换为int32结果: 123
转换为int结果: 123
Golang切片与JSON转换：高效序列化与反序列化
Golang编程笔记的博客
04-20 921
在现代软件开发中，数据的传输和存储是至关重要的环节。JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，具有易读性和通用性，被广泛应用于各种系统之间的数据交互。而Golang作为一种高效、简洁的编程语言，在后端开发中占据着重要地位。Golang中的切片是一种动态数组，能够灵活地处理数据集合。本文章的目的就是详细介绍如何在Golang中实现切片与JSON之间的高效序列化与反序列化，涵盖了基本原理、具体实现步骤、实际应用场景等方面，旨在帮助开发者更好地掌握这一关键技术。
golang学习笔记（基础篇）
lcynone的博客
01-13 1006
Golang学习笔记_从零开始
使用Golang进行JSON序列化
代码教主
06-18 4015
总览 JSON是最流行的序列化格式之一。 它是人类可读的，相当简洁的，任何Web应用程序都可以使用JavaScript轻松地对其进行解析。 Go作为一种现代编程语言，在其标准库中对JSON序列化提供了一流的支持。 但是这里有些角落和缝隙。 在本教程中，您将学习如何有效地对JSON以及从JSON序列化和反序列化任意数据和结构化数据。 您还将学习如何处理高级场景，例如序列化枚举。 json包...
golang json 序列化、反序列化 字符串反序列化
牛肉胡辣汤
11-11 848
在使用Golang进行开发时，经常会遇到需要将一段JSON字符串进行序列化和反序列化的情况。我们可以使用JSON来保存用户的注册信息，并在需要时将其序列化和反序列化。需要注意的是，为了将JSON字符串正确解析为结构体，我们需要将JSON字符串转换为字节数组([]byte)，并将结构体变量的指针传给​。在结构体字段的标签中可以定义序列化和反序列化时的名称，以便更好地控制JSON的格式。以上就是对Golang中JSON序列化、反序列化以及字符串反序列化的详细介绍。​包来处理JSON的序列化和反序列化。
【Golang】在Go语言中进行序列化和反序列化JSON数据
tr6666的博客
05-21 684
在现代Web开发中，JSON已经成为了数据交换的主要格式。Go语言提供了强大的内置支持，可以很容易地对JSON进行序列化和反序列化。在这篇博客中，我们将讨论如何在Go中使用encoding/json包来处理JSON数据。通过这两个示例，我们可以看到Go语言处理JSON数据的强大和灵活。无论是序列化还是反序列化，Go都提供了简单易用的工具。希望这篇博客能帮助你理解如何在Go中处理JSON数据。如果你有任何问题或建议，欢迎在下方留言。
Go语言json序列化
weixin_46529397的博客
05-26 501
【代码】Go语言json序列化。
go实现Json序列化
Q_W_W_Q的博客
03-16 684
【代码】go实现Json序列化。
Golang笔记
怨行客
10-18 662
协程是用户态轻量级线程协程是线程调度的基本单位通常在函数前加上go关键字就能实现并发。一个Goroutine会以一个很小的栈启动2KB或4KB，当遇到栈空间不足时，栈会自动伸缩， 因此可以轻易实现成千上万个goroutine同时启动。
Go语言的基础知识
最新发布
weixin_52943021的博客
01-05 807
var 变量名 类型=表达式变量名 := 表达式a := 10b := 20c := 30fmt.Println("a=", a, ",b=", b, ",c=", c)//%d 打印变量a,b,c的值 a= 10 ,b= 20 ,c= 30​const(c,de,f。
【一月一本技术书】-【Go语言设计与实现】- 9月
「 虚幻私塾」
09-20 769
用树状的方式表示编程语言的语法结构。每一个节点表示源代码的一个元素。每一颗子树表示一个语法元素。2 * 3 + 7抽象语法树抹去了源代码中不重要的一些字符：空格、分号、括号等接口是计算机系统中多个组件共享的边界。不同的组件能够在边界上交换信息。接口的本质是引入一个新的中间层。调用方可以通过接口与具体的实现分离。解除上下游的耦合。上层的模块不需要依赖下层的具体模块。只需要依赖一个约定好的接口。面向接口的编程方式有着非常强大的生命力。Go语言中的接口是一种内置的类型。定义了一组方法的签名。
[go]深入学习Go总结
CRAJA的blog
01-14 1257
一种用来表示编译语言的语法结构的树形结构，用于辅助编译器进行语法分析。是一种中间代码的特性，即每个变量只赋值一次。分为复杂指令集体系（CISC）和精简指令集体系（RISC）通过 扫描数据源文件来匹配对应的字符，跳过空格和换行等空白字符。使用 文法解析 Token，按顺序检查语法树中定义和使用的类型，确保不存在类型匹配问题。（包括结构体对接口的实现等），同时也会展开和改写一些内置函数如 改写为 ,, 等。拓展：先对元素类型进行检查，再根据操作类型()的不同更新节点类型。创建 结构，存储哈希表的键值类型
golang JSON序列化
m0_70982551的博客
07-30 1017
(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于, Standard ECMA-262 3rd Edition - December 1999的一个子集。
golang json序列化与反序列化
青梅煮酒
05-19 2273
1、json的序列化 ➢介绍.   json序列化是指，将有key-value结构的数据类型(比如结构体、map、 切片)序列化成json字符串的操作。 ➢应用案例   这里我们介绍一下结构体、map和切片的序列化，其它数据类型的序列化类似。 package main import ( "encoding/json" "fmt" ) //定义一个结构体 type Monster struc...
go语言json序列化
weixin_49744225的博客
04-09 1398
go语言json序列化 key-value (结构体，map，切片)序列化为json字符串操作 package main import ( "encoding/json" "fmt" ) type Monster struct { Name string Age int Birthday string Sal float64 Skill string } func testStruct() { monster:= Monster{ Name: "jack", Age:
go 中 json 的序列化
实践求真知
05-02 1134
一 介绍 json 序列化是指，将有 key-value 结构的数据类型（结构体、map 、切片)序列化成 json 字符串的操作。 二实战 1需求 完成结构体、map和切片的序列化。 2说明 其它数据类型的序列化类似。 3代码 package main import ( "encoding/json" "fmt" ) // 定义一个结构体 type Monster struct { Name string `json:"monster_name"...
Golang中的JSON序列化和反序列化
qq_53267860的博客
02-06 1191
Golang对数据的序列化和反序列化
Go：json（序列化、反序列化）
weixin_33943347的博客
05-31 571
一、示例 package main import ( "encoding/json" "fmt" ) type Person struct { Name string `json:"name"` Age int `json:"age"` Salary float64 `json:"salary"` ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿-瑞瑞

打赏不准超过你的一半工资哦~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值