反射
反射的应用场景举例
- 对结构体序列化时,若结构体有指定Tag,也会使用到反射生成对应的字符串。
- 不知道接口调用哪个函数,根据传入参数在运行时确定调用的具体接口,这种需要对函数或方法反射。
- 使用反射机制,编写函数的适配器,桥连接
反射的基本介绍
- 反射可以在运行时动态获取变量的各种信息,比如变量的类型(type),类别(kind)
- 如果是结构体变量,还可以获取到结构体本身的信息(包括结构体的字段、方法)
- 通过反射,可以修改变量的值,可以调用关联的方法
- 使用反射,需要 import (“reflect”)
- 反射的原理图
- reflect.TypeOf(变量名),获取变量的类型,返回reflect.Type类型
- reflect.ValueOf(变量名),获取变量的值,返回reflect.Value类型。如果reflect.Value是一个结构体类型,通过reflect.Value,可以获取到关于该变量的很多信息
- 变量、interface{}、和reflect.Value是可以相互转换的。这在实际开发中,经常用到
反射快速入门
案例:
- 编写一个程序,演示对基本数据类型、interface{}、reflect.Value()进行反射的基本操作
package main
import (
"fmt"
"reflect"
)
//专门演示反射
func reflectTest01(b interface{}){
//通过反射获取传入变量的 type, kind, 值
//先获取到 reflect.Type
rTyp := reflect.TypeOf(b)
fmt.Println("rType=", rTyp)
//获取到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 main(){
//先定义一个int
var num int = 100
reflectTest01(num)
}
- 编写一个程序,演示对结构体类型、interface{}、reflect.Value进行反射的基本操作
package main
import (
"fmt"
"reflect"
)
type Student struct{
Name string
Age int
}
func reflectTest02(b interface{}){
rTyp:=reflect.TypeOf(b)
fmt.Println("rType=", rTyp)
rVal:=reflect.ValueOf(b)
iv := rVal.Interface()
//可以使用switch语句来完善断言,使其更加灵活
stu, ok := iv.(Student)
if ok{
fmt.Printf("stu.Name=%v\n", stu.Name)
}
}
func main(){
stu := Student{
Name: "tom",
Age : 18,
}
reflectTest02(stu)
}
反射使用注意事项
- reflect.Value.Kind:获取变量的类别,返回的是一个常量
- Type是类型,Kind是类别,Type和Kind可能是相同的,也可能是不同的
- 使用反射的方式来获取变量的值(并返回对应的类型),要求数据类型匹配,比如 x 是 int,那么就应该使用 reflect.Value(x).Int(),而不能使用其他的,否则报panic
- 通过反射来修改变量
反射最佳实践
- 使用反射遍历结构体的字段,调用结构体的方法,并获取结构体标签的值
package main
import (
"fmt"
"reflect"
)
//声明一个结构体
type Monster struct{
Name string `json:"name"`
Age int `json:"age"`
Score float32
Sex string
}
//方法,显示s的值
func (s Monster)Print(){
fmt.Println("--------start--------")
fmt.Println(s)
fmt.Println("---------end---------")
}
//方法,返回两个数的和
func (s Monster)GetSum(n1, n2 int)int{
return n1 + n2
}
//方法 接收四个值给monster赋值
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 TestStruct(a interface{}){
typ := reflect.TypeOf(a)
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")
//如果字段有tag标签,就显示;否则就不显示
if tagVal != ""{
fmt.Printf("Field %d:tag为=%v\n", i, tagVal)
}
}
//获取到该结构体有多少个方法
numOfMethod := val.NumMethod()
fmt.Println("struct 有", numOfMethod,"个方法")
//方法的排序:默认按照函数名的排序,按ASCII码
val.Method(1).Call(nil)//val.Method(1):获取结构体第二个方法
//调用结构体第一个方法
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,返回的结果也是
fmt.Println("res=", res[0].Int()) //
}
func main(){
var a Monster = Monster{
Name: "黄鼠狼精",
Age: 400,
Score:54.6,
}
//将monster实例传给TestStruct()
TestStruct(a)
}
- 修改结构体字段值(需要传地址)
关键函数:
- func (v Value) NumField() int(返回v持有的结构体类型值的字段数,如果v的Kind不是Struct会panic)
- func (v Value) Elem() Value
- val.Elem().Field(0).SetString(“孙悟空”)
package main
import (
"fmt"
"reflect"
)
type Monster struct{
Name string
Age int
Score float64
}
func TestStruct(a interface{}){
//typ := reflect.TypeOf(a)
val := reflect.ValueOf(a)
kd := val.Kind()
if kd != reflect.Ptr && val.Elem().Kind() == reflect.Struct{
fmt.Println("expect struct")
return
}
num := val.Elem().NumField()
val.Elem().Field(0).SetString("孙悟空")
for i := 0; i < num; i++{
fmt.Printf("%d%v\n", i, val.Elem().Field(i).Kind())
}
fmt.Printf("struct has %d fields\n", num)
}
func main(){
var a Monster = Monster{
Name : "黄鼠狼精",
Age : 400,
Score : 65.9,
}
TestStruct(&a)
fmt.Println(a)
}
- 定义了两个函数test1和test2,定义一个适配器函数用作同一处理接口
package test
import (
"testing"
"reflect"
)
func TestReflectFunc(t *testing.T){
call1 := func(v1 int, v2 int){
t.Log(v1, v2)
}
call2 := func(v1 int, v2 int, s string){
t.Log(v1, v2, s)
}
var (
function reflect.Value
inValue []reflect.Value
n int
)
bridge := func(call interface{}, args ...interface{}){
n = len(args)
inValue = make([]reflect.Value, n)
for i := 0; i < n; i++{
inValue[i] = reflect.ValueOf(args[i])
}
function = reflect.ValueOf(call)
function.Call(inValue)
}
bridge(call1, 1, 2)
bridge(call2, 1, 2, "test2")
}
-
使用反射操作任意结构体类型
-
使用反射创建并操作结构体
package test
import (
"reflect"
"testing"
)
type user struct{
UserId string
Name string
}
func TestReflectStruct(t *testing.T){
var (
model *user
st reflect.Type
elem reflect.Value
)
st = reflect.TypeOf(model)//获取类型 *user
t.Log("reflect.TypeOf", st.Kind().String()) //ptr
st = st.Elem() //st指向的类型
t.Log("reflect.TypeOf.Elem", st.Kind().String()) //struct
elem = reflect.New(st) //New返回一个Value值,该值持有一个指向类型为typ的新申请的零值的指针
t.Log("reflect.New", elem.Kind().String()) //ptr
t.Log("reflect.New.Elem", elem.Elem().Kind().String()) //struct
//model就是创建的user结构体变量(实例)
model = elem.Interface().(*user) //model是 *user
elem = elem.Elem() //取得elem指向的值
elem.FieldByName("UserId").SetString("12345678")
elem.FieldByName("Name").SetString("nickname")
t.Log("model model.Name", model, model.Name)
}