reflect反射,可以通过reflect反射结构体所包含的属性和方法，然后进行一些赋值和方法的调用,灵活度比较高
下面定律引用别人的博客:http://blog.csdn.net/wo198711203217/article/details/70213812感觉写的还透彻
- 反射定律一：反射可以将“接口类型变量”转换为“反射类型对象”
这里的反射类型指的是reflect.Type和reflect.Value
将接口类型变量转换为反射类型变量，是通过reflect包的TypeOf和ValueOf实现的。 - 反射定律二： 反射可以将“反射类型对象”转换为“接口类型变量
根据一个 reflect.Value 类型的变量，我们可以使用 Interface 方法恢复其接口类型的值。事实上，这个方法会把 type 和 value 信息打包并填充到一个接口变量中，然后返回。 - 反射定律三：如果要修改反射类型对象，其值必须是“addressable”
通过反射定义一可以知道，反射对象包含了接口变量中存储的值以及类型。
如果反射对象中包含的值是原始值，那么可以通过反射对象修改原始值；
如果反射对象中包含的值不是原始值（反射对象包含的是副本值或指向原始值的地址），那么该反射对象是不可以修改的。
通过CanSet函数可以判定反射对象是否可以修改
package my
import (
ft "fmt"
"reflect"
)
type User struct {
Id int
Name string
}
func (user User) Print() {
ft.Println("reflect Print()")
}
func Reflect(inter interface{}) {
t := reflect.TypeOf(inter) //从接口中获取结构的对象
if k:=t.Kind();k!=reflect.Struct{//判断传入的是否是struce类型,而不是指针类型*User,指针类型报错
ft.Println("type is not true")
return
}
ft.Println("类型名称:", t.Name())
v := reflect.ValueOf(inter) //从接口中获取结构的值
for i := 0; i < t.NumField(); i++ { //遍历所包含的属性字段
f := t.Field(i) //获取到字段
val := v.Field(i).Interface()
ft.Println("字段签名:", f.Type, " 字段名称:", f.Name, " 值:", val)
}
for i := 0; i < t.NumMethod(); i++ { //遍历所绑定的方法
m := t.Method(i) //获取到方法
ft.Println("方法名称:", m.Name, " 方法签名:", m.Type)
}
}
- 结构体嵌套的反射
package something
import (
ft "fmt"
"reflect"
)
type User struct {
Id int
Name string
Info
Base
}
type Info struct {
Age int
Address string
}
type Base struct {
Sex int
}
func (user User) Printl(name string) {
ft.Println("reflect Print()", name)
}
func Reflect(inter interface{}) {
t := reflect.TypeOf(inter) //从接口中获取结构的对象
v := reflect.ValueOf(inter) //从接口中获取结构的值
if t.Kind() == reflect.Ptr && v.Elem().CanSet() { //传入的是指针,可以修改
ft.Println("这里")
v = v.Elem()
if f := v.Kind(); f == reflect.Struct {
if x := v.FieldByName("Age"); x.IsValid() {
x.SetInt(888)
}
if x := v.FieldByName("Address"); x.IsValid() {
x.SetString("深圳市")
}
if x := v.FieldByName("Sex"); x.IsValid() {
x.SetInt(100001)
}
}
if f := v.FieldByName("Name"); f.Kind() == reflect.String && f.IsValid() {
f.SetString("haha")
}
if f := v.FieldByName("Id"); f.Kind() == reflect.Int && f.IsValid() {
f.SetInt(99)
}
if f := v.MethodByName("Print"); f.IsValid() {
args := []reflect.Value{reflect.ValueOf("测试")}
f.Call(args)
}
}
if k := t.Kind(); k != reflect.Struct { //判断传入的是否是struct类型
ft.Println("type is not true")
return
}
ft.Println("类型名称:", t.Name())
for i := 0; i < t.NumField(); i++ { //遍历所包含的属性字段
f := t.FieldByIndex([]int{i}) //获取到字段
val := v.FieldByIndex([]int{i}).Interface()
ft.Println("字段签名:", f.Type, " 字段名称:", f.Name, " 值:", val)
}
for i := 0; i < t.NumMethod(); i++ { //遍历所绑定的方法
m := t.Method(i) //获取到方法
ft.Println("方法名称:", m.Name, " 方法签名:", m.Type)
}
}
- Elem returns the value that the interface v contains or that the pointer v points to. It panics if v's Kind is not Interface or Ptr. It returns the zero Value if v is nil.
解释的大概意思是结构包含接口或指针指向的元素返回值,类型不能使没有实现接口或者指针的结构,如果值是空的,则返回0
package main
import (
f "fmt"
"com.guo/mytest/something"
)
func main(){
r:=something.User{1,"haha",something.Info{100,"广州市"}}
something.Reflect(&r)
something.Reflect(r)
f.Println("修改后结果:",r)
}
