Golang 中反射的應用範例詳解

2022-08-25 22:01:17

引言

首先來一段簡單的程式碼邏輯熱身，下面的程式碼大家覺得應該會列印什麼呢？

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 中變數包括（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
}

執行結果：

可以看出，利用反射初始化結構體和直接使用建立 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
}

測試結果：

從上面可以看出，通過反射進行 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()
   }
}

這個測試結果同上面的分析相同

優缺點

優點：

反射提高了程式的靈活性和擴充套件性，降低耦合性，提高自適應能力。
合理利用反射可以減少重複程式碼

缺點：

與反射相關的程式碼，經常是難以閱讀的。在軟體工程中，程式碼可讀性也是一個非常重要的指標。
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)
   }
}