脚本之家,脚本语言编程技术及教程分享平台!
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - 一文搞懂Go反射的使用方法和应用场景

一文搞懂Go反射的使用方法和应用场景

2021-10-26 22:41网管叨bi叨KevinYan11 Golang

今天来聊一个平时用的不多,但是很多框架或者基础库会用到的语言特性--反射,反射并不是Go语言独有的能力,其他编程语言都有。这篇文章的目标是简单地给大家梳理一下反射的应用场景和使用方法。

一文搞懂Go反射的使用方法和应用场景

今天来聊一个平时用的不多,但是很多框架或者基础库会用到的语言特性--反射,反射并不是Go语言独有的能力,其他编程语言都有。这篇文章的目标是简单地给大家梳理一下反射的应用场景和使用方法。

我们平时写代码能接触到与反射联系比较紧密的一个东西是结构体字段的标签,这个我准备放在后面的文章再梳理。

我准备通过用反射搞一个通用的SQL构造器的例子,带大家掌握反射这个知识点。这个是看了国外一个博主写的例子,觉得思路很好,我又对其进行了改进,让构造器的实现更丰富了些。

本文的思路参考自:https://golangbot.com/reflection/ ,本文内容并非只是对原文的简单翻译,具体看下面的内容吧~!

什么是反射

反射是程序在运行时检查其变量和值并找到它们类型的能力。听起来比较笼统,接下来我通过文章的例子一步步带你认识反射。

为什么需要反射

当学习反射的时候,每个人首先会想到的问题都是 “为什么我们要在运行时检查变量的类型呢,程序里的变量在定义的时候我们不都已经给他们指定好类型了吗?” 确实是这样的,但也并非总是如此,看到这你可能心里会想,大哥,你在说什么呢,em... 还是先写一个简单的程序,解释一下。

  1. package main 
  2.  
  3. import (   
  4.     "fmt" 
  5.  
  6. func main() {   
  7.     i := 10 
  8.     fmt.Printf("%d %T", i, i) 

在上面的程序里, 变量i的类型在编译时是已知的,我们在下一行打印了它的值和类型。

现在让我们理解一下 ”在运行时知道变量的类型的必要“。假设我们要编写一个简单的函数,它将一个结构体作为参数,并使用这个参数创建一个SQL插入语句。

考虑一下下面这个程序:

  1. package main 
  2.  
  3. import (   
  4.     "fmt" 
  5.  
  6. type order struct {   
  7.     ordId      int 
  8.     customerId int 
  9.  
  10. func main() {   
  11.     o := order
  12.         ordId:      1234, 
  13.         customerId: 567, 
  14.     } 
  15.     fmt.Println(o) 

我们需要写一个接收上面定义的结构体o作为参数,返回类似INSERT INTO order VALUES(1234, 567)这样的SQL语句。这个函数定义写来很容易,比如像下面这样。

  1. package main 
  2.  
  3. import (   
  4.     "fmt" 
  5.  
  6. type order struct {   
  7.     ordId      int 
  8.     customerId int 
  9.  
  10. func createQuery(o order) string {   
  11.     i := fmt.Sprintf("INSERT INTO order VALUES(%d, %d)", o.ordId, o.customerId) 
  12.     return i 
  13.  
  14. func main() {   
  15.     o := order
  16.         ordId:      1234, 
  17.         customerId: 567, 
  18.     } 
  19.     fmt.Println(createQuery(o)) 

上面例子的createQuery使用参数o 的ordId和customerId字段创建SQL。

现在让我们将我们的SQL创建函数定义地更抽象些,下面还是用程序附带说明举一个案例,比如我们想泛化我们的SQL创建函数使其适用于任何结构体。

  1. package main 
  2.  
  3. type order struct {   
  4.     ordId      int 
  5.     customerId int 
  6.  
  7. type employee struct {   
  8.     name string 
  9.     id int 
  10.     address string 
  11.     salary int 
  12.     country string 
  13.  
  14. func createQuery(q interface{}) string {   

现在我们的目标是,改造createQuery函数,让它能接受任何结构作为参数并基于结构字段创建INSERT 语句。比如如果传给createQuery的参数不再是order类型的结构体,而是employee类型的结构体时

  1. e := employee { 
  2.        name"Naveen"
  3.        id: 565, 
  4.        address: "Science Park Road, Singapore"
  5.        salary: 90000, 
  6.        country: "Singapore"
  7.    } 

那它应该返回的INSERT语句应该是

  1. INSERT INTO employee (name, id, address, salary, country)  
  2. VALUES("Naveen", 565, "Science Park Road, Singapore", 90000, "Singapore")   

由于createQuery 函数要适用于任何结构体,因此它需要一个 interface{}类型的参数。为了说明问题,简单起见,我们假定createQuery函数只处理包含string 和 int 类型字段的结构体。

编写这个createQuery函数的唯一方法是检查在运行时传递给它的参数的类型,找到它的字段,然后创建SQL。这里就是需要反射发挥用的地方啦。在后续步骤中,我们将学习如何使用Go语言的反射包来实现这一点。

Go语言的反射包

Go语言自带的reflect包实现了在运行时进行反射的功能,这个包可以帮助识别一个interface{}类型变量其底层的具体类型和值。我们的createQuery函数接收到一个interface{}类型的实参后,需要根据这个实参的底层类型和值去创建并返回INSERT语句,这正是反射包的作用所在。

在开始编写我们的通用SQL生成器函数之前,我们需要先了解一下reflect包中我们会用到的几个类型和方法,接下来我们先逐个学习一下。

reflect.Type 和 reflect.Value

经过反射后interface{}类型的变量的底层具体类型由reflect.Type表示,底层值由reflect.Value表示。reflect包里有两个函数reflect.TypeOf() 和reflect.ValueOf() 分别能将interface{}类型的变量转换为reflect.Type和reflect.Value。这两种类型是创建我们的SQL生成器函数的基础。

让我们写一个简单的例子来理解这两种类型。

  1. package main 
  2.  
  3. import (   
  4.     "fmt" 
  5.     "reflect" 
  6.  
  7. type order struct {   
  8.     ordId      int 
  9.     customerId int 
  10.  
  11. func createQuery(q interface{}) {   
  12.     t := reflect.TypeOf(q) 
  13.     v := reflect.ValueOf(q) 
  14.     fmt.Println("Type ", t) 
  15.     fmt.Println("Value ", v) 
  16.  
  17.  
  18. func main() {   
  19.     o := order
  20.         ordId:      456, 
  21.         customerId: 56, 
  22.     } 
  23.     createQuery(o) 
  24.  

上面的程序会输出:

  1. Type  main.order   
  2. Value  {456 56}  

上面的程序里createQuery函数接收一个interface{}类型的实参,然后把实参传给了reflect.Typeof和reflect.Valueof 函数的调用。从输出,我们可以看到程序输出了interface{}类型实参对应的底层具体类型和值。

Go语言反射的三法则

这里插播一下反射的三法则,他们是:

  • 从接口值可以反射出反射对象。
  • 从反射对象可反射出接口值。
  • 要修改反射对象,其值必须可设置。

反射的第一条法则是,我们能够吧Go中的接口类型变量转换成反射对象,上面提到的reflect.TypeOf和 reflect.ValueOf 就是完成的这种转换。第二条指的是我们能把反射类型的变量再转换回到接口类型,最后一条则是与反射值是否可以被更改有关。三法则详细的说明可以去看看德莱文大神写的文章 Go反射的实现原理,文章开头就有对三法则说明的图解,再次膜拜。

下面我们接着继续了解完成我们的SQL生成器需要的反射知识。

reflect.Kind

reflect包中还有一个非常重要的类型,reflect.Kind。

reflect.Kind和reflect.Type类型可能看起来很相似,从命名上也是,Kind和Type在英文的一些Phrase是可以互转使用的,不过在反射这块它们有挺大区别,从下面的程序中可以清楚地看到。

  1. package main 
  2. import (   
  3.     "fmt" 
  4.     "reflect" 
  5.  
  6. type order struct {   
  7.     ordId      int 
  8.     customerId int 
  9.  
  10. func createQuery(q interface{}) {   
  11.     t := reflect.TypeOf(q) 
  12.     k := t.Kind() 
  13.     fmt.Println("Type ", t) 
  14.     fmt.Println("Kind ", k) 
  15.  
  16.  
  17. func main() {   
  18.     o := order
  19.         ordId:      456, 
  20.         customerId: 56, 
  21.     } 
  22.     createQuery(o) 
  23.  

上面的程序会输出

  1. Type  main.order   
  2. Kind  struct   

通过输出让我们清楚了两者之间的区别。reflect.Type 表示接口的实际类型,即本例中main.order 而Kind表示类型的所属的种类,即main.order是一个「struct」类型,类似的类型map[string]string的Kind就该是「map」。

反射获取结构体字段的方法

我们可以通过reflect.StructField类型的方法来获取结构体下字段的类型属性。reflect.StructField可以通过reflect.Type提供的下面两种方式拿到。

  1. // 获取一个结构体内的字段数量 
  2. NumField() int 
  3. // 根据 index 获取结构体内字段的类型对象 
  4. Field(i int) StructField 
  5. // 根据字段名获取结构体内字段的类型对象 
  6. FieldByName(name string) (StructField, bool) 

reflect.structField是一个struct类型,通过它我们又能在反射里知道字段的基本类型、Tag、是否已导出等属性。

  1. type StructField struct { 
  2.  Name string 
  3.  Type      Type      // field type 
  4.  Tag       StructTag // field tag string 
  5.   ...... 

与reflect.Type提供的获取Field信息的方法相对应,reflect.Value也提供了获取Field值的方法。

  1. func (v Value) Field(i int) Value { 
  2. ... 
  3.  
  4. func (v Value) FieldByName(name string) Value { 
  5. ... 

这块需要注意,不然容易迷惑。下面我们尝试一下通过反射拿到order结构体类型的字段名和值

  1. package main 
  2.  
  3. import ( 
  4.  "fmt" 
  5.  "reflect" 
  6.  
  7. type order struct { 
  8.  ordId      int 
  9.  customerId int 
  10.  
  11. func createQuery(q interface{}) { 
  12.  t := reflect.TypeOf(q) 
  13.  if t.Kind() != reflect.Struct { 
  14.   panic("unsupported argument type!"
  15.  } 
  16.  v := reflect.ValueOf(q) 
  17.  for i:=0; i < t.NumField(); i++ { 
  18.   fmt.Println("FieldName:", t.Field(i).Name"FiledType:", t.Field(i).Type, 
  19.    "FiledValue:", v.Field(i)) 
  20.  } 
  21.  
  22. func main() { 
  23.  o := order
  24.   ordId:      456, 
  25.   customerId: 56, 
  26.  } 
  27.  createQuery(o) 
  28.  

上面的程序会输出:

  1. FieldName: ordId FiledType: int FiledValue: 456 
  2. FieldName: customerId FiledType: int FiledValue: 56 

除了获取结构体字段名称和值之外,还能获取结构体字段的Tag,这个放在后面的文章我再总结吧,不然篇幅就太长了。

reflect.Value转换成实际值

现在离完成我们的SQL生成器还差最后一步,即还需要把reflect.Value转换成实际类型的值,reflect.Value实现了一系列Int(), String(),Float()这样的方法来完成其到实际类型值的转换。

用反射搞一个SQL生成器

上面我们已经了解完写这个SQL生成器函数前所有的必备知识点啦,接下来就把他们串起来,加工完成createQuery函数。

这个SQL生成器完整的实现和测试代码如下:

  1. package main 
  2.  
  3. import ( 
  4.  "fmt" 
  5.  "reflect" 
  6.  
  7. type order struct { 
  8.  ordId      int 
  9.  customerId int 
  10.  
  11. type employee struct { 
  12.  name    string 
  13.  id      int 
  14.  address string 
  15.  salary  int 
  16.  country string 
  17.  
  18. func createQuery(q interface{}) string { 
  19.  t := reflect.TypeOf(q) 
  20.  v := reflect.ValueOf(q) 
  21.  if v.Kind() != reflect.Struct { 
  22.   panic("unsupported argument type!"
  23.  } 
  24.  tableName := t.Name() // 通过结构体类型提取出SQL的表名 
  25.  sql := fmt.Sprintf("INSERT INTO %s ", tableName) 
  26.  columns := "(" 
  27.  values := "VALUES (" 
  28.  for i := 0; i < v.NumField(); i++ { 
  29.   // 注意reflect.Value 也实现了NumField,Kind这些方法 
  30.   // 这里的v.Field(i).Kind()等价于t.Field(i).Type.Kind() 
  31.   switch v.Field(i).Kind() { 
  32.   case reflect.Int
  33.    if i == 0 { 
  34.     columns += fmt.Sprintf("%s", t.Field(i).Name
  35.     values += fmt.Sprintf("%d", v.Field(i).Int()) 
  36.    } else { 
  37.     columns += fmt.Sprintf(", %s", t.Field(i).Name
  38.     values += fmt.Sprintf(", %d", v.Field(i).Int()) 
  39.    } 
  40.   case reflect.String: 
  41.    if i == 0 { 
  42.     columns += fmt.Sprintf("%s", t.Field(i).Name
  43.     values += fmt.Sprintf("'%s'", v.Field(i).String()) 
  44.    } else { 
  45.     columns += fmt.Sprintf(", %s", t.Field(i).Name
  46.     values += fmt.Sprintf(", '%s'", v.Field(i).String()) 
  47.    } 
  48.   } 
  49.  } 
  50.  columns += "); " 
  51.  values += "); " 
  52.  sql += columns + values 
  53.  fmt.Println(sql) 
  54.  return sql 
  55.  
  56. func main() { 
  57.  o := order
  58.   ordId:      456, 
  59.   customerId: 56, 
  60.  } 
  61.  createQuery(o) 
  62.  
  63.  e := employee{ 
  64.   name:    "Naveen"
  65.   id:      565, 
  66.   address: "Coimbatore"
  67.   salary:  90000, 
  68.   country: "India"
  69.  } 
  70.  createQuery(e) 

同学们可以把代码拿到本地运行一下,上面的例子会根据传递给函数不同的结构体实参,输出对应的标准SQL插入语句

  1. INSERT INTO order (ordId, customerId); VALUES (456, 56);  
  2. INSERT INTO employee (name, id, address, salary, country); VALUES ('Naveen', 565, 'Coimbatore', 90000, 'India');  

总结

这篇文章通过利用反射完成一个实际应用来教会大家Go语言反射的基本使用方法,虽然反射看起来挺强大,但使用反射编写清晰且可维护的代码非常困难,应尽可能避免,仅在绝对必要时才使用。

我的看法是如果是要写业务代码,根本不需要使用反射,如果要写类似encoding/json,gorm这些样的库倒是可以利用反射的强大功能简化库使用者的编码难度。

原文链接:https://mp.weixin.qq.com/s/0FNClBKYzgheMiAwjOnKyA

延伸 · 阅读

精彩推荐
  • Golanggolang的httpserver优雅重启方法详解

    golang的httpserver优雅重启方法详解

    这篇文章主要给大家介绍了关于golang的httpserver优雅重启的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,...

    helight2992020-05-14
  • Golanggo语言制作端口扫描器

    go语言制作端口扫描器

    本文给大家分享的是使用go语言编写的TCP端口扫描器,可以选择IP范围,扫描的端口,以及多线程,有需要的小伙伴可以参考下。 ...

    脚本之家3642020-04-25
  • GolangGolang通脉之数据类型详情

    Golang通脉之数据类型详情

    这篇文章主要介绍了Golang通脉之数据类型,在编程语言中标识符就是定义的具有某种意义的词,比如变量名、常量名、函数名等等,Go语言中标识符允许由...

    4272021-11-24
  • Golanggolang json.Marshal 特殊html字符被转义的解决方法

    golang json.Marshal 特殊html字符被转义的解决方法

    今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧 ...

    李浩的life12792020-05-27
  • GolangGolang中Bit数组的实现方式

    Golang中Bit数组的实现方式

    这篇文章主要介绍了Golang中Bit数组的实现方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...

    天易独尊11682021-06-09
  • Golanggolang 通过ssh代理连接mysql的操作

    golang 通过ssh代理连接mysql的操作

    这篇文章主要介绍了golang 通过ssh代理连接mysql的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...

    a165861639710342021-03-08
  • Golanggolang如何使用struct的tag属性的详细介绍

    golang如何使用struct的tag属性的详细介绍

    这篇文章主要介绍了golang如何使用struct的tag属性的详细介绍,从例子说起,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看...

    Go语言中文网11352020-05-21
  • Golanggo日志系统logrus显示文件和行号的操作

    go日志系统logrus显示文件和行号的操作

    这篇文章主要介绍了go日志系统logrus显示文件和行号的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...

    SmallQinYan12302021-02-02