温馨提示×

温馨提示×

您好，登录后才能下订单哦！

密码登录×
登录注册×
获取短信验证码
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》
登 录 注册有礼
云服务器 香港服务器 高防服务器
最新更新 网站标签 地图导航
产品

Golang中反射怎么应用

发布时间：2022-08-26 10:12:01 来源：亿速云 阅读：142 作者：iii 栏目：开发技术

本文小编为大家详细介绍“Golang中反射怎么应用”，内容详细，步骤清晰，细节处理妥当，希望这篇“Golang中反射怎么应用”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。

    引言

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

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

    读到这里，这篇“Golang中反射怎么应用”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注亿速云行业资讯频道。

    向AI问一下细节
    推荐阅读：
    1. golang中的反射
    2. 反射的应用

    免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。

    golang

    猜你喜欢

    最新资讯
    相关推荐

    相关标签

    golang.org golang框架 golang语言 c++ api bit数组 centos7 android base bash centos array byte base64 art 30个 append age cap channel
    AI
    助
    手
    产品服务
    地区划分
    专题活动
    帮助支持
    关于我们
    售后咨询
    7*24小时在线电话：400-100-2938
    7*24小时在线 QQ：800811969
    关注亿速云

    亿速云公众号

    手机网站二维码

    Copyright © Yisu Cloud Ltd. All Rights Reserved. 2018 版权所有

    广州亿速云计算有限公司粤ICP备17096448号-1 粤公网安备 44010402001142号增值电信业务经营许可证编号：B1-20181529