2. 程式人生 > >GO語言使用之Reflect(反射)

GO語言使用之Reflect(反射)

阿新 • • 發佈：2018-11-01

一、從案列場景引入反射

定義了兩個函式test1和test2，定義一個介面卡函式用作統一處理介面：
(1) 定義了兩個函式

test1 := func(v1 int, v2 int) {
    t.Log(v1, v2)
}
test2 := func(v1 int, v2 int, s string) {
    t.Log(v1, v2, s)
}

(2) 定義一個介面卡函式用作統一處理介面, 其大致結構如下:

bridge := func(call interface{}, args ...interface{}) {
 //內容       
}
//實現呼叫test1對應的函式
 

bridge(test1, 1, 2) 
//實現呼叫test2對應的函式
bridge(test2, 1, 2, "test2")

(3) 要求使用反射機制完成 

package test
import (
    "testing"
     "reflect"       
)
/*反射的最佳實踐*/


/*
3) 定義了兩個函式test1和test2，定義一個介面卡函式用作統一處理介面【瞭解】：
(1) 定義了兩個函式
test1 := func(v1 int, v2 int) {
    t.Log(v1, v2)
}
test2 := func(v1 int, v2 int, s string) {
    t.Log(v1, v2, s)
}
(2) 定義一個介面卡函式用作統一處理介面, 其大致結構如下:
bridge := func(call interface{}, args ...interface{}) {
 //內容       
}
//實現呼叫test1對應的函式
bridge(test1, 1, 2) 
//實現呼叫test2對應的函式
bridge(test2, 1, 2, "test2")

(3) 要求使用反射機制完成 
*/
 
  


func TestReflectFunc(t *testing.T) {
    call1 := func(v1 int, v2 int) {
        t.Log(v1, v2)
    }
    call2 := func(v1 int, v2 int, s string) {
        t.Log(v1, v2, s)
    }
    var (
        function reflect.Value
        inValue  []reflect.Value
        n        int
    )
    bridge := func
 
(call interface{}, args ...interface{}) {
        n = len(args)
        inValue = make([]reflect.Value, n)
        for i := 0; i < n; i++ {
            inValue[i] = reflect.ValueOf(args[i])
        }
        function = reflect.ValueOf(call)
        function.Call(inValue)
    }
    bridge(call1, 1, 2)
    bridge(call2, 1, 2, "test2")
}

二、反射的基本介紹

1、反射可以在執行時動態獲取變數的各種資訊, 比如變數的型別(type)，類別(kind)
2、 如果是結構體變數，還可以獲取到結構體本身的資訊(包括結構體的欄位、方法)
3、通過反射，可以修改變數的值，可以呼叫關聯的方法。
4、使用反射，需要 import (“reflect”)
5、 示意圖

這裡寫圖片描述

三、反射的應用場景

1、反射常見應用場景有以下兩種
不知道介面呼叫哪個函式，根據傳入引數在執行時確定呼叫的具體介面，這種需要對函式或方法反射。例如以下這種橋接模式, 比如我前面提出問題。

第一個引數funcPtr以介面的形式傳入函式指標，函式引數args以可變引數的形式傳入，bridge函式中可以用反射來動態執行funcPtr函式
2、對結構體序列化時，如果結構體有指定Tag, 也會使用到反射生成對應的字串。
這裡寫圖片描述

四、反射重要的函式和概念

1、reflect.TypeOf(變數名)，獲取變數的型別，返回reflect.Type型別
2、reflect.ValueOf(變數名)，獲取變數的值，返回reflect.Value型別reflect.Value 是一個結構體型別。【看文件】, 通過reflect.Value，可以獲取到關於該變數的很多資訊
3、變數、interface{} 和 reflect.Value是可以相互轉換的，這點在實際開發中，會經常使用到。

變數 interface{} 和reflect.Value()是可以相互轉換的，
變數 interface{} 和valueOf()之間的轉換
這裡寫圖片描述
這裡寫圖片描述

五、快速入門的案例

反射普通變數和結構體

//反射操作方法-基本資料型別float64
func reflectOper(b interface{})  {
    //通過反射獲取的傳入的變數的 type , kind, 值
    //1. 先獲取到 reflect.Type
    rTye := reflect.TypeOf(b)
    fmt.Println("rtype=",rTye)
    rKind := rTye.Kind()
    fmt.Println("rKind=",rKind)
    //2. 獲取到 reflect.Value
    rVal := reflect.ValueOf(b)
    fmt.Println("rVal=",rVal)
    // 將 reflect.Value 轉成 interface{}
    iV := rVal.Interface()
    fmt.Println("iV=",iV)
    //將 interface{} 通過斷言轉成需要的型別
    num := iV.(float64)
    fmt.Println("num=",num)
}

type Student struct{
    Name string
    Age int

}

//反射操作方法-結構體
func reflectOPerStruct(b interface{})  {
    //通過反射獲取的傳入的變數的 type , kind, 值
    //1. 先獲取到 reflect.Type
    rTyp := reflect.TypeOf(b)
    fmt.Println("rType=", rTyp)

    //2. 獲取到 reflect.Value
    rVal := reflect.ValueOf(b)

    fmt.Println("rVal=", rVal)

    //下面我們將 rVal 轉成 interface{}
    iV := rVal.Interface()
    fmt.Printf("iv=%v iv type=%T \n", iV, iV)
    //將 interface{} 通過斷言轉成需要的型別

    stu, ok := iV.(Student)
    if ok {
        fmt.Printf("stu.Name=%v\n", stu.Name)
    }

}

func RefelctDemo(){
    // var num float64 = 12.0
    // reflectOper(num)//對普通變數進行反射
    stu :=Student{
        Name : "張三",
        Age : 30,
    }
    reflectOPerStruct(stu)//對結構體進行反射
}

測試結果：

e:\GoProject\src\go_code\grammar\reflect\code\main>go run main.go
rType= utils.Student
rVal= {張三 30}
iv={張三 30} iv type=utils.Student
stu.Name=張三

e:\GoProject\src\go_code\grammar\reflect\code\main>

六、 使用細節和注意事項

1、reflect.Value.Kind，獲取變數的類別，返回的是一個常量
這裡寫圖片描述
2、Type 和 Kind 的區別
Type是型別, Kind是類別， Type 和 Kind 可能是相同的，也可能是不同的.
比如: var num int = 10 num的Type是int , Kind也是int
比如: var stu Student stu的Type是 pkg1.Student , Kind是struct
3、通過反射可以在讓變數在 interface{} 和Reflect.Value 之間相互轉換,

4、使用反射的方式來獲取變數的值(並返回對應的型別)，要求資料型別匹配，比如x是int, 那麼就應該使用 reflect.Value(x).Int(), 而不能使用其它的，否則報panic。
這裡寫圖片描述
這裡寫圖片描述
5、通過反射的來修改變數, 注意當使用SetXxx方法來設定需要通過對應的指標型別來完成, 這樣才能改變傳入的變數的值, 同時需要使用到reflect.Value.Elem()方法
這裡寫圖片描述
這裡寫圖片描述
這裡寫圖片描述
七、反射最佳實踐
1、使用反射來遍歷結構體的欄位，呼叫結構體的方法，並獲取結構體標籤的值

import (
    "reflect"
    "fmt"
)

/*反射的最佳實踐*/
// 1、使用反射來遍歷結構體的欄位，呼叫結構體的方法，並獲取結構體標籤的值
/*
分析：
1、結構體 有四個欄位 Name Age   Score Sex  
2、宣告結構體方法 GetSum  Set Print()
3、TestStruct 處理結構體方法和欄位
4、main方法呼叫
*/

type Monster struct{
    Name string `json:"name"`
    Age int      `json:"age"`
    Score float64 `json:"score"`
    Sex string 

}

func (m Monster)Print()  {
    fmt.Println("---start~----")
    fmt.Println(m)
    fmt.Println("---end~----")
}

func (m Monster)GetSum(n1, n2 int) int {
    return n1 + n2
}

func (m Monster)Set(name string, age int, score float64, sex string) Monster {
    m.Name = name
    m.Age = age
    m.Score = score
    m.Sex = sex

    return m
}

func StructOpera(i interface{})  {
    //獲取reflect.Type 型別
    rType := reflect.TypeOf(i)
    //獲取reflect.Value 型別
    rValue := reflect.ValueOf(i)
    //獲取到a對應的類別
    rKind := rValue.Kind()
    //如果傳入的不是struct，就退出
    if rKind != reflect.Struct {
        fmt.Println("expect struct")
        return
    }

    //獲取到該結構體有幾個欄位
    numField := rValue.NumField()

    //變數結構體的所有欄位

    for i := 0; i < numField; i++ {
        fmt.Printf("Field %d: 值為=%v\n", i, rValue.Field(i))
        //獲取到struct標籤, 注意需要通過reflect.Type來獲取tag標籤的值
        tagVal := rType.Field(i).Tag.Get("json")
        //如果該欄位是tag標籤就顯示，否則就不顯示
        if tagVal !="" {
            fmt.Printf("Field %d: tag為=%v\n", i, tagVal)
        }
    }



    //獲取到該結構體有多少個方法
    numMethod := rValue.NumMethod()
    fmt.Printf("struct has %d methods\n", numMethod)


    //方法的排序預設是按照 函式名的排序（ASCII碼）
    rValue.Method(1).Call(nil) //獲取到第二個方法。呼叫它

    //呼叫結構體的第1個方法Method(0)
    //聲明瞭 []reflect.Value
    var params []reflect.Value

    params = append(params,reflect.ValueOf(10))
    params = append(params,reflect.ValueOf(20))

    res := rValue.Method(0).Call(params)//傳入的引數是 []reflect.Value, 返回[]reflect.Value 
    fmt.Println("res=", res[0].Int()) //返回結果, 返回的結果是 []reflect.Value*/

    var params1 []reflect.Value

    params1 = append(params1,reflect.ValueOf("狐狸精"))
    params1 = append(params1,reflect.ValueOf(500))
    params1 = append(params1,reflect.ValueOf(60.0))
    params1 = append(params1,reflect.ValueOf("女"))

    res1 := rValue.Method(2).Call(params1)//傳入的引數是 []reflect.Value, 返回[]reflect.Value 
    fmt.Println("res=", res1[0])

}

func StructOperaDemo()  {
    //建立了一個Monster例項
    var m Monster = Monster{
        Name:  "黃鼠狼精",
        Age:   400,
        Score: 30.8,
    }
    //將Monster例項傳遞給StructOpera函式
    StructOpera(m)  
    fmt.Println("m=",m)
}

測試結果：

Field 0: 值為=黃鼠狼精
Field 0: tag為=name
Field 1: 值為=400
Field 1: tag為=age
Field 2: 值為=30.8
Field 2: tag為=score
Field 3: 值為=
struct has 3 methods
---start~----
{黃鼠狼精 400 30.8 }
---end~----
res= 30
res= {狐狸精 500 60 女}
m= {黃鼠狼精 400 30.8 }

2、使用反射的方式來獲取結構體的tag標籤, 遍歷欄位的值，修改欄位值，呼叫結構體方法(要求：通過傳遞地址的方式完成, 在前面案例上修改即可)

package test


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

/*反射的最佳實踐*/


// 3、使用反射的方式來獲取結構體的tag標籤, 遍歷欄位的值，修改欄位值，呼叫結構體方法
// (要求：通過傳遞地址的方式完成, 在前面案例上修改即可)
type Monster struct {
    Name  string `json:"monster_name"`
    Age   int
    Score float32
    Sex   string
}

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



func TestStruct(a interface{}) {
    tye := reflect.TypeOf(a)
    val := reflect.ValueOf(a)
    kd := val.Kind()
    if kd != reflect.Ptr && val.Elem().Kind() == reflect.Struct {
        fmt.Println("expect struct")
        return
    }

    num := val.Elem().NumField()
    val.Elem().Field(0).SetString("白象精")
    for i := 0; i < num; i++ {
        fmt.Printf("%d %v\n", i, val.Elem().Field(i).Kind())
    }

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

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

    numOfMethod := val.Elem().NumMethod()
    fmt.Printf("struct has %d methods\n", numOfMethod)

    val.Elem().Method(0).Call(nil)
}

func StructOperaDemo2() {
    var a Monster = Monster{
        Name:  "黃獅子",
        Age:   408,
        Score: 92.8,
    }

    //先說明一下，Marshal就是通過反射獲取到struct的tag值的...
    result, _ := json.Marshal(a)
    fmt.Println("json result:", string(result))

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

測試結果：

json result: {"monster_name":"黃獅子","Age":408,"Score":92.8,"Sex":""}
0 string
1 int
2 float32
3 string
struct has 4 fields
tag=monster_name
struct has 1 methods
---start----
{白象精 408 92.8 }
---end----
{白象精 408 92.8 }

3、使用反射操作任意結構體型別：【瞭解】

package test
import (
    "reflect"
    "testing"
)
/*反射的最佳實踐*/
// 5、使用反射操作任意結構體型別：【瞭解】
type user struct {
    UserId string
    Name string

} 

func TestReflectStruct(t *testing.T) {
    var (
        model *user
        sv    reflect.Value
    )
    model = &user{}
    sv = reflect.ValueOf(model)
    t.Log("reflect.ValueOf", sv.Kind().String())
    sv = sv.Elem()
    t.Log("reflect.ValueOf.Elem", sv.Kind().String())
    sv.FieldByName("UserId").SetString("12345678")
    sv.FieldByName("Name").SetString("nickname")
    t.Log("model", model)
}

4、使用反射建立並操作結構體

package test

import (
    "testing"
    "reflect"
)

/*反射的最佳實踐*/
// 6、使用反射建立並操作結構體
type User struct {
    UserId string
    Name string
} 
func TestReflectStructPtr(t *testing.T) {
    var (
        model *User 
        st    reflect.Type
        elem  reflect.Value
    )
    st = reflect.TypeOf(model) //獲取型別 *user
    t.Log("reflect.TypeOf", st.Kind().String()) // ptr
    st = st.Elem() //st指向的型別
    t.Log("reflect.TypeOf.Elem", st.Kind().String()) //struct
    elem = reflect.New(st) //New返回一個Value型別值，該值持有一個指向型別為typ的新申請的零值的指標
    t.Log("reflect.New", elem.Kind().String()) // ptr
    t.Log("reflect.New.Elem", elem.Elem().Kind().String()) //struct
    //model就是建立的user結構體變數(例項)
    model = elem.Interface().(*User) //model 是 *user 它的指向和elem是一樣的.
    elem = elem.Elem() //取得elem指向的值
    elem.FieldByName("UserId").SetString("12345678") //賦值..
    elem.FieldByName("Name").SetString("nickname")
    t.Log("model model.Name", model, model.Name)
}

相關推薦

GO語言使用之Reflect(反射)

一、從案列場景引入反射 定義了兩個函式test1和test2，定義一個介面卡函式用作統一處理介面： (1) 定義了兩個函式 test1 := func(v1 int, v2 int) { t.Log(v1, v2) } test2 := func(v1 int, v2

Go語言中的反射機制reflect

Go語言中的反射機制reflect Go語言反射機制 Go語言reflect go的反射機制是要通過接口來進行的，而類似於Java的Object的空接口可以和任何類型進行交互，因此對基本數據類型等的反射也直接利用了這一特點。 package main import ( "fmt"

Go語言之反射（一）

反射 反射是指在程式執行期對程式本身進行訪問和修改的能力。程式在編譯時，變數被轉換為記憶體地址，變數名不會被編譯器寫入到可執行部分。在執行程式時，程式無法獲取自身的資訊。支援反射的語言可以在程式編譯期將變數的反射資訊，如欄位名稱、型別資訊、結構體資訊等整合到可執行檔案中，並給程式提供介面訪問反射資訊，這樣就

Go語言之反射

lec mon \n otto switch set 接口 app solid 變量與反射 1.變量的內在機制 A.類型信息,這部分是元信息,是預先定義好的,比如 1: var arr [10]int 2: arr[0] = 10 3: arr[1] = 20

Go語言之嵌入類型

go 類型 嵌入類型，或者嵌套類型，這是一種可以把已有的類型聲明在新的類型裏的一種方式，這種功能對代碼復用非常重要。在其他語言中，有繼承可以做同樣的事情，但是在Go語言中，沒有繼承的概念。Go提倡的代碼復用的方式是組合，所以這也是嵌入類型的意義所在。組合而不是繼承，所以Go才會更靈活。type Rea

Go語言之標誌符可見性

goGo的標誌符，這個翻譯覺得怪怪的，不過還是按這個起了標題，可以理解為Go的變量、類型、字段等。這裏的可見性，也就是說那些方法、函數、類型或者變量字段的可見性。比如哪些方法不想讓另外一個包訪問，我們就可以把它們聲明為非公開的；如果需要被另外一個包訪問，就可以聲明為公開的，和Java語言裏的作用域類似。在Go

Go語言之Doc 文檔

go doc 對於協作開發或者代碼共享來說，文檔是一個可以幫助開發者快速了解以及使用這些代碼的一個教程，文檔越全面、越詳細，入門越快，效率也會更高。在Go語言中，Go為我們提供了快速生成文檔以及查看文檔的工具，讓我們可以很容易地編寫查看文檔。Go提供了兩種查看文檔的方式：一種是使用go doc命令在終

Go語言之並發資源競爭

go 並發 並發本身並不復雜，但是因為有了資源競爭的問題，就使得我們開發出好的並發程序變得復雜起來，因為會引起很多莫名其妙的問題。package main import ( "fmt" "runtime" "sync" ) var ( count int32

Go語言之並發示例-Pool(一)

go pool 並發 這篇文章演示使用有緩沖的通道實現一個資源池，這個資源池可以管理在任意多個goroutine之間共享的資源，比如網絡連接、數據庫連接等，我們在數據庫操作的時候，比較常見的就是數據連接池，也可以基於我們實現的資源池來實現。可以看出，資源池也是一種非常流暢性的模式，這種模式一般適用

Go語言之log日誌

log go 在我們開發程序後，如果有一些問題需要對程序進行調試的時候，日誌是必不可少的，這是我們分析程序問題常用的手段。 日誌使用 日誌分析，就是根據輸出的日誌信息，分析挖掘可能的問題，我們使用fmt.Println系列函數也可以達到目的，因為它們也可以把我們需要的信息輸出到終端或者其他文件中。不過

go語言之指針

ptr數組 Arrays數組是內置(build-in)類型,是一組同類型數據的集合，它是值類型，通過從0開始的下標索引訪問元素值。在初始化後長度是固定的，無法修改其長度。當作為方法的入參傳入時將復制一份數組而不是引用同一指針。數組的長度也是其類型的一部分，通過內置函數len(array)獲取其長度。在開始前先

Go語言之調試

調試 go 調試是一種技能，不限於我們說的debug，這只是其中的一種，這是可以打斷點的調試，除此之外，還有打印輸出、日誌記錄、單元測試，這都可以稱之為調試程序的手段。打印輸出打印輸出是一種比較傳統的調試手段，我們可以把我們需要了解的變量值，執行的步驟等打印出來，來證明我們的猜測，以便解決問題。fun

Go語言之數據類型總結

go語言 數據 數據類型字符串：字符串是不可變的字節序列，本身就是一個復合結構。頭部指針指向字節數組，但是沒有NULL結尾。默認以UTF-8編碼存儲Unicode字符，字面量裏允許使用十六進制、八進制和UTF-8編碼格式。內置函數len返回字節數組長度，cap不接受字符串類型參數。字符串默認是nil而不是&

Go語言之方法詳解

go語言 方法方法是與對象實例綁定的特殊函數。用於維護和展示對象自身的狀態。對象是內斂的。普通函數則專註與算法流程，通過接受參數來完成特定的邏輯運算，並返回最終結果，方法是有關聯狀態的，函數通常是沒有的。方法和函數定義語法區別在於前者實例接受參數，編譯器以此確定方法所屬的類型。在一些語言中盡管沒有定義，但是函

Go語言之項目的包結構詳解

go語言 包結構Go語言的工作空間：通常添加到GOPATH中。 src bin pkg對於bin和pkg兩個目錄，主要影響go install/get命令，它們會將編譯結果安裝到這兩個目錄下，以實現增量編譯。環境變量用於實現GOPATH只是工具鏈和標準庫的存放位置。在使用Git等版本控制工具的時候，建議忽略

Go語言之常量與運算符

常量 運算符 用例1 //此文件用來練習 //常量與運算符的 package main import "fmt" //定義單個常量 const SPARK_NAME = "spark-test001" const NODE_NUM int = 3 //下面的方式，只是簡寫 const (

Go語言之切片Slice練習

切片slice切片Slice理論知識 其本身並不是數組，它指向底層的數組 作為編程數組的替代方案，可以關聯底層數組的局部或者全部 為引用類型 可以直接創建或從底層數組獲取生成 使用len()獲取元素個數，cap()獲取容量 一般使用make()創建 如果多個slice指向相同底層數組，其中一個的值改變會影響

Go語言之map練習

mapmap理論基礎知識 類似其他語言中的哈希表或者字典，以key-value形式存儲數據 key必須是支持== 或者 != 比較運算的類型，不可以是函數，map或者slice map查找比線性搜索快很多，但比使用索引訪問數據的類型慢100倍 map使用make()創建，支持:=這種簡寫方式 make(

Go語言之method

method方法method Go 中雖沒有class, 但依舊有method 通過顯示說明receiver來實現與某個類型的組合 只能為同一個包中的類型定義方法 receiver可以是類型的值或指針 不存在方法重載 可以使用值或者指針來調用方法，編譯器會自動完成轉換 從某種意義上來說，方法是函數的語法糖，

Go語言之interface

interfaceinterface 理論 接口是一個或多個方法簽名的集合 只要某個類型擁有該接口的所有方法簽名，即算實現該接口，無需顯示聲明實現了哪個接口，這稱為Structural Typing 接口只有方法聲明，沒有實現，沒有數據字段 接口可以匿名嵌入其他接口，或嵌入到結構中 將對象賦值給接口時