本文参考了李文周的博客——Go语言基础之反射。
一、反射初识
1. 什么是反射
在计算机科学中，反射是指计算机程序在运行时（run time）可以访问、检测和修改它本身状态和行为的一种能力。用比喻来说，反射就是程序在运行的时候能够观察并修改自己的行为。
2. 使用场景
- 编写函数时，并不知道调用者传入的参数类型是什么，可能是没约定好，也可能是传入的类型很多，这些类型不能统一表示
- 有时候需要根据某些条件调用哪个函数，此时需要对函数和函数的参数进行反射，在运行期间动态的执行函数
3. 缺点
- 反射相关的代码难以阅读
- Go语言作为一门静态语言，在编码过程中可以发现一些类型错误，但对于反射代码则是无能为力的
- 反射对性能影响比较大，比正常代码运行速度慢一到两个数量级
二、reflect包
Go语言中的接口值都具有具体类型和具体类型的值两部分信息，而类型（Type）和值（Value）可以理解为定义在reflect包下的两个结构体reflect.Type和reflect.Value。
reflect包下有两个最基础的函数——TypeOf和ValueOf，分别用于获取对象的类型信息和值信息，也即reflect.Type和reflect.Value对象。
| 函数 | 说明 |
|---|---|
| func TypeOf(i any) Type | 获取对象的类型信息 |
| func ValueOf(i any) Value | 获取对象的值信息 |
1. refelect.TypeOf函数
(1) TypeOf函数
通过relect.TypeOf()函数我们可以获取任意对象的类型信息，即reflect.Type对象。
package main
import (
"fmt"
"reflect"
)
func main() {
var x float64 = 3.4
fmt.Println("type:",reflect.TypeOf(x)) //type: float64
}
(2) Type和Kind
反射中的类型可以分为类型（Type）和种类（Kind）两种。类型（Type）是在变量声明时被赋予的类型（静态类型）或者运行时的类型（动态类型，又称具体类型）。而种类（Kind）是指数据底层的类型，种类是有限可枚举的。reflect包下定义的Kind类型包含以下几种：
type Kind uint
const (
Invalid Kind = iota // 非法类型
Bool // 布尔型
Int // 有符号整型
Int8 // 有符号8位整型
Int16 // 有符号16位整型
Int32 // 有符号32位整型
Int64 // 有符号64位整型
Uint // 无符号整型
Uint8 // 无符号8位整型
Uint16 // 无符号16位整型
Uint32 // 无符号32位整型
Uint64 // 无符号64位整型
Uintptr // 指针
Float32 // 单精度浮点数
Float64 // 双精度浮点数
Complex64 // 64位复数类型
Complex128 // 128位复数类型
Array // 数组
Chan // 通道
Func // 函数
Interface // 接口
Map // 映射
Ptr // 指针
Slice // 切片
String // 字符串
Struct // 结构体
UnsafePointer // 底层指针
)
反射对象的Kind可以通过reflect.Value或reflect.Type类型对象的Kind()函数获取。reflect.Value或reflect.Type类型对象有很多同名函数，它们有些功能相同，有些在返回值有些许区别，本文后面对此有更多的例子。
2. reflect.ValueOf函数
(1) ValueOf函数
通过reflect.ValueOf()函数我们可以获取任意对象的值信息，即reflect.Value对象，其中包含了原始值的值信息。
package main
import (
"fmt"
"reflect"
)
func main() {
var x float64 = 3.4
fmt.Println("value:",reflect.ValueOf(x)) //value: 3.4
}
(2) Value转为原始值
除了可以通过ValueOf()函数将原始值转为reflect.Value对象外，还可以将reflect.Value对象转为原始值，reflect.Value类型提供的获取原始值的方法如下：
| 方法 | 说明 |
|---|---|
| func (v Value) Interface() interface {} | 将值以 interface{} 类型返回，可以通过类型断言转换为指定类型 |
| func (v Value) Int() int64 | 将值以 int 类型返回，所有有符号整型均可以此方式返回 |
| func (v Value) Uint() uint64 | 将值以 uint 类型返回，所有无符号整型均可以此方式返回 |
| func (v Value) Float() float64 | 将值以双精度（float64）类型返回，所有浮点数（float32、float64）均可以此方式返回 |
| func (v Value) Bool() bool | 将值以 bool 类型返回 |
| func (v Value) Bytes() []bytes | 将值以字节数组 []bytes 类型返回 |
| func (v Value) String() string | 将值以字符串类型返回 |
可以发现通过Interface方法获取原始值的方式是最为通用的一种。
3. isNil和isValid方法
由于函数参数传递是值拷贝，所以必须传递变量的地址才能修改变量的值。在反射中可以使用Elem()方法来获取指针对应的值。
(1) isNil方法
func (v Value) IsNil() bool
IsNil()报告v持有的值是否为nil，IsNil()常被用于判断指针是否为空。。v持有的值的分类必须是通道、函数、接口、映射、指针、切片之一；否则IsNil函数会导致panic。
(2) isValid方法
func (v Value) IsValid() bool
IsValid()返回v是否持有一个值，IsValid()常被用于判定返回值是否有效。
(3) 代码示例
func main() {
// *int类型空指针
var a *int
fmt.Println("var a *int IsNil:", reflect.ValueOf(a).IsNil())
// nil值
fmt.Println("nil IsValid:", reflect.ValueOf(nil).IsValid())
// 实例化一个匿名结构体
b := struct{}{}
// 尝试从结构体中查找"abc"字段
fmt.Println("不存在的结构体成员:", reflect.ValueOf(b).FieldByName("abc").IsValid())
// 尝试从结构体中查找"abc"方法
fmt.Println("不存在的结构体方法:", reflect.ValueOf(b).MethodByName("abc").IsValid())
// map
c := map[string]int{}
// 尝试从map中查找一个不存在的键
fmt.Println("map中不存在的键：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("娜扎")).IsValid())
}
三、结构体反射
如果反射对象的类型是结构体，反射类型reflect.Type和反射值reflect.Value对象提供了对应的方法，来获取结构体的字段信息和方法信息，并且可以通过反射来调用结构体的方法。
1. 与结构体字段、方法相关的方法
下表中所列举的方法，除了Call()函数之外，其他的都是reflect.Value和reflect.Type都有的，只不过reflect.Value的同名函数返回结果的类型都是reflect.Value对象。
| 方法 | 说明 |
|---|---|
| func (t Type) Field(i int) StructField | 根据索引，返回索引对应的结构体字段的信息。 |
| func (t Type) NumField() int | 返回结构体成员字段数量。 |
| func (t Type) FieldByName(name string) (StructField, bool) | 根据给定字符串返回字符串对应的结构体字段的信息。 |
| func (t Type) FieldByIndex(index []int) StructField | 多层成员访问时，根据 []int 提供的每个结构体的字段索引，返回字段的信息。 |
| func (t Type) FieldByNameFunc(match func(string) bool) (StructField,bool) | 根据传入的匹配函数匹配需要的字段。 |
| func (t Type) NumMethod() int | 返回该类型的方法集中方法的数目 |
| func (t Type) Method(int) Method | 返回该类型方法集中的第i个方法 |
| func (t Type) MethodByName(string) (Method, bool) | 根据方法名返回该类型方法集中的方法 |
| func (v Value) Call([]Value) []Value | 根据传参调用结构体的方法 |
2. 获取结构体字段信息
(1) StructField类型
在上表中，有些方法的返回值类型为StructField类型，它是用来描述结构体的一个字段信息的，其定义如下：
type StructField struct {
Name string // 字段的名字
PkgPath string // 非导出字段的包路径，对于导出字段该字段值为""
Type Type // 字段的类型
Tag StructTag // 字段的标签
Offset uintptr // 字段在结构体中的字节偏移量
Index []int // 用于Type.FieldByIndex时的索引
Anonymous bool // 是否匿名字段
}
(2) 获取结构体字段信息步骤
获取结构体字段信息可以分为以下几步：
- 先获取interface的reflect.Type，然后通过NumField进行遍历
- 再通过reflect.Type的Field方法根据下标获取其Field
- 最后通过reflect.Value的Field的Interface()得到对应的value
当然也可以使用FieldByName方法根据字段名获取字段信息。
2. 获取结构体方法信息
(1) Method类型
在上表中，有些方法的返回值类型为Method类型，它是用来描述结构体的一个方法信息的，其定义如下：
type Method struct {
Name string // 方法名称
PkgPath string // 非导出方法的包路径，对于导出方法该字段值为""
Type Type // 方法类型
Func Value // 带有接收器作为第一个参数的方法
Index int // 用于Type.MethodByIndex时的索引
}
(2) 获取结构体方法信息步骤
获取结构体方法信息可以分为以下几步：
- 先获取interface的reflect.Type，然后通过NumMethod进行遍历
- 再通过reflect.Type的Method根据下标获取其Method
- 使用reflect.Value的Call函数调用结构体的Method
当然也可以使用MethodByName方法根据方法名获取方法信息。
3. 代码示例
package main
import (
"fmt"
"reflect"
)
// 定义一个结构体
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
Sex string `json:"sex"`
}
// 注意，如果是指针 *Person 类型，则不算做是 Person 的Method
func (p Person) PrintInfo() {
fmt.Printf("name：%s, age：%d, sex：%s\n", p.Name, p.Age, p.Sex)
}
func (p Person) Say(msg string) {
fmt.Println("hello,", msg)
}
func main() {
p := Person{
Name: "zuzhiang",
Age: 27,
Sex: "female",
}
getFieldAndMethod(p)
}
// getFieldAndMethod 通过接口来获取任意参数，并打印结构体的字段和方法信息
func getFieldAndMethod(input interface{}) {
getType := reflect.TypeOf(input) // 获取input的类型
fmt.Println("Type.Name: ", getType.Name()) // Person
fmt.Println("Type.Kind: ", getType.Kind()) // struct
getValue := reflect.ValueOf(input) // 获取input的值
fmt.Println("Value:", getValue) // {zuzhiang 27 female}
fmt.Println("----------------------------------------\n")
// 获取结构体字段
// 1. 先获取interface的reflect.Type，然后通过NumField进行遍历
// 2. 再通过reflect.Type的Field方法根据下标获取其Field
// 3. 最后通过reflect.Value的Field的Interface()得到对应的value
for i := 0; i < getType.NumField(); i++ {
field := getType.Field(i)
value := getValue.Field(i).Interface() //获取第i个值
fmt.Printf("字段名: %s, 字段类型: %s, 字段索引: %d, json tag: %s, 字段值: %v \n",
field.Name, field.Type, field.Index, field.Tag.Get("json"), value)
}
fmt.Println("----------------------------------------\n")
// 定义函数调用时的参数，Call函数的参数类型必须是[]reflect.Value
msg := "zuzhiang"
paramList := make([]reflect.Value, 0)
paramList = append(paramList, reflect.ValueOf(msg))
args := [][]reflect.Value{
nil,
paramList,
}
// 通过反射，操作方法
// 1. 先获取interface的reflect.Type，然后通过NumMethod进行遍历
// 2. 再通过reflect.Type的Method根据下标获取其Method
// 3. 使用reflect.Value的Call函数调用结构体的Method
for i := 0; i < getType.NumMethod(); i++ {
method := getType.Method(i)
fmt.Printf("方法名称: %s, 方法类型: %v \n", method.Name, method.Type)
// 函数的顺序按函数名字典序正序排列
getValue.Method(i).Call(args[i])
fmt.Println("")
}
}
![[2]MyBatis+Spring+SpringMVC+SSM整合一套通关](https://img-blog.csdnimg.cn/8292acd91dab45c39860de2a3ceaddf6.png#pic_center)
