作者：BGbiao
链接：https://www.jianshu.com/p/42c19f88df6c
來源：简书
反射reflection
- 可以大大提高程序的灵活性，使得interface{}有更大的发挥余地
- 反射可以使用TypeOf和ValueOf函数从接口中获取目标对象信息
- 反射会将匿名字段作为独立字段（匿名字段的本质）
- 想要利用反射修改对象状态，前提是interface.data是settable，即pointer-interface
- 通过反射可以“动态”调用方法
常用的类型、函数和方法
//返回动态类型i的类型，如果i是一个空结构体类型，TypeOf将返回nil
func TypeOf(i interface{}) Type //Type 接口类型
type Type interface {
Align() int
FieldAlign() int
//指定结构体中方法的下标，返回某个方法的对象，需要注意的是返回的Method是一个独立的结构体
Method(int) Method
/*
type Method struct {
Name string
PkgPath string
Type Type
Func Value
Index int
}
*/ MethodByName(string) (Method, bool) //返回该结构体类型的方法下标
NumMethod() int
//返回类型的名称，即动态类型i的名称
Name() string
PkgPath() string
Size() uintptr
String() string
Kind() Kind
Implements(u Type) bool
AssignableTo(u Type) bool
ConvertibleTo(u Type) bool
Comparable() bool
Bits() int
ChanDir() ChanDir
IsVariadic() bool
Elem() Type
//返回结构体类型第i个字段
Field(i int) StructField
//StructField结构体
//type StructField struct {
// Name string
// PkgPath string
// Type Type
// Tag StructTag
// Offset uintptr
// Index []int
// Anonymous bool //根据结构体字段索引获取嵌入字段的结构体信息
FieldByIndex(index []int) StructField FieldByName(name string) (StructField, bool)
FieldByNameFunc(match func(string) bool) (StructField, bool)
In(i int) Type
Key() Type
Len() int
//返回动态类型i(结构体字段)的字段总数
NumField() int
NumIn() int
NumOut() int
Out(i int) Type
} //返回接口i的一个初始化的新值.ValueOf(nil)返回一个零值
func ValueOf(i interface{}) Value // Value结构体
type Value struct { }
// Value结构体的一些方法
// 返回结构体v中的第i个字段。如果v的类型不是结构体或者i超出了结构体的范围，则会出现panic
func (v Value) Field(i int) Value //以接口类型返回v的当前值
func (v Value) Interface() (i interface{})
//等价于.
var i interface{} = (v's underlying value) //通过反射方式修改结构体对象的一些方法 //返回接口v包含或者指针v包含的值
func (v Value) Elem() Value
//判断该接口v是否可以被set修改
func (v Value) CanSet() bool //使用另外一个反射接口去修改反射值
func (v Value) Set(x Value)
//其他不同类型的Set
func (v Value) SetBool(x bool)
func (v Value) SetBytes(x []byte)
func (v Value) SetFloat(x float64)
func (v Value) SetInt(x int64)
//设置结构体对象v的长度为n
func (v Value) SetLen(n int)
func (v Value) SetString(x string) //一些辅助方法
//返回反射结构体的Value的类型.如果v为零值，IsValid将返回false
func (v Value) Kind() Kind
//判断value是否为有效值，通常用在判断某个字段是否在反射体的Value中
func (v Value) IsValid() bool //Kind常量
type Kind uint
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
)
反射的基本操作
通过反射来获取结构体字段的名称以及其他相关信息。
package main import (
"fmt"
"reflect"
) //定义结构体
type User struct {
Id int
Name string
Age int
} //定义结构体方法
func (u User) Hello() {
fmt.Println("Hello xuxuebiao")
} func main() {
u := User{, "bgops", }
Info(u)
u.Hello()
} //定义一个反射函数,参数为任意类型
func Info(o interface{}) {
//使用反射类型获取o的Type,一个包含多个方法的interface
t := reflect.TypeOf(o)
//打印类型o的名称
fmt.Println("type:", t.Name()) //使用反射类型获取o的Value,一个空的结构体
v := reflect.ValueOf(o)
fmt.Println("Fields:") //t.NumField()打印结构体o的字段个数(Id,Name,Age共三个)
for i := ; i < t.NumField(); i++ {
//根据结构体的下标i来获取结构体某个字段,并返回一个新的结构体
/**
type StructField struct {
Name string
PkgPath string
Type Type
Tag StructTag
Offset uintptr
Index []int
Anonymous bool
}
**/
f := t.Field(i) //使用结构体方法v.Field(i)根据下标i获取字段Value(Id,Name,Age)
//在根据Value的Interface()方法获取当前的value的值(interface类型)
val := v.Field(i).Interface()
fmt.Printf("%6s:%v = %v\n", f.Name, f.Type, val)
} //使用t.NumMethod()获取所有结构体类型的方法个数(只有Hello()一个方法)
//接口Type的方法NumMethod() int
for i := ; i < t.NumMethod(); i++ {
//使用t.Method(i)指定方法下标获取方法对象。返回一个Method结构体
//Method(int) Method
m := t.Method(i)
//打印Method结构体的相关属性
/*
type Method struct {
Name string
PkgPath string
Type Type
Func Value
Index int
}
*/
fmt.Printf("%6s:%v\n", m.Name, m.Type)
}
}
输出
type: User
Fields:
Id:int =
Name:string = bgops
Age:int =
Hello:func(main.User)
Hello xuxuebiao
注意：我们上面的示例是使用值类型进行进行反射构造的。如果是指针类型的话，我们需要使用reflect.Struct字段进行判断接口类型的Kind()方法
if k := t.Kind();k != reflect.Struct {
fmt.Println("非值类型的反射")
return
}匿名字段的反射以及嵌入字段
注意:反射会将匿名字段当做独立的字段去处理,需要通过类型索引方式使用FieldByIndex方法去逐个判断
//根据指定索引返回对应的嵌套字段
FieldByIndex(index []int) StructField type StructField struct {
Name string
PkgPath string
Type Type
Tag StructTag
Offset uintptr
Index []int
Anonymous bool //是否为匿名字段
}
package main import (
"fmt"
"reflect"
) type User struct {
Id int
Name string
Age int
} type Manager struct {
User
title string
} func main() {
//注意匿名字段的初始化操作
m := Manager{User: User{, "biaoge", }, title: "hello biao"}
t := reflect.TypeOf(m) fmt.Printf("%#v\n", t.FieldByIndex([]int{}))
fmt.Printf("%#v\n", t.FieldByIndex([]int{}))
fmt.Printf("%#v\n", t.FieldByIndex([]int{, }))
fmt.Printf("%#v\n", t.FieldByIndex([]int{, })) }
输出：
reflect.StructField{Name:"User", PkgPath:"", Type:(*reflect.rtype)(0x4ac660), Tag:"", Offset:0x0, Index:[]int{}, Anonymous:true}
reflect.StructField{Name:"title", PkgPath:"main", Type:(*reflect.rtype)(0x49d820), Tag:"", Offset:0x20, Index:[]int{}, Anonymous:false}
reflect.StructField{Name:"Id", PkgPath:"", Type:(*reflect.rtype)(0x49d1a0), Tag:"", Offset:0x0, Index:[]int{}, Anonymous:false}
reflect.StructField{Name:"Name", PkgPath:"", Type:(*reflect.rtype)(0x49d820), Tag:"", Offset:0x8, Index:[]int{}, Anonymous:false}通过反射修改目标对象
通过反射的方式去修改对象的某个值。需要注意的亮点是，首先，需要找到对象相关的名称，其次需要找到合适的方法去修改相应的值。
package main import (
"fmt"
"reflect"
) func main() {
x :=
v := reflect.ValueOf(&x)
v.Elem().SetInt()
fmt.Println(x)
}
输出：
修改I的时候需要找到对象字段的名称;并且判断类型，使用相对正确的类型修改值
v.FieldByName("Name");f.Kind() == reflect.String {
f.SetString("test string")
}判断是否找到正确的字段名称：
f := v.FieldByName("Name1")
//判断反射对象Value中是否找到Name1字段
if !f.IsValid() {
fmt.Println("bad field")
return
}package main import (
"fmt"
"reflect"
) type User struct {
Id int
Name string
Age int
} //使用反射方式对结构体对象的修改有两个条件
//1.通过指针
//2.必须是可set的方法
func main() {
num :=
numv := reflect.ValueOf(&num)
//通过Value的Elem()和SetX()方法可直接对相关的对象进行修改
numv.Elem().SetInt()
fmt.Println(num) u := User{, "biao", }
uu := reflect.ValueOf(&u)
//Set()后面的必须是值类型
//func (v Value) Set(x Value)
test := User{, "bgops", }
testv := reflect.ValueOf(test)
uu.Elem().Set(testv)
fmt.Println("Change the test to u with Set(x Value)", uu) //此时的U已经被上面那个uu通过指针的方式修改了
Set(&u)
fmt.Println(u)
} func Set(o interface{}) {
v := reflect.ValueOf(o)
//判断反射体值v是否是Ptr类型并且不能进行Set操作
if v.Kind() == reflect.Ptr && ! v.Elem().CanSet() {
fmt.Println("xxx")
return
//初始化对象修改后的返回值(可接受v或v的指针)
} else {
v = v.Elem()
}
//按照结构体对象的名称进行查找filed，并判断类型是否为string，然后进行Set
if f := v.FieldByName("Name"); f.Kind() == reflect.String {
f.SetString("BYBY")
}
}
输出：
Change the test to u with Set(x Value) &{ bgops }
{ BYBY }通过反射进行动态方法的调用
使用反射的相关知识进行方法的动态调用
package main import (
"fmt"
"reflect"
) type User struct {
Id int
Name string
Age int
} func (u User) Hello(name string, id int) {
fmt.Printf("Hello %s,my name is %s and my id is %d\n", name, u.Name, id)
} func main() {
u := User{, "biaoge", }
fmt.Println("方法调用:")
u.Hello("xuxuebiao", ) //获取结构体类型u的Value
v := reflect.ValueOf(u)
//根据方法名称获取Value中的方法对象
mv := v.MethodByName("Hello") //构造一个[]Value类型的变量，使用Value的Call(in []Value)方法进行动态调用method
//这里其实相当于有一个Value类型的Slice，仅一个字段
args := []reflect.Value{reflect.ValueOf("xuxuebiao"), reflect.ValueOf()}
fmt.Println("通过反射动态调用方法:")
//使用Value的Call(in []Value)方法进行方法的动态调用
//func (v Value) Call(in []Value) []Value
//需要注意的是当v的类型不是Func的化，将会panic;同时每个输入的参数args都必须对应到Hello()方法中的每一个形参上
mv.Call(args) }
方法调用:
Hello xuxuebiao,my name is biaoge and my id is
通过反射动态调用方法:
Hello xuxuebiao,my name is biaoge and my id is