GoLang学习笔记之进阶编程（三）：反射机制reflect

最新推荐文章于 2023-07-23 22:42:38 发布
最新推荐文章于 2023-07-23 22:42:38 发布
阅读量550 收藏
点赞数
分类专栏： GoLang进阶 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41736299/article/details/121914821
版权

目录

前言

一、什么是反射？

二、reflect包的使用

1.reflect.Type

1.1.获取类型名与底层类型

1.2.获取结构体的字段信息和标签

2.reflect.Value

2.1.获取值的类型与底层类型

2.2.获取结构体字段的值信息

2.3.获取并调用结构体的方法

2.4.修改结构体字段的值

三、练习：json格式数据的序列化与反序列化

3.1.标准库中json包的marshal与unmarshal

3.2.通过reflect包自定义marshal与unmarshal

总结

前言

        在前面介绍接口的时候有提过，接口是方法的抽象，接口只注重方法的实现，而不在乎是谁调用的，那么当一个函数传入一个接口时，除了使用类型断言，还有什么方法获取该接口的具体类型信息呢，标准库中的reflect包为我们提供了此功能。


一、什么是反射？

        《GO语言圣经》声明：“GO语言提供了一种机制在运行时更新变量和检查它们的值、调用他们的方法和它们支持的内在操作，但是在编译时并不知道这些变量的具体类型，这种机制称为反射。”反射常用于判断一个接口变量的类型信息。


二、reflect包的使用

        reflect包中有两个十分重要的结构体：reflect.Type与reflect.Value，其中Type保存了一个接口变量的所有类型信息，包括类型名，底层类型，类型的字段等信息，Value则包含了接口变量的值信息，包括值的类型，值的底层类型，值的方法等。下面分别介绍这两种结构体的基本使用，更多使用方法请参考Golang标准库中文文档。


1.reflect.Type

        reflect.Type包含了一个接口变量的各种类型信息，我们可以通过reflect.TypeOf()函数获得一个reflect.Type结构体。

type person struct {
	Name string `heihei:haha`
	age  int
	sex  string
}

func (p person) Info() {
	fmt.Printf("name:%s,age:%d,sex:%s\n", p.Name, p.age, p.sex)
}

func (p *person) SetAge(age int) {
	p.age = age
}

func (p person) GetAge() int {
	return p.age
}

func main(){
    var p = person{"lulu", 22, "male"}
    getType := reflect.TypeOf(p)
}

1.1.获取类型名与底层类型

/*-----------------reflect.Type--------------------------------*/
	/*方法
	1.Name(),获取该接口的类型名，可以是自定义的别名
	2.Kind(),获取该接口的底层类型，如struct,ptr等
    */
fmt.Printf("type:%v,kind:%v\n", getType.Name(), getType.Kind()) // 输出:type:person,kind:struct

1.2.获取结构体的字段信息和标签

// 获取结构体字段信息，注意，这里获取不到字段对应的值
	for i := 0; i < getType.NumField(); i++ {
		field := getType.Field(i) // 通过index获取字段
		fmt.Printf("fieldName:%v,fieldTag:%v\n", field.Name, field.Tag)
	}

/*输出
fieldName:Name,fieldTag:heihei:haha
fieldName:age,fieldTag:
fieldName:sex,fieldTag:
*/


2.reflect.Value

        reflect.Value包含了接口变量的各种值信息，可以通过reflect.ValueOf()获得reflect.Value对象。

2.1.获取值的类型与底层类型

/*------------------reflect.Value-----------------------------*/
	/*方法
	1.Type()获取值的类型，相当于%T
	2.Kind()获取值的底层类型
	*/
	getValue := reflect.ValueOf(p)
	fmt.Printf("type:%v,kind:%v\n", getValue.Type(), getValue.Kind()) //输出：type:main.person,kind:struct

2.2.获取结构体字段的值信息

// 获取结构体每个字段的值信息
	for i := 0; i < getValue.NumField(); i++ {
		value := getValue.Field(i)
		fmt.Printf("valueType:%v,valueValue:%v\n", value.Type(), value)
	}

/*输出
valueType:string,valueValue:lulu
valueType:int,valueValue:22
valueType:string,valueValue:male
*/

2.3.获取并调用结构体的方法

// 获取结构体的方法并调用,值接收者只能获得值接收者的方法，方法必须对外可见，否则找不到
	for i := 0; i < getValue.NumMethod(); i++ {
		method := getValue.Method(i)
		fmt.Printf("methodType:%v,mathodKind:%v\n", method.Type(), method.Kind())
		if method.Kind() == reflect.Func {
			method.Call(nil)
		}
	}

/*输出
    methodType:func() int,mathodKind:func
    methodType:func(),mathodKind:func
    name:lulu,age:22,sex:male
*/

	// 指针接收者方法的调用
	pointer := reflect.ValueOf(&p)
	method := pointer.MethodByName("SetAge")
	method.Call([]reflect.Value{reflect.ValueOf(18)})
	p.Info() //name:lulu,age:18,sex:male,成功修改

2.4.修改结构体字段的值

// 通过reflect修改值
	// 必须传入地址
	// 字段必须对外导出，否则会panic
	nameFiled := pointer.Elem().FieldByName("Name")
	//fmt.Println(nameFiled)
	nameFiled.SetString("Allen")
	p.Info() //name:Allen,age:18,sex:male

        通过reflect包修改接口变量的值时，要注意以下四点:

  1. 传入的接口变量必须是指针类型，否则会引发panic
  2. 修改的变量必须对外导出，否则会引发panic
  3. 对传入的指针接口变量，要通过Elem()方法获取其值后再进行相关操作
  4. 修改变量的值时，一定要知道该变量的底层类型。

三、练习：json格式数据的序列化与反序列化

3.1.标准库中json包的marshal与unmarshal

        在进行web开发时，前后端交互数据中有一种重要的数据格式，称为json格式。标准库中的json包为我们提供了marshal与unmarshal方法，marshal用于讲一个结构体对象序列化成一个json字符串，而unmarshal则用于将json字符串中各个key-value对赋值给对应的结构体对象。使用方法如下：

type person struct {
	Name      string `json:"name"`
	Age       int    `json:"age"`
	Sex       string `json:"sex"`
	IsStudent bool   `json:"isStudent"`
}

func main(){
    p := person{"LuLu", 18, "male", true}
	msg, err := json.Marshal(p)
	if err != nil {
		fmt.Printf("json marshal failed,err:%v\n", err)
		return
	}
	fmt.Println(string(msg)) // 输出:{"name":"LuLu","age":18,"sex":"male","isStudent":true}

	var p2 person
	err = json.Unmarshal(msg, &p2)
	if err != nil {
		fmt.Printf("json unmarshal failed,err:%v\n", err)
		return
	}
	fmt.Println(p2) // 输出:{LuLu 18 male true}
}

3.2.通过reflect包自定义marshal与unmarshal

        本次的练习就是用reflect包的相关操作实现上面的marshal方法与unmarshal方法，该练习假设输入全是正确格式的输入（即无需判断输入是否合法），同时，限定结构体字段类型只有string,int与bool类型三种，有需要可自行扩展。

type person struct {
	Name      string `json:"name"`
	Age       int    `json:"age"`
	Sex       string `json:"sex"`
	IsStudent bool   `json:"isStudent"`
}

// 定义一个结构体来保存需要序列化的和结构体字段信息
type fieldInfo struct {
	fieldName string       // 保存字段名
	fieldType reflect.Kind // 保存字段类型
	fieldTag  string       // 保存字段标签
	hasTag    bool         // 记录该字段是否有标签，有标签的话结果要根据标签来
}

// fieldInfo 工厂函数
func newFieldInfo(fieldName string, fieldType reflect.Kind, fieldTag string, hasTag bool) *fieldInfo {
	return &fieldInfo{
		fieldName: fieldName,
		fieldType: fieldType,
		fieldTag:  fieldTag,
		hasTag:    hasTag,
	}
}

// 序列化函数
func marShal(v interface{}) (string, error) {
	// 对于进来的接口类型，先判断是不是结构体，不是则返回错误
	vType := reflect.TypeOf(v) // 获取reflect.Type,其中包含了字段的相关信息
	if vType.Kind() != reflect.Struct {
		return "", errors.New("Please input a struct\n")
	}
	vValue := reflect.ValueOf(v) // 获取reflect.Value，其中包含了字段的各种值信息

	fields := make([]*fieldInfo, 0, 5)   // 定义一个切片来获取结构体的所有字段信息，默认只有五个字段，不够的话会通过append扩容
	result := make(map[string]string, 5) // 存放结果
	// 遍历获取所有字段
	for i := 0; i < vType.NumField(); i++ { // 遍历每一个字段
		field := vType.Field(i)      // 获取字段
		tag := field.Tag.Get("json") //获取标签
		if tag != "" {               // 如果有json标签，设置hasTag属性为true
			info := newFieldInfo(field.Name, field.Type.Kind(), tag, true)
			fields = append(fields, info) // 保存当前字段信息
		} else { // 如果没有json标签，设置hasTag属性为false
			info := newFieldInfo(field.Name, field.Type.Kind(), tag, false)
			fields = append(fields, info) //保存当前字段信息
		}
	}

	// 遍历获取字段的值
	for _, info := range fields {
		value := vValue.FieldByName(info.fieldName) // 通过字段名获取字段Value
		switch info.fieldType {                     // 判断当前字段的类型
		case reflect.String:
			if info.hasTag { // 如果有tag,在结果中使用tag取代name
				result[info.fieldTag] = value.String()
			} else { // 没有tag则直接使用字段名name
				result[info.fieldName] = value.String()
			}
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			if info.hasTag { // 如果有tag,在结果中使用tag取代name
				result[info.fieldTag] = strconv.Itoa(int(value.Int()))
			} else { // 没有tag则直接使用字段名name
				result[info.fieldName] = strconv.Itoa(int(value.Int()))
			}
		case reflect.Bool:
			if info.hasTag { // 如果有tag,在结果中使用tag取代name
				result[info.fieldTag] = strconv.FormatBool(value.Bool())
			} else { // 没有tag则直接使用字段名name
				result[info.fieldName] = strconv.FormatBool(value.Bool())
			}
		default: // 还可以添加许多类型判断，此处示例只添加三种
			return "", errors.New("Invalid type\n")
		}

	}

	resultSlice := make([]string, 0, 5)
	for key, value := range result {
		// 拼接成json格式字符串
		resultSlice = append(resultSlice, fmt.Sprintf("\"%s\":\"%s\"", key, value))
	}

	return "{" + strings.Join(resultSlice, ",") + "}", nil
}

// 假设输入的字符串是满足json格式的字符串
func dealJsonStr(s string) map[string]string {
	result := make(map[string]string)
	temp1 := s[1 : len(s)-1]           // 去掉json字符串前后"{"与"}"
	temp2 := strings.Split(temp1, ",") // 获取每个key-value对
	for _, v := range temp2 {
		temp := strings.Split(v, ":") // 分割key与value
		key := temp[0]
		value := temp[1]
		result[key[1:len(key)-1]] = value[1 : len(value)-1] // 去掉引号
	}

	return result
}

// 假设输入的字符串是满足json格式的字符串
func unMarshal(s string, v interface{}) error {

	vType := reflect.TypeOf(v)       // 获取reflect.Type,其中包含了字段的相关信息
	vValue := reflect.ValueOf(v)     // 获取reflect.Value，其中包含了字段的各种值信息
	if vType.Kind() != reflect.Ptr { // 需要修改结构体，因此必须是指针类型
		return errors.New("input must ptr\n")
	}

	jsonMap := dealJsonStr(s) // 解析json字符串，获取key-value对
	// 对每个字段信息开始遍历
	for i := 0; i < vType.Elem().NumField(); i++ {
		field := vType.Elem().Field(i) // 获取当前字段
		tag := field.Tag.Get("json")   // 获取当前字段tag
		fieldType := field.Type.Kind() // 获取当前字段类型
		if value, ok := jsonMap[field.Name]; ok {
			switch fieldType { // 根据类型设置字段的值
			case reflect.String:
				vValue.Elem().FieldByName(field.Name).SetString(value)
			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
				setValue, err := strconv.Atoi(value)
				if err != nil {
					return err
				}
				vValue.Elem().FieldByName(field.Name).SetInt(int64(setValue))
			case reflect.Bool:
				setValue, err := strconv.ParseBool(value)
				if err != nil {
					return err
				}
				vValue.Elem().FieldByName(field.Name).SetBool(setValue)
			default:
				return errors.New("unmarshal invalid type\n")
			}
		} else if value1, ok1 := jsonMap[tag]; ok1 {
			switch fieldType {
			case reflect.String:
				vValue.Elem().FieldByName(field.Name).SetString(value1)
			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
				setValue, err := strconv.Atoi(value1)
				if err != nil {
					return err
				}
				vValue.Elem().FieldByName(field.Name).SetInt(int64(setValue))
			case reflect.Bool:
				setValue, err := strconv.ParseBool(value1)
				if err != nil {
					return err
				}
				vValue.Elem().FieldByName(field.Name).SetBool(setValue)
			default:
				return errors.New("unmarshal invalid type\n")
			}
		} else {
			return errors.New("can not parse the struct\n")
		}
	}

	return nil

}

func main() {
	p := person{"LuLu", 18, "male", true}
	
	j, err := marShal(p)
	if err != nil {
		fmt.Printf("marshal failed,err:%v\n", err)
		return
	}
	fmt.Println(j) // 输出:{"name":"LuLu","age":"18","sex":"male","isStudent":"true"}

	var p2 person
	err = unMarshal(j, &p2)
	if err != nil {
		fmt.Printf("unmarshal failed,err:%v\n", err)
		return
	}
	fmt.Println(p2) // 输出:{LuLu 18 male true}

}


总结

        我们可以通过reflect包动态获取一个接口变量的类型信息与值信息，并调用相关的方法或修改值。但是要注意，reflect包十分复杂，且效率十分低下，比正常代码运行速度慢两个数量级，非必要情况谨慎使用reflect包！

Allen-LuLu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang学习笔记（三）：控制流
01-21
控制结构分为： 条件+选择+循环 IF 1.说明 代码如下: 条件表达式没有括号 支持一个初始化表达式（可以是多变量初始化语句） 初始化语句中定义的都是只能在block级别中使用的局部变量，不能在block之外使用 ...
Golang学习(三十三） 反射
默子昂
03-09 2346
一、基本介绍 1、反射可以在运行时动态获取变量的各种信息，比如变量的类型(type),类别(kind) 2、如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法) 3、通过反射，可以修改变量的值，可以调用关联的方法 1、重要的函数 func TypeOf(i interface{}) Type func ValueOf(i interface{}) Value 以上函数都是空接口类型，可以传入任意值，之后我们将得到一个type和Value类型变量 这里的ty...
go语言标准库之——反射reflect
General_zy的博客
04-04 1422
reflect包提供了reflect.TypeOf和reflect.ValueOf两个函数来获取任意对象的Value和Type。基于反射的代码是极其脆弱的，反射中的类型错误会在真正运行的时候才会引发panic，那很可能是在代码写完的很长时间之后。大量使用反射的代码通常难以理解。反射的性能低下，基于反射实现的代码通常比正常代码运行速度慢一到两个数量级。
golang中的reflect(反射)
_____________________________________simanstar____
01-26 4278
一、概述 在golang中，reflect是一个比较高级的话题，本文将尽可能简单而又清楚的介绍相关内容。 本文将从如下几个方面进行阐述： - 什么是reflection ？ - 如何检查一个变量var 并获得其真实类型 - golang中的reflect包 1.1 reflect.Type 和 reflect.Value 1.2 reflect.Kind 1.3 NumField() 和 Field() 1.4 Int() 和 String() - 完整实例 - 如何使用reflection 二、什么
Go语言之反射
weixin_34273046的博客
11-25 128
和Java语言一样，Go也实现运行时反射，这为我们提供一种可以在运行时操作任意类型对象的能力。比如我们可以查看一个接口变量的具体类型，看看一个结构体有多少字段，如何修改某个字段的值等。 TypeOf和ValueOf 在Go的反射定义中，任何接口都会由两部分组成的，一个是接口的具体类型，一个是具体类型对应的值。比如var i int = ...
golang reflect
weixin_33730836的博客
10-05 238
reflect包实现了运行时反射，允许程序操作任意类型的对象。典...
Golang学习笔记（一）：简介
01-21
并发编程 反射 语言交互性 高性能/高效开发 安装 安装说明 地址 http://golang.org/doc/install 包下载 地址 https://code.google.com/p/go/downloads/list 确认是否安装成功 代码如下: go version //查看版本 ...
Golang学习笔记（五）：函数
01-01
函数 Go语言里面的核心设计，通过关键字func来声明 代码如下: func funcName(input type1, input2 type2) (output1 type1, output2 type2) {  //logical code  return value1, value2 } 基本语法 ...
Go语言通过反射获取各种类型变量的值
最新发布
YIYIYI
07-23 1242
Go语言通过反射获取各种类型变量的值
GOLang reflect获取struct字段信息及reflect.Value转型
qq_35976548的博客
12-29 1063
GOLang reflect获取struct字段信息及reflect.Value转型 panic: reflect.Value.Interface: cannot return value obtained from unexported field or method [recovered] panic: reflect.Value.Interface: cannot return value obtained from unexported field or method
详解Golang中的反射及反射结构体
金戈鐡馬
04-21 1018
反射是在golang程序运行时检查变量所具有类型的一种机制。由于反射可以得出关于变量结构的数据（即“关于数据的数据”），所以这也被认为是golang元编程的基础。
深入浅出go反射
热门推荐
明望君的博客
02-26 1万+
写在前面 Go的反射机制带来很多动态特性，一定程度上弥补了Go缺少自定义范型而导致的不便利。 Go反射机制设计的目标之一是任何操作（非反射）都可以通过反射机制来完成。 变量是由两部分组成：变量的类型和变量的值。 类型和值 reflect.Type和reflect.Value是反射的两大基本要素，他们的关系如下： 任意类型都可以转换成Type和Value Value可以转换成Type Value可以转换成Interface Type 类型系统 Type描述的是变量的类型，关于类型请参考下面这个文章： G
Golang的反射reflect深入理解和示例
Aiky哇
03-16 446
Golang的反射reflect深入理解和示例 【记录于2018年2月】 编程语言中反射的概念 在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。 每种语言的反射模型都不同，并且有些语言根本不支持反射。Golang语言实现了反射，反射机制就是在运行时动态的调用对象的方法和属性，官方自带的
Golang 反射机制 reflect.TypeOf、 reflect.ValueOf、字符串处理
wgchen
02-25 1768
Golang 反射机制 reflect.TypeOf、 reflect.ValueOf、字符串处理
Go语言中的结构体类型
阿星的博客
03-20 1853
介绍Golang中结构体的定义、初始化、匿名字段、内嵌结构体以及方法的定义
golang 结构体和 json 相互转换时的 key 匹配问题
bdss58的专栏
12-20 1万+
使用json.Unmarshal时，结构体的每一项必须是导出项（import field)也是就说结构体的key的首字母必须大写。package mainimport "fmt" import "encoding/json"type Person struct { name string age int } func main() { jsonstr := `
Golang的Tag语法
嘿嘿
08-16 680
我们可以通过Tag来增强结构体的定义，Tag会带上一些meta信息，在本文中我们将通过几个例子来深入了解Tag的用法。 结构 Struct是由一组field组成，每个field包括了名字(可选)和字段类型 package main import "fmt" type T1 struct { f1 string } type T2 struct { T1 f2 int64 f3, f4 float64 } func main() { t := T2{T1
go那些事儿|go反射使用第一弹(TypeOf)
qq_41066066的博客
01-10 837
文章始发于公众号【迈莫coding】 地址：https://mp.weixin.qq.com/s/F8yZyqC5UwoewsX0THqy1w 即将用Go语言从零到一编写ORM框架，目前先把所用技术讲一遍，大家可以尽情期待，可以关注【迈莫coding】，了解最新状况。 目录 反射概念 reflect包 反射类型(Type)和种类(Kind) 反射类型(Type)使用 反射类型对象(TypeOf)使用 结构体对象 变量 常量 指针 反射获取结构体的成员类型 介绍structField结构 演.
Golang进阶指南：常见陷阱与高效编程模式
在Golang编程中，有许多常见的坑和独特的编程模式值得新手Gopher们了解和注意。Golang，因其并发支持、静态链接、简洁语法以及语言级别的并发特性而备受推崇，它的目标是提供静态语言的效率和动态语言的开发便利性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值