## 1 概述
类似于 Java,Go 语言也支持反射。支持反射的语言可以在运行时对程序进行访问和修改。反射的原理是在程序编译期将反射信息(如类型信息、结构体信息等)整合到程序中,并给提供给程序访问反射信息的操作接口,这样在程序运行期间就可以获取该反射信息,甚至支持修改操作。
Go 语言使用 `reflect` 包支持反射。
本文介绍与类型结构相关的反射操作。
<!-- more -->
## 2 获取类型
使用 `reflect.TypeOf()` 函数可以获得任意值的类型反射对象。演示为:
```go
type Stu struct {
}
var v *Stu
typeV := reflect.TypeOf(v)
fmt.Println(typeV)
// *main.Stu
```
其中,typeV是 `reflect.Type` 类型的实例。
## 3 获取基础类型(类别)
基础类型,也称之为类别。例如 `type Stu struct`,从类型上看是 Stu 类型,如果从基础类型(类别)的角度去看,就是 struct。当需要区分一个大类类别时,就会用到基础类型的概念。可以通过 typeV.Kind() 方法获取对应的基础类型。演示为:
```go
type Stu struct {
}
var v Stu
typeV := reflect.TypeOf(v)
// 同时输出类型名和基础类型
fmt.Println(typeV.Name(), typeV.Kind())
// Stu struct
```
Go 语言的 `reflect` 包定义了如下的基础类型:
```go
来自文件:src/reflect/type.go
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 // 底层指针
)
```
可见指的是原生类型,而不是自定义类型。
## 4 指针引用的元素类型
可以使用指针类型的反射得到其指向的元素的具体类型,使用 `Elem() Type` 来实现,演示为:
```go
type Stu struct {
}
var v *Stu
typeV := reflect.TypeOf(v)
fmt.Println(typeV)
// *main.Stu
fmt.Println(typeV.Kind())
// 基础类型为 ptr 指针
// ptr
fmt.Println(typeV.Elem())
// 指向的元素类型为 main.Stu
// main.Stu
fmt.Println(typeV.Elem().Kind())
// main.Stu的基础类型为 struct
// struct
```
`.Elem()` 方法会得到 `reflect.Type` 类型的返回值,因此可以继续调用 `.Kind()` 得到基础类型。
## 5 结构体信息
若反射的类型为结构体,可以获取其成员信息。涉及几个方法:
* NumField() int,字段数量
* Field(i int) StructField,通过索引确定获取字段的反射
* NumMethod() int,方法数量
* Method(int) Method,通过索引获取方法的反射
演示为:
```go
type Stu struct {
Name string
Sn string
}
func (this *Stu) SetName() {
}
func (this *Stu) SetSn() {
}
func main() {
v := Stu{}
typeV := reflect.TypeOf(v)
fmt.Println(typeV.NumField())
for i, c := 0, typeV.NumField(); i < c; i++ {
fmt.Println(typeV.Field(i))
}
vp := &v // ? 为什么必须要是引用呢 ?
typeVP := reflect.TypeOf(vp)
fmt.Println(typeVP.NumMethod())
for i, c := 0, typeV.NumMethod(); i < c; i++ {
fmt.Println(typeVP.Method(i))
}
}
// 以下为输出结果
2
{Name string 0 [0] false}
{Sn string 16 [1] false}
2
{SetName func(*main.Stu) <func(*main.Stu) Value> 0}
{SetSn func(*main.Stu) <func(*main.Stu) Value> 1}
```
做本案例时,发现对于方法反射的获取,要基于结构体指针才可以,目前不解,需要在深入下。
我们获取的属性和方法分别属于 `reflect.StructField`,`reflect.Method` 类型,若需要接续获取属性字段或方法的信息,可以使用该类型定义的方法完成。定义如下,供参考:
```go
type StructField struct {
Name string // 字段名
PkgPath string // 非导出字段的包路径,对导出字段该字段为""
Type Type // 字段类型
Tag StructTag // 字段标签
Offset uintptr // 字段在结构体中的字节偏移量
Index []int // 用于Type.FieldByIndex时的索引切片
Anonymous bool // 是否匿名字段
}
type Method struct {
Name string // 方法名
PkgPath string // 非导出方法的包路径,对导出方法该字段为""
Type Type // 方法类型
Func Value // 方法值
Index int // 方法索引
}
```
也支持:
* FieldByName(name string) (StructField, bool),通过字段名字确定字段的反射
* MethodByName(string) (Method, bool),通过方法名字确定方法的反射。
## 6 结构体标签
结构体标签,Struct Tag,指的是为字段增加额外的属性,利用反射可获取到这些属性,进而完成特定操作。例如:
```go
type Stu struct {
Name string `json:"name" bson:"name"`
Sn string `json:"sn" bson:"sn"`
}
```
字段后反引号包裹的就是字段的标签。上面的标签是一个常用的格式,在做结构体序列化时经常使用。
利用反射获取标签内容,先获取字段,再获取字段上的标签:
```go
type Stu struct {
Name string `json:"j_name" bson:"b_name"`
Sn string `json:"j_sn" bson:"b_sn"`
}
func main() {
var v Stu
typeV := reflect.TypeOf(v)
for i, c := 0, typeV.NumField(); i < c; i++ {
fmt.Println(typeV.Field(i).Tag.Get("json"), typeV.Field(i).Tag.Get("bson"))
}
}
// 输出
j_name b_name
j_sn b_sn
```
标签语法是key:value结构。(也可以字符串,key:value 更长用,信息量更大)。`StructField.Tag` 可以获取字段的标签,`.Get()` 方法可以获取具体内容。
演示,利用标签 json 编码我们的结构体对象,需要 `encoding/json` 包:
```go
type Stu struct {
Name string `json:"j_name" bson:"b_name"`
Sn string `json:"j_sn" bson:"b_sn"`
}
func main() {
var v = Stu{
"Hank",
"Kang-007",
}
json, err := json.Marshal(v)
fmt.Println(string(json), err)
// {"j_name":"Hank","j_sn":"Kang-007"} <nil>
}
```
注意上面的 json 中的字段,并不是我们的字段Name和Sn,而是标签中定义的j_name, j_sn。`json.Marshal` 方法就读取了字段的tag,确定了字段的名称。除了字段名称提示外,`json.Marshal` 还支持 `json:"j_sn,string,omitempty"` 表示设置名称,类型,忽略空值等操作。
也可利用 json 转换得到结构体对象,继续使用上面的结构体Stu:
```go
var u Stu
if nil == json.Unmarshal(str, &u) {
fmt.Println(u)
// {Hank Kang-007}
}
```
完!
原文出自:[小韩说课](http://www.hellokang.net/go/go-reflect-structure/)
微信关注:小韩说课
![小韩说课](http://www.hellokang.net/images/wechat_subscription.jpg)
有疑问加站长微信联系(非本文作者))