12. Go 反射

Go 反射

Go 反射
TypeOf和ValueOf

reflectValue转原始类型

获取类型底层类型

遍历字段和方法

修改字段的值

动态调用方法

JSON字符串对象转换

反射获取字段Tag

字段Tag的键值对

和Java语言一样，Go也实现运行时反射，这为我们提供一种可以在运行时操作任意类型对象的能力。比如我们可以查看一个接口变量的具体类型，看看一个结构体有多少字段，如何修改某个字段的值等等。

TypeOf和ValueOf

在Go的反射定义中，任何接口都会由两部分组成的，一个是接口的具体类型，一个是具体类型对应的值。比如

var i int = 3

，因为

interface{}

可以表示任何类型，所以变量

i

可以转为

interface{}

，所以可以把变量

i

当成一个接口，那么这个变量在Go反射中的表示就是

<Value,Type>

，其中Value为变量的值

3

,Type变量的为类型

int

。

在Go反射中，标准库为我们提供两种类型来分别表示他们

reflect.Value

和

reflect.Type

，并且提供了两个函数来获取任意对象的

Value

和

Type

。

func main() {
u:= User{"张三",20}
t:= reflect.TypeOf(u)
fmt.Println(t)
}

type User struct{
Name string
Age int
}

reflect.TypeOf

可以获取任意对象的具体类型，这里通过打印输出可以看到是

main.User

这个结构体类型。

reflect.TypeOf

函数接受一个空接口

interface{}

作为参数，所以这个方法可以接受任何类型的对象。

接着上面的例子，我们看下如何反射获取一个对象的

Value

。

v:=reflect.ValueOf(u)
fmt.Println(v)

和

TypeOf

函数一样，也可以接受任意对象，可以看到打印输出为

{张三 20}

。对于以上这两种输出，Go语言还通过

fmt.Printf

函数为我们提供了简便的方法。

fmt.Printf("%T\n",u)
fmt.Printf("%v\n",u)

这个例子和以上的例子中的输出一样。

reflect.Value转原始类型

上面的例子我们可以通过

reflect.ValueOf

函数把任意类型的对象转为一个

reflect.Value

，那我们如果我们想逆向转过回来呢，其实也是可以的，

reflect.Value

为我们提供了

Inteface

方法来帮我们做这个事情。继续接上面的例子：

u1:=v.Interface().(User)
fmt.Println(u1)

这样我们就又还原为原来的

User

对象了,通过打印的输出就可以验证。这里可以还原的原因是因为在Go的反射中，把任意一个对象分为

reflect.Value

和

reflect.Type

，而

reflect.Value

又同时持有一个对象的

reflect.Value

和

reflect.Type

,所以我们可以通过

reflect.Value

的

Interface

方法实现还原。现在我们看看如何从一个

reflect.Value

获取对应的

reflect.Type

。

t1:=v.Type()
fmt.Println(t1)

如上例中，通过

reflect.Value

的

Type

方法就可以获得对应的

reflect.Type

。

获取类型底层类型

底层的类型是什么意思呢？其实对应的主要是基础类型，接口、结构体、指针这些，因为我们可以通过

type

关键字声明很多新的类型，比如上面的例子，对象

u

的实际类型是

User

，但是对应的底层类型是

struct

这个结构体类型，我们来验证下。

fmt.Println(t.Kind())

通过

Kind

方法即可获取，非常简单，当然我们也可以使用

Value

对象的

Kind

方法，他们是等价的。

Go语言提供了以下这些最底层的类型，可以看到，都是最基本的。

const (
Invalid Kind = iota
Bool
Int
Int8
Int16
Int32
Int64
Uint
Uint8
ce6c
Uint16
Uint32
Uint64
Uintptr
Float32
Float64
Complex64
Complex128
Array
Chan
Func
Interface
Map
Ptr
Slice
String
Struct
UnsafePointer
)

遍历字段和方法

通过反射，我们可以获取一个结构体类型的字段,也可以获取一个类型的导出方法，这样我们就可以在运行时了解一个类型的结构，这是一个非常强大的功能。

for i:=0;i<t.NumField();i++ {
fmt.Println(t.Field(i).Name)
}

for i:=0;i<t.NumMethod() ;i++  {
fmt.Println(t.Method(i).Name)
}

这个例子打印出结构体的所有字段名以及该结构体的方法。

NumField

方法获取结构体有多少个字段，然后通过

Field

方法传递索引的方式，循环获取每一个字段，然后打印出他们的名字。

同样的对于方法也类似，这里不再赘述。

修改字段的值

假如我们想在运行中动态的修改某个字段的值有什么办法呢？一种就是我们常规的有提供的方法或者导出的字段可以供我们修改，还有一种是使用反射，这里主要介绍反射。

func main() {
x:=2
v:=reflect.ValueOf(&x)
v.Elem().SetInt(100)
fmt.Println(x)
}

以上就是通过反射修改一个变量的例子。

因为

reflect.ValueOf

函数返回的是一份值的拷贝，所以前提是我们是传入要修改变量的地址。

其次需要我们调用

Elem

方法找到这个指针指向的值。

最后我们就可以使用

SetInt

方法修改值了。

以上有几个重点，才可以保证值可以被修改，

Value

为我们提供了

CanSet

方法可以帮助我们判断是否可以修改该对象。

我们现在可以更新变量的值了，那么如何修改结构体字段的值呢？大家自己试试。

动态调用方法

结构体的方法我们不光可以正常的调用，还可以使用反射进行调用。要想反射调用，我们先要获取到需要调用的方法，然后进行传参调用，如下示例：

func main() {
u:=User{"张三",20}
v:=reflect.ValueOf(u)

mPrint:=v.MethodByName("Print")
args:=[]reflect.Value{reflect.ValueOf("前缀")}
fmt.Println(mPrint.Call(args))

}

type User struct{
Name string
Age int
}

func (u User) Print(prfix string){
fmt.Printf("%s:Name is %s,Age is %d",prfix,u.Name,u.Age)
}

MethodByName

方法可以让我们根据一个方法名获取一个方法对象，然后我们构建好该方法需要的参数，最后调用

Call

就达到了动态调用方法的目的。

获取到的方法我们可以使用

IsValid

来判断是否可用（存在）。

这里的参数是一个

Value

类型的数组，所以需要的参数，我们必须要通过

ValueOf

函数进行转换。

JSON字符串对象转换

func main() {
var u User
h:=`{"name":"张三","age":15}`
err:=json.Unmarshal([]byte(h),&u)
if err!=nil{
fmt.Println(err)
}else {
fmt.Println(u)
}
}

type User struct{
Name string `name`
Age int `age`
}

上面这个例子就是Json字符串转User对象的例子，这里主要利用的就是User这个结构体对应的字段Tag，json解析的原理就是通过反射获得每个字段的tag，然后把解析的json对应的值赋给他们。

利用字段Tag不光可以把Json字符串转为结构体对象，还可以把结构体对象转为Json字符串。

newJson,err:=json.Marshal(&u)
fmt.Println((string(newJson)))

接着刚刚的例子，这样就可以转为一个新的字符串了，通过打印输出，可以看到和开始输入的字符串一样。

反射获取字段Tag

字段的Tag是标记到字段上的，所以我们可以通过先获取字段，然后再获取字段上的Tag。

func main() {
var u User

t:=reflect.TypeOf(u)

for i:=0;i<t.NumField();i++{
sf:=t.Field(i)
fmt.Println(sf.Tag)
}
}

获取字段上一篇我们提到过，获取字段后，调用

.Tag

就获取到对应的Tag字段了。

字段Tag的键值对

很多时候我们的一个Struct不止具有一个功能，比如我们需要JSON的互转、还需要BSON以及ORM解析的互转，所以一个字段可能对应多个不同的Tag，以便满足不同的功能场景。

Go Struct 为我们提供了键值对的Tag，来满足我们以上的需求。

func main() {
var u User
t:=reflect.TypeOf(u)

for i:=0;i<t.NumField();i++{
sf:=t.Field(i)
fmt.Println(sf.Tag.Get("json"))
}

}

type User struct{
Name string `json:"name"`
Age int `json:"age"`
}

以上的例子，使用了键值对的方式配置Struct Tag，Key-Value以冒号分开，这里的Key为

json

，所以我们可以通过这个Key获取对应的值，也就是通过

.Tag.Get("json"))

方法。

Get

方法就是通过一个Key获取对应的tag设置。

除此之外，我们还可以设置多个Key，来满足我们上面说的场景。

func main() {
var u User
t:=reflect.TypeOf(u)

for i:=0;i<t.NumField();i++{
sf:=t.Field(i)
fmt.Println(sf.Tag.Get("json"),",",sf.Tag.Get("bson"))
}

}

type User struct{
Name string `json:"name" bson:"b_name"`
Age int `json:"age" bson:"b_age"`
}

多个Key使用空格进行分开，然后使用Get方法获取不同Key的值。

Struct Tag可以提供字符串到Struct的映射能力，以便我们作转换，除此之外，还可以作为字段的元数据的配置，提供我们需要的配置，比如生成Swagger文档等。