golang通过反射手动实现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))
}

func test2(t *testing.t) {
	tjson1 := testjson{1, "jackson", 18}
	jsonstr1, _ := json.marshalindent(tjson1, "", "\t")
	fmt.println(string(jsonstr1))
}

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)
	}
}

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)
	}
}

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)
	}
}

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))
}

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)
}

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)
	}
}