Golang 中反射的应用实例详解

08-26 64阅读 0评论

引言

首先来一段简单的代码逻辑热身,下面的代码大家觉得应该会打印什么呢?

type OKR Struct {    id  int    content string } func GetOkrDetail(ctx context.Context, okrId int) (*OKR, *okrErr.OkrErr) {    return &OKR{id: okrId, content: fmt.Sprint(rand.Int63())}, nil } func getOkrDetailV2(ctx context.Context, okrId int) (*OKR, okrErr.OkrError) {    if okrId == 2{   return nil, okrErr.OKRnotFoundError    }    return &OKR{id: okrId, content: fmt.Sprint(rand.Int63())}, nil } func paperOkrId(ctx context.Context) (int, error){    return 1, nil } func test001(ctx context.Context) () {    var okr *OKR    okrId, err := paperOkrId(ctx)    if err != nil{   fmt.Println("####   111   ####")    }    okr, err = getOkrDetail(ctx, okrId)    if err != nil {   fmt.Println("####   222   ####")    }    okr, err = getOkrDetailV2(ctx, okrId)    if err != nil {   fmt.Println("####   333   ####")    }    okr, err = getOkrDetailV2(ctx, okrId + 1)    if err != nil {   fmt.Println("####   444   ####")    }    fmt.Println("####   555   ####")    fmt.Printf("%v", okr) } func main() {    Test001(context.Background()) } 

Golang 中反射的应用实例详解

golang类型设计原则

在讲反射之前,先来看看 Golang 关于型设计的一些原则

Golang 中变量括(type, value)两部分理解这一点就能解决上面的简单问题了type 包括 static type 和 concrete type. 简单来说 static type 是你在编码是看见的类型(如 int、string),concrete type 是 runtime 系统看见的类型。类型断言能否成功,取决于变量的 concrete type,而不是 static type.

接下来要说的反射,就是能够在运行时更新变量和检查变量的值、调用变量的方法和变量支持的内在操作,而不需要在编译时就知道这些变量的具体类型。这种机制被称为反射。GOlang 的基础类型是静态的(也就是指定 int、string 这些的变量,它的 type 是 static type),在创建变量的时候就已经确定,反射主要与 golang 的 interface 类型相关(它的 type 是 concrete type),只有运行时 interface 类型才有反射一说。

Golang 中为什么要使用反射/什么场景可以(应该)使用反射

当程序运行时,我们获取到一个 interface 变量, 程序应该如何知道当前变量的类型,和当前变量的值呢?

当然我们可以有预先定义好的指定类型, 但是如果有一个场景是我们需要编写一个函数,能够处理一类共性逻辑的场景,但是输入类型很多,或者根本不知道接收参数的类型是什么,或者可能是没约定好;

也可能是传入的类型很多,这些类型并不能统一表示。

这时反射就会用的上了,典型的例子如:JSon.Marshal。

再比如说有时候需要根据某些条件决定调用哪个函数,比如根据用户的输入来决定。这时就需要对函数和函数的参数进行反射,在运行期间动态地执行函数。

举例场景:

比如我们需要将一个 struct 执行某种操作(用格式化打印代替),这种场景下我们有多种方式可以实现,比较简单的方式是:Switch case

func Sprint(x interface{}) string { type stringer interface { String() string } switch x := x.(type) { case stringer: return x.String() case string: return x case int: return strconv.Itoa(x) // int16, UInt32... case bool: if x { return "true" } return "false" default: return "wrong parameter type" } } type permissiONType int64 

但是这种简单的方法存在一个问题, 当增加一个场景时,比如需要对 slice 支持,则需要在增加一个分支,这种增加是无穷无尽的,每当我需要支持一种类型,哪怕是自定义类型, 本质上是 int64 也仍然需要增加一个分支。

反射的基本用法

在 Golang 中为我们提供了两个方法,分别是 reflect.ValueOf 和 reflect.TypeOf,见名知意这两个方法分别能帮我们获取到对象的值和类型。Valueof 返回的是 Reflect.Value 对象,是一个 struct,而 typeof 返回的是 Reflect.Type 是一个接口。我们只需要简单的使用这两个进行组合就可以完成多种功能

type GetOkrDetailResp struct {    OkrId   int64    UInfo   *userInfo    Objlist []*ObjInfo } type ObjInfo struct {    ObjId int64    Content string } type UserInfo struct {    Name string    Age  int    IsLeader bool    Salary   float64    privateFiled int } // 利用反射创建struct func NewUserInfoByReflect(req interface{})*UserInfo{   if req == nil{ return nil   }    reqType :=reflect.TypeOf(req)   if reqType.Kind() == reflect.Ptr{   reqType = reqType.Elem()    }    return reflect.New(reqType).Interface().(*UserInfo) } // 修改struct 字段值 func modifyOkrDetailRespData(req interface{}) {    reqValue :=reflect.ValueOf(req).Elem()    fmt.Println(reqValue.Canset())    uType := reqValue.FieldByName("UInfo").Type().Elem()    fmt.Println(uType)    uInfo := reflect.New(uType)    reqValue.FieldByName("UInfo").Set(uInfo) } // 读取 struct 字段值,并根据条件进行过滤 func FilterOkrRespData(reqData interface{}, objId int64){ // 首先获取req中obj slice 的value for i := 0 ; i < reflect.ValueOf(reqData).Elem().NumField(); i++{   fieldValue := reflect.ValueOf(reqData).Elem().Field(i) if fieldValue.Kind() != reflect.Slice{ continue   }   fieldType := fieldValue.Type() // []*ObjInfo   sliceType := fieldType.Elem() // *ObjInfo   slicePtr := reflect.New(reflect.SliceOf(sliceType)) // 创建一个指向 slice 的指针   slice := slicePtr.Elem()   slice.Set(reflect.MakeSlice(reflect.SliceOf(sliceType), 0, 0))  // 将这个指针指向新创建slice // 过滤所有objId == 当前objId 的struct for i := 0 ;i < fieldValue.Len(); i++{ if fieldValue.Index(i).Elem().FieldByName("ObjId").Int() != objId { continue  }  slice = reflect.Append(slice, fieldValue.Index(i))   } // 将resp 的当前字段设置为过滤后的slice   fieldValue.Set(slice)    } } func Test003(){ // 利用反射创建一个新的对象 var uInfo *UserInfo    uInfo = NewUserInfoByReflect(uInfo)    uInfo = NewUserInfoByReflect((*UserInfo)(nil)) // 修改resp 返回值里面的 user info 字段(初始化)    reqData1 := new(GetOkrDetailResp)    fmt.Println(reqData1.UInfo)    ModifyOkrDetailRespData(reqData1)    fmt.Println(reqData1.UInfo) // 构建请求参数    reqData := &GetOkrDetailResp{OkrId: 123}    for i := 0; i < 10; i++{   reqData.ObjList = append(reqData.ObjList, &ObjInfo{ObjId: int64(i), Content: fmt.Sprint(i)})    } // 输出过滤前结果    fmt.Println(reqData) // 对respData进行过滤操作    FilterOkrRespData(reqData, 6) // 输出过滤后结果    fmt.Println(reqData) } 

反射的性能分析与优缺点

大家都或多或少听说过反射性能偏低,使用反射要比正常调用要低几倍到数十倍,不知道大家有没有思考过反射性能都低在哪些方面,我先做一个简单分析,通过反射在获取或者修改值内容时,多了几次内存引用,多绕了几次弯,肯定没有直接调用某个值来的迅速,这个是反射带来的固定性能损失,还有一方面的性能损失在于,结构体类型字段比较多时,要进行遍历匹配才能获取对应的内容。

下面就根据反射具体示例来分析性能:

测试反射结构体初始化

// 测试结构体初始化的反射性能 func Benchmark_Reflect_New(b *testing.B) {    var tf *TestReflectField    t := reflect.TypeOf(TestReflectField{})    for i := 0; i < b.N; i++ {   tf = reflect.New(t).Interface().(*TestReflectField)    }    _ = tf } // 测试结构体初始化的性能 func Benchmark_New(b *testing.B) {    var tf *TestReflectField    for i := 0; i < b.N; i++ {   tf = new(TestReflectField)    }    _ = tf } 

运行结果:

Golang 中反射的应用实例详解

可以看出,利用反射初始化结构体和直接使用创建 new 结构体是有性能差距的,但是差距不大,不到一倍的性能损耗,看起来对于性能来说损耗不是很大,可以接受。

测试结构体字段读取/赋值

// ---------------------  字段读  ----------- ----------- ----------- // 测试反射读取结构体字段值的性能 func Benchmark_Reflect_GetField(b *testing.B) {    var tf = new(TestReflectField)    var r int64    temp := reflect.ValueOf(tf).Elem()    for i := 0; i < b.N; i++ {   r = temp.Field(1).Int()    }    _ = tf    _ = r } // 测试反射读取结构体字段值的性能 func Benchmark_Reflect_GetFieldByName(b *testing.B) {    var tf = new(TestReflectField)    temp := reflect.ValueOf(tf).Elem()    var r int64    for i := 0; i < b.N; i++ {   r = temp.FieldByName("Age").Int()    }    _ = tf    _ = r } // 测试结构体字段读取数据的性能 func Benchmark_GetField(b *testing.B) {    var tf = new(TestReflectField)    tf.Age = 1995    var r int    for i := 0; i < b.N; i++ {   r = tf.Age    }    _ = tf    _ = r } // ---------------------  字段写  ----------- ----------- ----------- // 测试反射设置结构体字段的性能 func Benchmark_Reflect_Field(b *testing.B) {    var tf = new(TestReflectField)    temp := reflect.ValueOf(tf).Elem()    for i := 0; i < b.N; i++ {   temp.Field(1).SetInt(int64(25))    }    _ = tf } // 测试反射设置结构体字段的性能 func Benchmark_Reflect_FieldByName(b *testing.B) {    var tf = new(TestReflectField)    temp := reflect.ValueOf(tf).Elem()    for i := 0; i < b.N; i++ {   temp.FieldByName("Age").SetInt(int64(25))    }    _ = tf } // 测试结构体字段设置的性能 func Benchmark_Field(b *testing.B) {    var tf = new(TestReflectField)    for i := 0; i < b.N; i++ {   tf.Age = i    }    _ = tf } 

测试结果:

Golang 中反射的应用实例详解

Golang 中反射的应用实例详解

从上面可以看出,通过反射进行 struct 字段读取耗时是直接读取耗时的百倍。直接对实例变量进行赋值每次 0.5 ns,性能是通过反射操作实例指定位置字段的10 倍左右。

使用 FieldByName("Age") 方法性能比使用 Field(1) 方法性能要低十倍左右,看代码的话我们会发现,FieldByName 是通过遍历匹配所有的字段,然后比对字段名称,来查询其在结构体中的位置,然后通过位置进行赋值,所以性能要比直接使用 Field(index) 低上很多。

建议:

如果不是必要尽量不要使用反射进行操作,使用反射时要评估好引入反射对接口性能的影响。减少使用 FieldByName 方法。在需要使用反射进行成员变量访问的时候,尽可能的使用成员的序号。如果只知道成员变量的名称的时候,看具体代码的使用场景,如果可以在启动阶段或在频繁访问前,通过 TypeOf() 、Type.FieldByName() 和 StructField.Index 得到成员的序号。注意这里需要的是使用的是 reflect.Type 而不是 reflect.Value,通过 reflect.Value 是得不到字段名称的。

测试结构体方法调用

// 测试通过结构体访问方法性能 func BenchmarkMethod(b *testing.B) {    t := &TestReflectField{}    for i := 0; i < b.N; i++ {   t.Func0()    } } // 测试通过序号反射访问无参数方法性能 func BenchmarkReflectMethod(b *testing.B) {    v := reflect.ValueOf(&TestReflectField{})    for i := 0; i < b.N; i++ {   v.Method(0).Call(nil)    } } // 测试通过名称反射访问无参数方法性能 func BenchmarkReflectMethodByName(b *testing.B) {    v := reflect.ValueOf(&TestReflectField{})    for i := 0; i < b.N; i++ {   v.MethodByName("Func0").Call(nil)    } } // 测试通过反射访问有参数方法性能 func BenchmarkReflectMethod_WithArgs(b *testing.B) {    v := reflect.ValueOf(&TestReflectField{})    for i := 0; i < b.N; i++ {   v.Method(1).Call([]reflect.Value{reflect.ValueOf(i)})    } } // 测试通过反射访问结构体参数方法性能 func BenchmarkReflectMethod_WithArgs_Mul(b *testing.B) {    v := reflect.ValueOf(&TestReflectField{})    for i := 0; i < b.N; i++ {   v.Method(2).Call([]reflect.Value{reflect.ValueOf(TestReflectField{})})    } } // 测试通过反射访问接口参数方法性能 func BenchmarkReflectMethod_WithArgs_Interface(b *testing.B) {    v := reflect.ValueOf(&TestReflectField{})    for i := 0; i < b.N; i++ {   var tf TestInterface = &TestReflectField{}   v.Method(3).Call([]reflect.Value{reflect.ValueOf(tf)})    } } // 测试访问多参数方法性能 func BenchmarkMethod_WithManyArgs(b *testing.B) {    s := &TestReflectField{}    for i := 0; i < b.N; i++ {   s.Func4(i, i, i, i, i, i)    } } // 测试通过反射访问多参数方法性能 func BenchmarkReflectMethod_WithManyArgs(b *testing.B) {    v := reflect.ValueOf(&TestReflectField{})    va := make([]reflect.Value, 0)    for i := 1; i <= 6; i++ {   va = append(va, reflect.ValueOf(i))    }    for i := 0; i < b.N; i++ {   v.Method(4).Call(va)    } } // 测试访问有返回值的方法性能 func BenchmarkMethod_WithResp(b *testing.B) {    s := &TestReflectField{}    for i := 0; i < b.N; i++ {   _ = s.Func5()    } } // 测试通过反射访问有返回值的方法性能 func BenchmarkReflectMethod_WithResp(b *testing.B) {    v := reflect.ValueOf(&TestReflectField{})    for i := 0; i < b.N; i++ {   _ = v.Method(5).Call(nil)[0].Int()    } } 

Golang 中反射的应用实例详解

这个测试结果同上面的分析相同

优缺点

优点:

反射提高了程序的灵活性和扩展性,降低耦合性,提高自适应能力。合理利用反射可以减少重复代码

缺点:

与反射相关的代码,经常是难以阅读的。在软件工程中,代码可读性也是一个非常重要的指标。Go 语言作为一门静态语言,编码过程中,编译器能提前发现一些类型错误,但是对于反射代码是无能为力的。所以包含反射相关的代码,很可能会运行很久,才会出错,这时候经常是直接 panic,可能会造成严重的后果。反射对性能影响还是比较大的,比正常代码运行速度慢一到两个数量级。所以,对于一个项目中处于运行效率关键位置的代码,尽量避免使用反射特性。

反射在 okr 中的简单应用

func OkrBaseMW(next endpoint.EndPoint) endpoint.EndPoint {    return func(ctx context.Context, req interface{}) (resp interface{}, err error) {   if req == nil {  return next(ctx, req)   }   requestValue := reflect.ValueOf(req)   // 若req为指针,则转换为非指针值   if requestValue.Type().Kind() == reflect.Ptr {  requestValue = requestValue.Elem()   }   // 若req的值不是一个struct,则不注入   if requestValue.Type().Kind() != reflect.Struct {  return next(ctx, req)   }   if requestValue.IsValid() {  okrBaseValue := requestValue.FieldByName("OkrBase")  if okrBaseValue.IsValid() &amp;&amp; okrBaseValue.Type().Kind() == reflect.Ptr { okrBase, ok := okrBaseValue.Interface().(*okrx.OkrBase) if ok {    ctx = contextWithUserInfo(ctx, okrBase)    ctx = contextWithLocaleInfo(ctx, okrBase)    ctx = contextWithUserAgent(ctx, okrBase)    ctx = contextWithCsrfToken(ctx, okrBase)    ctx = contextWithReferer(ctx, okrBase)    ctx = contextWithXForwardedFor(ctx, okrBase)    ctx = contextWithHost(ctx, okrBase)    ctx = contextWithURI(ctx, okrBase)    ctx = contextWithSession(ctx, okrBase) }  }   }   return next(ctx, req)    } } 

结论

使用反射必定会导致性能下降,但是反射是一个强有力的工具,可以解决我们平时的很多问题,比如数据库映射、数据序列化、代码生成场景。

在使用反射的时候,我们需要避免一些性能过低的操作,例如使用 FieldByName() 和MethodByName() 方法,如果必须使用这些方法的时候,我们可以预先通过字段名或者方法名获取到对应的字段序号,然后使用性能较高的反射操作,以此提升使用反射的性能。

以上就是Golang 中反射的应用实例详解的详细内容,更多关于Golang 反射应用的资料请关注云初冀北其它相关文章!

免责声明
本站提供的资源,都来自网络,版权争议与本站无关,所有内容及软件的文章仅限用于学习和研究目的。不得将上述内容用于商业或者非法用途,否则,一切后果请用户自负,我们不保证内容的长久可用性,通过使用本站内容随之而来的风险与本站无关,您必须在下载后的24个小时之内,从您的电脑/手机中彻底删除上述内容。如果您喜欢该程序,请支持正版软件,购买注册,得到更好的正版服务。侵删请致信E-mail:goliszhou@gmail.com
$

发表评论

表情:
评论列表 (暂无评论,64人围观)

还没有评论,来说两句吧...