reflect.go包学习_之二 指针操作提高反射性能 反射应用 反射创建实例
反射信息、反射调用方法、反射修改值类型，略。
Go的反射性能
为获取同一类型不同对象，java的field是可重用的，减少了构造和gc。
//java
Field field = clazz.getField("hello");
field.get(obj1);
field.get(obj2);
相对的go：
//go
type_ := reflect.TypeOf(obj)
field, _ := type_.FieldByName("hello")
//filed对于同一类型的不同对象是相同的，但无法用来获取不同对象的此field
//每个对象的取值都要构建reflect.Value，且不可复用，造成GC压力
指针获取struct字段
用指针直接操作地址，先取field.Offset，再obj地址。
获取指针先调用unsafe.Pointer(对象地址)，再强转为unitptr整数。
对象起始位置字段偏移，得到字段地址。强转为字串指针（前提是已经静态地知道了字段的类型），再取内容。
b1 := B{1,"one"}
field,_ := reflect.TypeOf(&b1).Elem().FieldByName("Name")
fieldPtr := uintptr(unsafe.Pointer(&b1))+field.Offset
*((*string)(unsafe.Pointer(fieldPtr))) = "two"
fmt.Println(*((*string)(unsafe.Pointer(fieldPtr))))
评价：没有复杂数据结构reflect.Value的构建。大量获取字段，也不会触发频繁gc，简单高效。编程复杂，要用unsafe包操作指针。
三个重要变量：起始指针、字段偏移、符合字段类型的偏移后指针。
指针获取struct字段
type interfaceHeader struct {
typ *struct{}
word unsafe.Pointer
}
structPtr := (*interfaceHeader)(unsafe.Pointer(&obj)).word
指针获取slice字段
先构造切片和空接口和头struct。切片取指针，强转为切片头。如此实现获取切片长度。
反射获取元素的Type。切片头地址，加若干个元素块大小，转为uintptr类型（Type.Size()返回uintptr类型，所以都要转成这个类型计算）。强转为元素对应的类型，取内容并赋值。
指针可以强转，但不能计算。需要计算转为uintptr大整数。过程：转指针，转uintptr做计算，再转为指针，最后强转取指针指向的内容。
slice :=[]string{"hello","world"}
header := (*SliceHeader)(unsafe.Pointer(&slice))
fmt.Println(header.Len)
//上面实现未用reflect.Value获取切片长度，下面实现指针改值。
elementType := reflect.TypeOf(slice).Elem()//返回类型为Type
s1Ptr := uintptr(header.Data)+elementType.Size()
*((*string)(unsafe.Pointer(s1Ptr)))= "kitty"
Map暂时只用go标准库的值反射api。
扩展：Jsoniter，一种基于反射的 JSON 解析器。可以用 reflect.Type 得出来的信息来直接做反射，而不依赖于 reflect.ValueOf，从而提高反射效率。
反射创建slice map
功能：反射创建、反射添加元素、转回Interface{}
s := make([]int,0)
sT := reflect.TypeOf(s)
sReflect := reflect.MakeSlice(sT,0,0)//反射创建
sReflect = reflect.Append(sReflect,reflect.ValueOf(10))//反射添加
sRtoObj := sReflect.Interface().([]int)
fmt.Println(sRtoObj)
m := make(map[int]string)
mT := reflect.TypeOf(m)
mReflect := reflect.MakeMap(mT)
mReflect.SetMapIndex(reflect.ValueOf(1),reflect.ValueOf("one"))
mRtoObj := mReflect.Interface().(map[int]string)
fmt.Println(mRtoObj)
反射创建实例
bT := reflect.TypeOf(b)
bIns := reflect.New(bT)
fmt.Println(bIns.Type(), bIns.Kind())
反射调用的方法含有错误，可以使用断言：
//反射调用的检查错误示例
type T struct {
}
func (this *T)HasError() (int,error) {
return 0,errors.New("hasError")
}
func main() {
t := T{}
err := reflect.ValueOf(&t).MethodByName("HasError").Call(nil)[1]
if err1 := err.Interface().(error);err1!=nil{
println(err1.Error())
}
}
用作tag作关联。动态调用，获取不同类的相同字段名，并为其赋值。
取Type的反射不用引用，避免调用NumField()，Field()都比较麻烦。Tag的值类型为字串。
Tag调用Get()直接获取，而调用tag.Loopup()返回tagVal,ok先作判断，防止程序panic。
type A struct {
Id int `B:"Id"`
Name string `B:"Name""`
}
type B struct {
Id int
Name string
}
func main() {
a := A{1,"one"}
b := B{2,"two"}
aT := reflect.TypeOf(a)
aV := reflect.ValueOf(&a)
bV := reflect.ValueOf(&b)
for i:=0;i<aT.NumField();i++{
field := aT.Field(i)
fieldB := field.Tag.Get("B")
bV.Elem().FieldByName(fieldB).Set(aV.Elem().Field(i))
}
}
不同类型不同处理，在mvc框架中的返回值String Interface{}中有用到。
//检测各字段类型、分别处理
for i:=0;i<aV.Elem().NumField();i++{
switch aV.Elem().Field(i).Type().Kind(){
case reflect.Int:
fmt.Println("it's Id")
case reflect.String:
fmt.Println("it's Name")
default:
}
}
IsValide检测
//检测是否有不存在的字段，未命中的哈希
reflect.ValueOf(s).FieldByName("").IsValid())
reflect.ValueOf(m).MapIndex(reflect.ValueOf(3)).IsValid())
其它概念
Go语言类型是静态类型，接口也是静态类型。
类型查询，反射转回Interface{}都会用到断言。断言和switch...case功能相同。一个简洁，一个方便断言失败的default处理。
接口三定律，
反射第一定律：反射可以将“接口类型变量”转换为“反射类型对象”。
反射第二定律：反射可以将“反射类型对象”转换为“接口类型变量”。
反射第三定律：如果要修改“反射类型对象”，其值必须是“可写的”（settable）。用传址+Elem()的方法。
最后的整合全部实例
package main
import (
"errors"
"fmt"
"reflect"
"unsafe"
)
type T struct {
}
func (this *T) HasError() (int, error) {
return 0, errors.New("hasError")
}
type A struct {
Id int `B:"Id"`
Name string `B:"Name""`
}
type B struct {
Id int
Name string
}
func main() {
t := T{}
err := reflect.ValueOf(&t).MethodByName("HasError").Call(nil)[1]
if err1 := err.Interface().(error); err1 != nil {
println(err1.Error())
}
a := A{1, "one"}
b := B{2, "two"}
aT := reflect.TypeOf(a)
aV := reflect.ValueOf(&a)
bV := reflect.ValueOf(&b)
for i := 0; i < aT.NumField(); i++ {
field := aT.Field(i)
fieldB := field.Tag.Get("B")
bV.Elem().FieldByName(fieldB).Set(aV.Elem().Field(i))
}
for i := 0; i < aV.Elem().NumField(); i++ {
switch aV.Elem().Field(i).Type().Kind() {
case reflect.Int:
fmt.Println("it's Id")
case reflect.String:
fmt.Println("it's Name")
default:
}
}
s := make([]int, 0)
sT := reflect.TypeOf(s)
sReflect := reflect.MakeSlice(sT, 0, 0) //反射创建
sReflect = reflect.Append(sReflect, reflect.ValueOf(10)) //反射添加
sRtoObj := sReflect.Interface().([]int)
fmt.Println(sRtoObj)
m := make(map[int]string)
mT := reflect.TypeOf(m)
mReflect := reflect.MakeMap(mT)
mReflect.SetMapIndex(reflect.ValueOf(1), reflect.ValueOf("one"))
mRtoObj := mReflect.Interface().(map[int]string)
fmt.Println(mRtoObj)
b1 := B{1, "one"}
field, _ := reflect.TypeOf(&b1).Elem().FieldByName("Name")
fieldPtr := uintptr(unsafe.Pointer(&b1)) + field.Offset
*((*string)(unsafe.Pointer(fieldPtr))) = "two"
fmt.Println(*((*string)(unsafe.Pointer(fieldPtr))))
slice := []string{"hello", "world"}
header := (*SliceHeader)(unsafe.Pointer(&slice))
fmt.Println(header.Len)
//上面实现未用reflect.Value获取切片长度，下面实现指针改值。
elementType := reflect.TypeOf(slice).Elem() //返回类型为Type
s1Ptr := uintptr(header.Data) + elementType.Size()
*((*string)(unsafe.Pointer(s1Ptr))) = "kitty"
bT := reflect.TypeOf(b)
bIns := reflect.New(bT)
fmt.Println(bIns.Type(), bIns.Kind())
}
type SliceHeader struct {
Data unsafe.Pointer
Len int
Cap int
}
type interfaceHeader struct {
typ *struct{}
word unsafe.Pointer
}
https://studygolang.com/articles/14577?fr=sidebar
https://studygolang.com/articles/12348?fr=sidebar
https://studygolang.com/articles/12349
https://www.jb51.net/article/90021.htm
