Go学习笔记（15）
反射
先看一个问题，反射的使用场景
使用反射机制，编写函数的适配器, 桥连接
反射的基本介绍
基本介绍
- 反射可以在运行时动态获取变量的各种信息, 比如变量的类型(type)，类别(kind)
- 如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法)
- 通过反射，可以修改变量的值，可以调用关联的方法。
- 使用反射，需要 import (“reflect”)
- 示意图
反射的应用场景
反射重要的函数和概念
- 变量、interface{} 和 reflect.Value 是可以相互转换的，这点在实际开发中，会经常使用到。画出示意图
反射的快速入门
快速入门说明
请编写一个案例，演示对(基本数据类型、interface{}、reflect.Value)进行反射的基本操作
代码演示，见下面的表格：
请编写一个案例，演示对(结构体类型、interface{}、reflect.Value)进行反射的基本操作
代码演示：
package main
import (
"reflect"
"fmt"
)
//专门演示反射
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)
//下面我们将 rVal 转成 interface{}
iV := rVal.Interface()
fmt.Printf("iv=%v iv type=%T \n", iV, iV)
//将 interface{} 通过断言转成需要的类型
//这里，我们就简单使用了一带检测的类型断言.
//同学们可以使用 swtich 的断言形式来做的更加的灵活
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)进行反射的基本操作
//1. 先定义一个 int
// var num int = 100
// reflectTest01(num)
//2. 定义一个 Student 的实例
stu := Student{
Name : "tom",
Age : 20,
}
reflectTest02(stu)
}
反射的注意事项和细节
- reflect.Value.Kind，获取变量的类别，返回的是一个常量
- Type 和 Kind 的区别
Type 是类型, Kind 是类别， Type 和 Kind 可能是相同的，也可能是不同的.
比如: var num int = 10 num 的 Type 是 int , Kind 也是 int
比如: var stu Student stu 的 Type 是 pkg1.Student , Kind 是 struct
- 通过反射的来修改变量, 注意当使用 SetXxx 方法来设置需要通过对应的指针类型来完成, 这样才能改变传入的变量的值, 同时需要使用到 reflect.Value.Elem()方
- reflect.Value.Elem() 应该如何理解？
反射课堂练习
- 给你一个变量 var v float64 = 1.2 , 请使用反射来得到它的 reflect.Value, 然后获取对应的 Type,Kind 和值，并将 reflect.Value 转换成 interface{} , 再将 interface{} 转换成 float64. [不说：]
- 看段代码，判断是否正确，为什么
package main
import (
"fmt"
"reflect"
)
func main() {
var str string = "tom" //ok
fs := reflect.ValueOf(str) //ok fs -> string
fs.SetString("jack") //error
fmt.Printf("%v\n", str)
}
修改如下：
反射最佳实践
- 使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值
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
}
//方法， 接收四个值，给 s 赋值
func (s Monster) Set(name string, age int, score float32, sex string) {
s.Name = name
s.Age = age
s.Score = score
s.Sex = sex
}
//方法，显示 s 的值
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()
//如果传入的不是 struct，就退出
if kd != reflect.Struct {
fmt.Println("expect struct")
return
}
//获取到该结构体有几个字段
num := val.NumField()
fmt.Printf("struct has %d fields\n", num) //4
//变量结构体的所有字段
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.Printf("struct has %d methods\n", numOfMethod)
//var params []reflect.Value
//方法的排序默认是按照 函数名的排序（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() {
//创建了一个 Monster 实例
var a Monster = Monster{
Name: "黄鼠狼精",
Age: 400,
Score: 30.8,
}
//将 Monster 实例传递给 TestStruct 函数
TestStruct(a)
}
- 使用反射的方式来获取结构体的 tag 标签, 遍历字段的值，修改字段值，调用结构体方法(要求：通过传递地址的方式完成, 在前面案例上修改即可)
- 定义了两个函数 test1 和 test2，定义一个适配器函数用作统一处理接口【了解】
- 使用反射操作任意结构体类型：【了解】
- 使用反射创建并操作结构体
课后作业
package main
import (
"fmt"
"reflect"
)
type Cal struct {
Num1 int
Num2 int
}
func (c Cal) GetSub(name string) {
res := c.Num1 - c.Num2
fmt.Printf("%v 完成了减法运行,%v-%v=%v",name,c.Num1,c.Num2,res)
}
func reflectCal(c interface{}) {
v := reflect.ValueOf(c)
// t := reflect.TypeOf(c)
numFiled := v.NumField()
for i := 0; i < numFiled; i++ {
fmt.Printf("第%v字段的值为%v\n",i+1,v.Field(i))
}
var params []reflect.Value
params = append(params, reflect.ValueOf("cbx"))
v.Method(0).Call(params)
}
func main() {
c := Cal{
Num1: 12,
Num2: 3,
}
reflectCal(c)
}
评论