Go语言学习之6 反射详解

1.反射：    

       定义： 反射就是程序能够在运行时检查变量和值，求出它们的类型。
                   可以在运行时动态获取变量的相关信息
                   Import ("reflect")

       为什么需要反射？
       想象下：如果程序中每个变量都是我们自己定义的，那么在编译时就可以知道变量类型了，但是实际中并非如此，就需要我们在运行时检查变量，求出它的类型。这就需要用到反射。

       在 Go 语言中，reflect 实现了运行时反射。reflect 包会帮助识别 interface{} 变量的底层具体类型和具体值。

几个函数：
a. reflect.TypeOf(val)，获取变量的类型，返回reflect.Type类型
b. reflect.ValueOf(val)，获取变量的值，返回reflect.Value类型
c. reflect.Value.Kind()，获取变量的类别，返回一个常量
d. reflect.Value.Interface()，转换成interface{}类型

       变量接口及获取变量值之间的转换：

       

package main

import (
    "fmt"
    "reflect"
)

type Student struct {
    Name  string
    Age   int
    Score float32
}

func test(b interface{}) {
    t := reflect.TypeOf(b)
    fmt.Println("t: ", t)  //t:  main.Student

    v := reflect.ValueOf(b)  
    fmt.Println("v: ", v)  //v:  {stu01 18 92}

    k := v.Kind()
    fmt.Println("k: ", k)  //k:  struct

    iv := v.Interface()
    fmt.Println("iv: ", iv)  //iv:  {stu01 18 92}
    stu, ok := iv.(Student)
    if ok {
        fmt.Printf("%v %T
", stu, stu)  //{stu01 18 92} main.Student
    }
}

func main() {
    var a Student = Student{
        Name:  "stu01",
        Age:   18,
        Score: 92,
    }
    test(a)
}

package main

import (
    "fmt"
    "reflect"
)

func main() {

    var x float64 = 3.4
    fmt.Println("type:", reflect.TypeOf(x))  //type: float64
    v := reflect.ValueOf(x)
    fmt.Printf("value:%v, type:%T
", v, v)  //value:3.4, type: reflect.Valuetype 
    fmt.Println("type:", v.Type())  //type: float64
    fmt.Println("kind:", v.Kind())  //kind: float64
    fmt.Println("value:", v.Float())  //value: 3.4

    fmt.Println(v.Interface())  //3.4
    fmt.Printf("value is %5.2e
", v.Interface())  //value is 3.40e+00
    y := v.Interface().(float64)  //v -> Interface -> float64 -> y
    fmt.Println(y)  //3.4
}

2. reflect.Value.Kind()方法返回的常量

const (
    Invalid Kind = iota
    Bool
    Int
    Int8
    Int16
    Int32
    Int64
    Uint
    Uint8
    Uint16
    Uint32
    Uint64
    Uintptr
    Float32
    Float64
    Complex64
    Complex128
    Array
    Chan
    Func
    Interface
    Map
    Ptr
    Slice
    String
    Struct
    UnsafePointer
) 

3. 获取变量的值：

reflect.ValueOf(x).Float() 
reflect.ValueOf(x).Int()
reflect.ValueOf(x).String()
reflect.ValueOf(x).Bool()

4. 通过反射的来改变变量的值
    reflect.Value.SetXX相关方法，比如:

reflect.Value.SetFloat()，设置浮点数
reflect.Value.SetInt()，设置整数
reflect.Value.SetString()，设置字符串

练习：（panic: reflect: reflect.Value.SetFloat using unaddressable value）

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var a float64
    fv := reflect.ValueOf(a)
    fv.SetFloat(3.3)
    fmt.Printf("%v
", a)
}

崩溃的原因：还是值类型和引用类型的原因。v := reflect.ValueOf(x) ，v是x的一个拷贝，修改v，x不会修改!

解决方法：传地址！

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var a float64 = 1.0

    fv := reflect.ValueOf(&a)
    fv.Elem().SetFloat(3.3)   //相当于var *fv float64;  *fv = 3.3
    fmt.Printf("%v
", a) //3.3
}

其中fv.Elem().Setxx用来获取指针指向的变量，相当于：
       var a *int;
       *a = 100

5. 用反射操作结构体
    a. reflect.Value.NumField() 获取结构体中字段的个数
    b. reflect.Value.Method(n).Call 来调用结构体中的方法

func (Value) Call
func (v Value) Call(in []Value) []Value
Call calls the function v with the input arguments in. For example, if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]). Call panics if v's Kind is not Func. It returns the output results as Values. As in Go, each input argument must be assignable to the type of the function's corresponding input parameter. If v is a variadic function, Call creates the variadic slice parameter itself, copying in the corresponding values.

func (Value) Elem
func (v Value) Elem() Value
Elem returns the value that the interface v contains or that the pointer v points to. It panics if v's Kind is not Interface or Ptr. It returns the zero Value if v is nil.

func (Value) NumField
func (v Value) NumField() int
NumField returns the number of fields in the struct v. It panics if v's Kind is not Struct.

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

type Student struct {
    Name  string `json:"student_name"`
    Age   int
    Score float32
    Sex   string
}

func (s Student) Print() {
    fmt.Println("---start----")
    fmt.Println(s)
    fmt.Println("---end----")
}

func (s Student) Set(name string, age int, score float32, sex string) {
    s.Name = name
    s.Age = age
    s.Score = score
    s.Sex = sex
    fmt.Println("set -----------")
}

func TestStruct(a interface{}) {
    tye := reflect.TypeOf(a)
    val := reflect.ValueOf(a)
    kd := val.Kind()
    // fmt.Println(tye, val, kd, val.Elem().Kind()) //*main.Student &{stu01 18 92.8 } ptr struct

    if kd != reflect.Ptr && val.Elem().Kind() == reflect.Struct {
        fmt.Println("expect struct")
        return
    }

    num := val.Elem().NumField()  //获取val
    val.Elem().Field(0).SetString("stu1000")
    for i := 0; i < num; i++ {
        fmt.Printf("%d %v
", i, val.Elem().Field(i).Kind())
    }

    fmt.Printf("struct has %d fields
", num)

    tag := tye.Elem().Field(0).Tag.Get("json")
    fmt.Printf("tag=%s
", tag)  //tag=student_name

    numOfMethod := val.Elem().NumMethod()  //2
    fmt.Printf("struct has %d methods
", numOfMethod)
    var params []reflect.Value
    val.Elem().Method(0).Call(params)
}

func main() {
    var a Student = Student{
        Name:  "stu01",
        Age:   18,
        Score: 92.8,
    }

    result, _ := json.Marshal(a)
    fmt.Println("json result:", string(result))

    TestStruct(&a)
    fmt.Println(a)
}

6. 反射中调用函数

Go中的函数是可以像普通的 int、float 等类型变量那样作为值的。例如：

package main
 
import "fmt"
 
func Print() {
    fmt.Println("Hello world!")
}
 
func main() {
    f := Print
    f()
}

和函数作为变量类似，在反射中函数和方法的类型（Type）都是 reflect.Func，如果要调用函数的话，可以通过 Value的Call()方法。

package main
 
import (
    "fmt"
    "reflect"
)

func Print() {
    fmt.Println("Hello world!")
}
 
func main() {
    f := Print
    fv := reflect.ValueOf(f)
    fmt.Println("fv is reflect.Func? ", fv.Kind() == reflect.Func)  //fv is reflect.Func?  true
    fv.Call(nil)  //Hello world!
}

Call函数的定义：func (v Value) Call(in []Value) []Value
Value 的 Call() 方法的参数是一个 Value 的 slice，对应的反射函数类型的参数，返回值也是一个 Value 的 slice，同样对应反射函数类型的返回值。

package main
 
import (
    "fmt"
    "reflect"
)

func Print(str string) string {
    str = fmt.Sprintf("hello %s", str)
    return str
}
 
func main() {
    fv := reflect.ValueOf(Print)
    params := make([]reflect.Value, 1)                 // 传给Print的参数
    params[0] = reflect.ValueOf("zhangsan")            // 参数设置为"zhangsan"
    rs := fv.Call(params)                              // rs作为结果接受函数的返回值
    //result: hello zhangsan
    fmt.Println("result:", rs[0].Interface().(string)) // rs[0].Interface() ok
}

7. 反射中调用方法

函数和方法可以说其实本质上是相同的，只不过方法与一个“对象”进行了“绑定”，方法是“对象”的一种行为，这种行为是对于这个“对象”的一系列操作，例如修改“对象”的某个属性。

package main
 
import (
    "fmt"
    "reflect"
)

type Student struct {
    Name string
    Age int
}

func (s *Student) SetName(name string) {
    s.Name = name
}

func (s *Student) SetAge(age int) {
    s.Age = age
}

func (s *Student) Print() string {
    str := fmt.Sprintf("%s is %d years old.", s.Name, s.Age)
    return str
}
 
func main() {
    stu := &Student {
        Name:"zhangsan",
        Age:20,
    }

    ref := reflect.ValueOf(stu) 
    fmt.Println("Before:", ref.MethodByName("Print").Call(nil)[0]) //Before: zhangsan is 20 years old.

    
    params := make([]reflect.Value, 1)

    params[0] = reflect.ValueOf("lisi")
    ref.MethodByName("SetName").Call(params)
    fmt.Println(stu)  //&{lisi 20}

    params[0] = reflect.ValueOf(22)
    ref.MethodByName("SetAge").Call(params)

    fmt.Println(stu)  //&{lisi 22}
    fmt.Println("After:", ref.MethodByName("Print").Call(nil)[0])  //After: lisi is 22 years old.
}

练习1：

package main

import (
    "fmt"
    "reflect"
)

type NotknownType struct {
    s1 string
    s2 string
    s3 string
}

func (n NotknownType) String() string {
    return n.s1 + "-" + n.s2 + "-" + n.s3
}

var secret interface{} = NotknownType{"Ada", "Go", "Oberon"}

func main() {
    value := reflect.ValueOf(secret) 
    typ := reflect.TypeOf(secret)    
    fmt.Println(typ)  // Main.NotknownType

    knd := value.Kind()
    fmt.Println(knd) // struct
    
    for i := 0; i < value.NumField(); i++ {
        fmt.Printf("Field %d: %v
", i, value.Field(i))
        //value.Field(i).SetString("C#")
    }
    
    results := value.Method(0).Call(nil)
    fmt.Println(results) // [Ada - Go - Oberon]
}

练习2：通过反射操作结构体

package main

import (
    "fmt"
    "reflect"
)

type NotknownType struct {
    s1 string
    s2 string
    s3 string
}

func (n NotknownType) String() string {
    return n.s1 + "-" + n.s2 + "-" + n.s3
}

var secret interface{} = NotknownType{"Ada", "Go", "Oberon"}

func main() {
    value := reflect.ValueOf(secret) 
    typ := reflect.TypeOf(secret)    
    fmt.Println(typ)  // Main.NotknownType

    knd := value.Kind()
    fmt.Println(knd) // struct
    
    for i := 0; i < value.NumField(); i++ {
        fmt.Printf("Field %d: %v
", i, value.Field(i))
        //value.Field(i).SetString("C#")
    }
    
    results := value.Method(0).Call(nil)
    fmt.Println(results) // [Ada - Go - Oberon]
}

练习3：通过反射修改结构体

package main

import (
    "fmt"
    "reflect"
)

type T struct {
    A int
    B string
}

func main() {
    t := T{23, "skidoo"}
    s := reflect.ValueOf(&t).Elem()
    typeOfT := s.Type() //main.T
    for i := 0; i < s.NumField(); i++ {
        f := s.Field(i)
        fmt.Printf("%d: %s %s = %v
", i,
            typeOfT.Field(i).Name, f.Type(), f.Interface())
    }
    s.Field(0).SetInt(77)
    s.Field(1).SetString("Sunset Strip")
    fmt.Println("t is now", t) //t is now {77 Sunset Strip}
}

建议：反射是 Go 语言中非常强大和高级的概念，我们应该小心谨慎地使用它。使用反射编写清晰和可维护的代码是十分困难的。你应该尽可能避免使用它，只在必须用到它时，才使用反射。

图书管理系统v2版本开发：

     实现一个图书管理系统v2，具有以下功能：
     a. 增加用户登录、注册功能
     b. 增加借书过期的图书界面
     c. 增加显示热门图书的功能，被借次数最多的top10
     d. 增加查看某个人的借书记录的功能

参考文献：

• https://studygolang.com/articles/13178 （Go 系列教程 - 反射）
• https://golang.org/pkg/reflect/
• https://www.cnblogs.com/52php/p/6337420.html