12 Go 反射

反射具有强大的功能，可在程序运行时检查其所拥有的结构，这是元编程的一种形式，即自己能解析自己。我们可以在运行时通过反射来分析一个结构体，检查其类型和变量（类型和取值）和方法，动态地修改变量和调用方法，这对于没有源代码的包尤其有用，这是一个强大的工具，除非真得有必要，否则应当避免使用或小心使用。

反射的一般使用场景：

• 一般的面向对象编程则是正射，程序按预定步骤执行，把类示例化为对象；反射则是把对象反射出类的所有信息，包括Typeof和Valueof两大类反射信息，这种特性可用于框架级别项目的开发。

• 在一般开发中运用于从interface{}容器中获取对象信息，避免类型断言和监测，这种做法也可以用接口实现来代替。

解析示例：

//使用反射解构一个对象，反射出类的信息,以下为示例结构体
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
}

使用示例：

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)
}

使用示例：

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
}