go 反射

最新推荐文章于 2023-12-12 22:16:11 发布

wuxingge

最新推荐文章于 2023-12-12 22:16:11 发布

阅读量348

点赞数

分类专栏： go

本文链接：https://blog.csdn.net/wuxingge/article/details/104519251

版权

go 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

反射基本介绍

反射可以在运行时动态获取变量的各种信息，比如变量的类型(type), 类型(kind)
如果是结构体变量，还可以获取到结构体本身的信息（包括结构体的字段，方法）
通过反射，可以修改变量的值，可以调用关联的方法
使用反射，需要 import( “reflect” )

reflect包实现了运行时反射

在这里插入图片描述

type Type

type Type interface {
    // Kind返回该接口的具体分类
    Kind() Kind
    // Name返回该类型在自身包内的类型名，如果是未命名类型会返回""
    Name() string
    // PkgPath返回类型的包路径，即明确指定包的import路径，如"encoding/base64"
    // 如果类型为内建类型(string, error)或未命名类型(*T, struct{}, []int)，会返回""
    PkgPath() string
    // 返回类型的字符串表示。该字符串可能会使用短包名（如用base64代替"encoding/base64"）
    // 也不保证每个类型的字符串表示不同。如果要比较两个类型是否相等，请直接用Type类型比较。
    String() string
    // 返回要保存一个该类型的值需要多少字节；类似unsafe.Sizeof
    Size() uintptr
    // 返回当从内存中申请一个该类型值时，会对齐的字节数
    Align() int
    // 返回当该类型作为结构体的字段时，会对齐的字节数
    FieldAlign() int
    // 如果该类型实现了u代表的接口，会返回真
    Implements(u Type) bool
    // 如果该类型的值可以直接赋值给u代表的类型，返回真
    AssignableTo(u Type) bool
    // 如该类型的值可以转换为u代表的类型，返回真
    ConvertibleTo(u Type) bool
    // 返回该类型的字位数。如果该类型的Kind不是Int、Uint、Float或Complex，会panic
    Bits() int
    // 返回array类型的长度，如非数组类型将panic
    Len() int
    // 返回该类型的元素类型，如果该类型的Kind不是Array、Chan、Map、Ptr或Slice，会panic
    Elem() Type
    // 返回map类型的键的类型。如非映射类型将panic
    Key() Type
    // 返回一个channel类型的方向，如非通道类型将会panic
    ChanDir() ChanDir
    // 返回struct类型的字段数（匿名字段算作一个字段），如非结构体类型将panic
    NumField() int
    // 返回struct类型的第i个字段的类型，如非结构体或者i不在[0, NumField())内将会panic
    Field(i int) StructField
    // 返回索引序列指定的嵌套字段的类型，
    // 等价于用索引中每个值链式调用本方法，如非结构体将会panic
    FieldByIndex(index []int) StructField
    // 返回该类型名为name的字段（会查找匿名字段及其子字段），
    // 布尔值说明是否找到，如非结构体将panic
    FieldByName(name string) (StructField, bool)
    // 返回该类型第一个字段名满足函数match的字段，布尔值说明是否找到，如非结构体将会panic
    FieldByNameFunc(match func(string) bool) (StructField, bool)
    // 如果函数类型的最后一个输入参数是"..."形式的参数，IsVariadic返回真
    // 如果这样，t.In(t.NumIn() - 1)返回参数的隐式的实际类型（声明类型的切片）
    // 如非函数类型将panic
    IsVariadic() bool
    // 返回func类型的参数个数，如果不是函数，将会panic
    NumIn() int
    // 返回func类型的第i个参数的类型，如非函数或者i不在[0, NumIn())内将会panic
    In(i int) Type
    // 返回func类型的返回值个数，如果不是函数，将会panic
    NumOut() int
    // 返回func类型的第i个返回值的类型，如非函数或者i不在[0, NumOut())内将会panic
    Out(i int) Type
    // 返回该类型的方法集中方法的数目
    // 匿名字段的方法会被计算；主体类型的方法会屏蔽匿名字段的同名方法；
    // 匿名字段导致的歧义方法会滤除
    NumMethod() int
    // 返回该类型方法集中的第i个方法，i不在[0, NumMethod())范围内时，将导致panic
    // 对非接口类型T或*T，返回值的Type字段和Func字段描述方法的未绑定函数状态
    // 对接口类型，返回值的Type字段描述方法的签名，Func字段为nil
    Method(int) Method
    // 根据方法名返回该类型方法集中的方法，使用一个布尔值说明是否发现该方法
    // 对非接口类型T或*T，返回值的Type字段和Func字段描述方法的未绑定函数状态
    // 对接口类型，返回值的Type字段描述方法的签名，Func字段为nil
    MethodByName(string) (Method, bool)
    // 内含隐藏或非导出方法
}

Type类型用来表示一个go类型

不是所有go类型的Type值都能使用所有方法。请参见每个方法的文档获取使用限制。在调用有分类限定的方法时，应先使用Kind方法获知类型的分类。调用该分类不支持的方法会导致运行时的panic

反射的应用场景

不知道接口调用哪个函数，根据传入参数在运行时确定调用的具体接口，这种需要对函数或方法反射。例如以下这种桥接模式

func bridge(funcPtr interface{}, args ...interface{})

第一个参数funcPtr以接口的形式传入函数指针，函数参数args以可变参数的形式传入，bridge函数中可以用反射来动态执行funcPtr函数

对结构体序列化时，如果结构体有指定Tag，也会使用到反射生成对应的字符串

package main

import (
	"encoding/json"
	"fmt"
)

type Monster struct {
	Name string `json:"monsterName"`
	Age int `json:"monsterAge"`
	Sal float64 `json:"monsterSal"`
	Sex string `json:"monsterSex"`
}
func main()  {
	m := Monster{
		Name: "猴子",
		Age:  500,
		Sal:  1000.99,
		Sex:  "male",
	}
	data, _ := json.Marshal(m)
	fmt.Println("json result:", string(data))
}

反射的函数和概念

reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型
reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型reflect.Value 是一个结构体类型。通过reflect.Value , 可以获取到关于该变量的很多信息

type Value

type Value struct {
    // 内含隐藏或非导出字段
}

Value为go值提供了反射接口

变量、interface{} 和 reflect.Value是可以相互转换的

变量、interface{} 和 reflect.Value是可以相互转换的
, 在使用反射的过程中，通常的方式是

在这里插入图片描述

反射说明

package main

import (
	"fmt"
	"reflect"
)

func reflectTest01(b interface{})  {
	//通过反射获取的传入的变量的 type, kind, 值
	//1.先获取到reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType=", rTyp)
	//2.获取到 reflect.Value
	rVal := reflect.ValueOf(b)
	n2 := 2 + rVal.Int()
	fmt.Println("n2=", n2)
	fmt.Printf("rVal=%v  rVal type=%T\n", rVal, rVal)
	//rVal 转成 interface{}
	iV := rVal.Interface()
	// interface{} 通过断言转成需要的类型
	num2 := iV.(int)
	fmt.Println("num2=", num2)
}
//对结构体的反射
func reflectTest02(b interface{})  {
	//通过反射获取的传入的变量的 type, kind, 值
	//1. 先获取到reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType=", rTyp)
	//2. 获取到reflect.Value
	rVal := reflect.ValueOf(b)

	//获取变量对应的Kind
	kind1 := rVal.Kind()
	kind2 := rTyp.Kind()
	fmt.Printf("kind =%v kind=%v\n", kind1, kind2)

	//将rVal 转成 interface{}
	iV := rVal.Interface()
	fmt.Printf("iv=%v  iv type=%T\n", iV, iV)
	//将interface{}通过断言转成需要的类型
	stu, ok := iV.(Student)
	if ok {
		fmt.Printf("stu.Name=%v\n", stu.Name)
	}
}

type Student struct {
	Name string
	Age int
}
type Monster struct {
	Name string
	Age int
}

func main()  {
	//(基本数据类型，interface{}，reflect.Value)进行反射基本操作
	var num int = 100
	reflectTest01(num)

	stu := Student{
		Name: "tom",
		Age:  20,
	}
	reflectTest02(stu)
}

反射的注意事项

reflect.Value.Kind 获取变量的类型，返回的是一个常量

type Kind

type Kind uint

Kind代表Type类型值表示的具体分类。零值表示非法分类。

const (
    Invalid Kind = iota
    Bool
    Int
    Int8
    Int16
    Int32
    Int64
    Uint
    Uint8
    Uint16
    Uint32
    Uint64
    Uintptr
    Float32
    Float64
    Complex64
    Complex128
    Array
    Chan
    Func
    Interface
    Map
    Ptr
    Slice
    String
    Struct
    UnsafePointer
)

Type 和 Kind 区别
Type是类型， Kind是类别， Type 和 Kind 可能是相同的，也可能是不同的
比如： var num int = 10 num的Type是int， Kind也是int
比如： var stu Student stu的Type是 pkg1.Student, Kind是 struct
通过反射可以在让变量在interface{} 和 reflect.Value之间相互转换

变量 <--------> interface{} <-------------> reflect.Value

使用反射的方式来获取变量的值（并返回对应的类型），要求数据类型匹配，比如 x是int，那么就使用 reflect.ValueOf(x).Int(), 否则报panic

func (Value) Int

func (v Value) Int() int64

返回v持有的有符号整数（表示为int64），如果v的Kind不是Int、Int8、Int16、Int32、Int64会panic

通过反射的来修改变量，注意当使用SetXxx方法来设置需要通过对应的指针类型来完成，这样才能改变传入的变量的值，同时需要使用到 reflect.Value.Elem()方法

func (Value) Elem

func (v Value) Elem() Value

Elem返回v持有的接口保管的值的Value封装，或者v持有的指针指向的值的Value封装。如果v的Kind不是Interface或Ptr会panic；如果v持有的值为nil，会返回Value零值

package main

import (
	"fmt"
	"reflect"
)

func testInt(b interface{})  {
	val := reflect.ValueOf(b)
	fmt.Printf("val type=%T\n", val)
	val.Elem().SetInt(110)
	fmt.Printf("val=%v\n", val)
}
func main()  {
	var num int = 20
	testInt(&num)
	fmt.Println("num=", num)
}

reflect.Value.Elem()如何理解

package main

import (
	"fmt"
	"reflect"
)

func main()  {
	var num int = 100
	fn := reflect.ValueOf(&num)
	fn.Elem().SetInt(200)
	fmt.Printf("%v\n", num)
}

理解为：

package main

import "fmt"

func main()  {
	//fn.Elem()用于获取指针指向变量，类似
	var num = 10
	var b *int = &num
	*b = 3
	fmt.Printf("num=%v\n", num)
}

反射练习

给变量 var v float64 = 1.2 , 使用反射来得到它的reflect.Value, 然后获取对应的Type, Kind 和值，并将reflect.Value转换成interface{}, 再将interface{} 转换成float64

package main

import (
	"fmt"
	"reflect"
)

func reflectTest(b interface{})  {
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType=", rTyp)
	rVal := reflect.ValueOf(b)
	n := rVal.Float()
	fmt.Printf("rVal=%v  rVal type=%T\n", rVal, rVal)
	fmt.Println("n=", n)
	// reflect.Value转换成interface{}
	iV := rVal.Interface()
	// interface{} 转换成float64
	n2 := iV.(float64)
	fmt.Println("n2=", n2)
}
func main()  {
	var v float64 = 1.2
	reflectTest(v)
}

package main

import (
	"fmt"
	"reflect"
)

func main()  {
	var str string = "tom"
	fs := reflect.ValueOf(&str)
	fs.Elem().SetString("jack")
	fmt.Printf("str=%v\n", str)
}

反射实战

func (Value) Method

func (v Value) Method(i int) Value

返回v持有值类型的第i个方法的已绑定（到v的持有值的）状态的函数形式的Value封装。返回值调用Call方法时不应包含接收者；返回值持有的函数总是使用v的持有者作为接收者（即第一个参数）。如果i出界，或者v的持有值是接口类型的零值（nil），会panic

func (Value) Call

func (v Value) Call(in []Value) []Value

Call方法使用输入的参数in调用v持有的函数。例如，如果len(in) == 3，v.Call(in)代表调用v(in[0], in[1], in[2])（其中Value值表示其持有值）。如果v的Kind不是Func会panic。它返回函数所有输出结果的Value封装的切片。和go代码一样，每一个输入实参的持有值都必须可以直接赋值给函数对应输入参数的类型。如果v持有值是可变参数函数，Call方法会自行创建一个代表可变参数的切片，将对应可变参数的值都拷贝到里面

使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值

package main

import (
	"fmt"
	"reflect"
)
//定义了一个Monster结构体
type Monster struct {
	Name string `json:"name"`
	Age int `json:monster_age`
	Score float32 `json:"成绩"`
	Sex string
}

func (s Monster) GetSum(n1, n2 int) int {
	return n1 + n2
}

func (s Monster) Set(name string, age int, score float32, sex string) {
	s.Name = name
	s.Age = age
	s.Score = score
	s.Sex = sex
}

func (s Monster) Print() {
	fmt.Println("---start---")
	fmt.Println(s)
	fmt.Println("---end---")
}
func TestStruct(a interface{})  {
	//获取reflect.Type类型
	typ := reflect.TypeOf(a)
	//获取reflect.Value类型
	val := reflect.ValueOf(a)
	//获取 a 对应的类别
	kd := val.Kind()
	if kd != reflect.Struct {
		fmt.Println("expect struct")
		return
	}
	//获取到结构体有几个字段
	num := val.NumField()
	fmt.Printf("struct has %d fields\n", num)


	//遍历结构体的所有字段
	for i := 0; i < num; i++ {
		fmt.Printf("Field %d: 值为%v\n", i, val.Field(i))
		//获取到struct标签，需要通过reflect.Type来获取tag标签的值
		tagVal := typ.Field(i).Tag.Get("json")
		if tagVal != "" {
			fmt.Printf("Field %d: tag 为=%v\n", i, tagVal)
		}
	}


	//获取到结构体有多少个方法
	numOfMethod := val.NumMethod()
	fmt.Printf("struct has %d methods\n", numOfMethod)

	//方法的排序默认是按照函数名排序（ASCII码）
	val.Method(1).Call(nil) //获取到第二个方法，调用它

	//调用结构体的第1个方法Method(0)
	var params []reflect.Value //声明了 []reflect.Value
	params = append(params, reflect.ValueOf(10))
	params = append(params, reflect.ValueOf(40))
	res := val.Method(0).Call(params) //传入的参数是 []reflect.Value, 返回[]reflect.Value
	fmt.Println("res=", res[0].Int()) //返回结果，返回的结果是 []reflect.Value

}
func main()  {
	var a Monster = Monster{
		Name:  "黄鼠狼",
		Age:   400,
		Score: 30.3,
		Sex:   "m",
	}
	TestStruct(a)
}

wuxingge

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
go 反射

反射基本介绍反射可以在运行时动态获取变量的各种信息，比如变量的类型(type), 类型(kind)如果是结构体变量，还可以获取到结构体本身的信息（包括结构体的字段，方法）通过反射，可以修改变量的值，可以调用关联的方法使用反射，需要 import( “reflect” )...
复制链接

扫一扫