Go反射机制
反射具有强大的功能，可在程序运行时检查其所拥有的结构，这是元编程的一种形式，即自己能解析自己。我们可以在运行时通过反射来分析一个结构体，检查其类型和变量（类型和取值）和方法，动态地修改变量和调用方法，这对于没有源代码的包尤其有用，这是一个强大的工具，除非真得有必要，否则应当避免使用或小心使用。
反射的一般使用场景：
一般的面向对象编程则是正射，程序按预定步骤执行，把类示例化为对象；反射则是把对象反射出类的所有信息，包括Typeof和Valueof两大类反射信息，这种特性可用于框架级别项目的开发。
在一般开发中运用于从interface{}容器中获取对象信息，避免类型断言和监测，这种做法也可以用接口实现来代替。
反射的两套实现：TypeOf和ValueOf
解析示例：
//使用反射解构一个对象，反射出类的信息,以下为示例结构体
type ObjectA struct {
Name string
Age int
Desc string
}
func (oa ObjectA) Fa(int) int {
return 0
}
func (oa ObjectA) Fb(string) bool {
return true
}
1.ValueOf：访问和修改对象的任意属性的值，访问对象的任意方法
使用示例：
func valueAPI(o ObjectA) {
oValue := reflect.ValueOf(o)
fmt.Println("值", oValue)
fmt.Println("查看oValue的原始类型:", oValue.Kind()) //struct
fmt.Println("查看p的所有属性的值")
for i := 0; i < oValue.NumField(); i++ {
fValue := oValue.Field(i)
fmt.Println(fValue.Interface())
}
fmt.Println("获得指针value的内容进而获得成员的值:")
opValue := reflect.ValueOf(&o)
//opValue是一个People指针的Value，oValue是一个People值的Value
oValue = opValue.Elem()
fmt.Println(oValue.Field(1).Interface())
fmt.Println("修改对象的属性:")
oValue.FieldByName("Age").SetInt(60)
fmt.Println(oValue)
fmt.Println("调用对象的方法:")
mValue := opValue.MethodByName("Fa")
mValue.Call([]reflect.Value{reflect.ValueOf(1)})
fmt.Println(oValue)
}
2.TypeOf：对任意对象的细致入微的类型检测
使用示例：
func typeAPI(obj interface{}) {
oType := reflect.TypeOf(obj)
fmt.Println("类型全名：", oType) //main.People
//原始类型
oKind := oType.Kind()
fmt.Println("原始类型：", oKind) //struct
//类型名称
fmt.Println("类型名称", oType.Name()) //People
//属性和方法的个数
fmt.Println("属性个数：", oType.NumField()) //3
fmt.Println("方法个数：", oType.NumMethod()) //2
fmt.Println("全部属性：")
for i := 0; i < oType.NumField(); i++ {
structField := oType.Field(i)
fmt.Println("\t", structField.Name, structField.Type)
}
fmt.Println("全部方法：")
for i := 0; i < oType.NumMethod(); i++ {
method := oType.Method(i)
fmt.Println("\t", method.Name, method.Type)
}
//fmt.Println("获得父类属性")
//fmt.Println(oType.FieldByIndex([]int{0, 0}).Name)
}
调用检查执行结果:
func BaseRelect() {
//valueAPI反射
fmt.Println("===============reflect.ValueOf检测===============")
valueAPI(objA)
//TypeAPI反射
fmt.Println("===============reflect.TypeOf检测===============")
typeAPI(objA)
}
//OUTPUT:
===============reflect.TypeOf检测===============
类型全名： base.ObjectA
原始类型： struct
类型名称 ObjectA
属性个数： 3
方法个数： 2
全部属性：
Name string
Age int
Desc string
全部方法：
Fa func(base.ObjectA, int) int
Fb func(base.ObjectA, string) bool
===============reflect.ValueOf检测===============
值 {fun 18 gopher}
查看oValue的原始类型: struct
查看p的所有属性的值
fun
18
gopher
获得指针value的内容进而获得成员的值:
18
修改对象的属性:
{fun 60 gopher}
调用对象的方法:
{fun 60 gopher}
应用示例
使用反射获取一个[]interface{}切片里对象的属性值：
示例需求：
所有商品有一些共性：品名、价格
个性无千无万，自行封装出三种商品（以模拟30万种商品）
随意给出一个商品的切片，将每件商品的所有属性信息输出到JSON文件(品名.json)
1.笨办法，使用[]interface{}接收所有元素，并逐一类型断言。
//以下普通为构造结构体：
type Computer1 struct {
Name string
Price float64
Cpu string
Memory int
Disk int
}
type TShirt1 struct {
Name string
Price float64
Color string
Size int
Sex bool
}
type Car1 struct {
Name string
Price float64
Cap int
Power string
}
func BaseReflect01() {
//接收所有struct类型的商品，然后类型断言，一旦类型多则断言断吐血
products := make([]interface{}, 0)
computer1 := Computer1{"电脑1", 999.99, "Intel", 1000, 1000}
shirt1 := TShirt1{"衬衫1", 99, "蓝色", 42, true}
car1 := Car1{"宝马", 999999.99, 999, "aa"}
products = append(products, &computer1, &shirt1, &car1)
for _, p := range products {
name := ""
switch p.(type) {
case *Computer1:
name = p.(*Computer1).Name
case *TShirt1:
name = p.(*TShirt1).Name
case *Car1:
name = p.(*Car1).Name
}
fileName := "/Users/fun/mydemo/text/" + name + ".json"
is := Struct2JsonFile(fileName, p)
fmt.Println("输出成功：", is)
}
}
2.常用办法：使用父struct和接口，调用统一接口方法就可以实现。
//以下为包含商品接口的构造体
type IProduct interface {
GetName() string
}
type Product struct {
Name string
Price float64
}
func (p *Product) GetName() string {
return p.Name
}
type Computer2 struct {
Product
Cpu string
Memory int
Disk int
}
type TShirt2 struct {
Product
Color string
Size int
Sex bool
}
type Car2 struct {
Product
Cap int
Power string
}
func BaseReflect02() {
iproducts := make([]IProduct, 0)
computer2 := Computer2{Product{"电脑1", 999.99}, "Intel", 1000, 1000}
shirt2 := TShirt2{Product{"衬衫1", 99}, "蓝色", 42, true}
car2 := Car2{Product{"宝马", 999999.99}, 999, "aa"}
iproducts = append(iproducts, &computer2, &shirt2, &car2)
for _, p := range iproducts {
name := p.GetName()
fileName := "/Users/fun/mydemo/text/" + name + ".json"
is := Struct2JsonFile(fileName, p)
fmt.Println("输出成功：", is)
}
}
3.优越的办法，使[]interface{}接收所有struct类型的商品，然后使用反射，简单的获取需要的对象信息。
func BaseReflect03() {
products := make([]interface{}, 0)
computer1 := Computer1{"电脑1", 999.99, "Intel", 1000, 1000}
shirt1 := TShirt1{"衬衫1", 99, "蓝色", 42, true}
car1 := Car1{"宝马", 999999.99, 999, "aa"}
products = append(products, computer1, shirt1, car1)
for _, p := range products {
//使用反射方式获取未知类型的对象的值,如果知道属性类型是string则直接用string方法获取
name := reflect.ValueOf(p).FieldByName("Name").String()
//如果不确定属性类型，则使用Interface()在类型断言如.(string) / .(int)
//name := reflect.ValueOf(p).FieldByName("Name").Interface().(string)
fileName := "/Users/fun/mydemo/text/" + name + ".json"
is := Struct2JsonFile(fileName, p)
fmt.Println("输出成功：", is)
}
}
工具方法：
//将结构体编码到文件的函数
func Struct2JsonFile(fileName string, v interface{}) (is bool) {
dst, e := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if e != nil {
fmt.Println("打开文件错误：", e)
return
}
defer dst.Close()
encoder := json.NewEncoder(dst)
encoder.Encode(v)
return true
}
