反射是 Go 語言比較重要的一個特性之一，雖然在大多數的應用和服務中並不常見，但是很多框架都依賴 Go 語言的反射機制實現一些動態的功能。作為一門靜態語言，Golang 在設計上都非常簡潔，所以在語法上其實並沒有較強的表達能力，但是 Go 語言為我們提供的 reflect 包提供的動態特性卻能夠彌補它在語法上的一些劣勢。
reflect 實現了運行時的反射能力，能夠讓 Golang 的程序操作不同類型的對象，我們可以使用包中的函數 TypeOf 從靜態類型 interface{} 中獲取動態類型信息並通過 ValueOf 獲取數據的運行時表示，通過這兩個函數和包中的其他工具我們就可以得到更強大的表達能力。
概述
在具體介紹反射包的實現原理之前，我們先要對 Go 語言的反射有一些比較簡單的理解，首先 reflect 中有兩對非常重要的函數和類型，我們在上面已經介紹過其中的兩個函數 TypeOf 和 ValueOf，另外兩個類型是 Type 和 Value，它們與函數是一一對應的關係：
類型 Type 是 Golang 反射包中定義的一個接口，我們可以使用 TypeOf 函數獲取任意值的變量的的類型，我們能從這個接口中看到非常多有趣的方法，MethodByName 可以獲取當前類型對應方法的引用、Implements 可以判斷當前類型是否實現了某個接口：
複製代碼
type Type interface { Align() int FieldAlign() int Method(int) Method MethodByName(string) (Method, bool) NumMethod() int Name() string PkgPath() string Size() uintptr String() string Kind() Kind Implements(u Type) bool ...}反射包中 Value 的類型卻與 Type 不同，Type 是一個接口類型，但是 Value 在 reflect 包中的定義是一個結構體，這個結構體沒有任何對外暴露的成員變量，但是卻提供了很多方法讓我們獲取或者寫入 Value 結構體中存儲的數據：
複製代碼
type Value struct { // contains filtered or unexported fields} func (v Value) Addr() Valuefunc (v Value) Bool() boolfunc (v Value) Bytes() []bytefunc (v Value) Float() float64...反射包中的所有方法基本都是圍繞著 Type 和 Value 這兩個對外暴露的類型設計的，我們通過 TypeOf、ValueOf 方法就可以將一個普通的變量轉換成『反射』包中提供的 Type 和 Value，使用反射提供的方法對這些類型進行復雜的操作。
反射法則
運行時反射是程序在運行期間檢查其自身結構的一種方式，它是 元編程 的一種，但是它帶來的靈活性也是一把雙刃劍，過量的使用反射會使我們的程序邏輯變得難以理解並且運行緩慢，我們在這一節中就會介紹 Go 語言反射的三大法則，這能夠幫助我們更好地理解反射的作用。
- 從接口值可反射出反射對象；
- 從反射對象可反射出接口值；
- 要修改反射對象，其值必須可設置；
第一法則
反射的第一條法則就是，我們能夠將 Go 語言中的接口類型變量轉換成反射對象，上面提到的reflect.TypeOf 和 reflect.ValueOf 就是完成這個轉換的兩個最重要方法，如果我們認為 Go 語言中的類型和反射類型是兩個不同『世界』的話，那麼這兩個方法就是連接這兩個世界的橋樑。
我們通過以下例子簡單介紹這兩個方法的作用，其中 TypeOf 獲取了變量 author 的類型也就是 string 而 ValueOf 獲取了變量的值 draven，如果我們知道了一個變量的類型和值，那麼也就意味著我們知道了關於這個變量的全部信息。
複製代碼
package main import ( "fmt" "reflect") func main() { author := "draven" fmt.Println("TypeOf author:", reflect.TypeOf(author)) fmt.Println("ValueOf author:", reflect.ValueOf(author))} $ go run main.goTypeOf author: stringValueOf author: draven從變量的類型上我們可以獲當前類型能夠執行的方法 Method 以及當前類型實現的接口等信息；
- 對於結構體，可以獲取字段的數量並通過下標和字段名獲取字段 StructField；
- 對於哈希表，可以獲取哈希表的 Key 類型；
- 對於函數或方法，可以獲得入參和返回值的類型；
- …
總而言之，使用 TypeOf 和 ValueOf 能夠將 Go 語言中的變量轉換成反射對象，在這時我們能夠獲得幾乎一切跟當前類型相關數據和操作，然後就可以用這些運行時獲取的結構動態的執行一些方法。
很多讀者可能都會對這個副標題產生困惑，為什麼是從
接口到反射對象，如果直接調用 reflect.ValueOf(1)，看起來是從基本類型 int 到反射類型，但是 TypeOf 和 ValueOf 兩個方法的入參其實是 interface{} 類型。我們在之前已經在 函數調用 一節中介紹過，Go 語言的函數調用都是值傳遞的，變量會在方法調用前進行類型轉換，也就是 int 類型的基本變量會被轉換成 interface{} 類型，這也就是第一條法則介紹的是從接口到反射對象。
第二法則
我們既然能夠將接口類型的變量轉換成反射對象類型，那麼也需要一些其他方法將反射對象還原成成接口類型的變量， reflect 中的 Interface 方法就能完成這項工作：
然而調用 Interface 方法我們也只能獲得 interface{} 類型的接口變量，如果想要將其還原成原本的類型還需要經過一次強制的類型轉換，如下所示：
複製代碼
v := reflect.ValueOf(1)v.Interface{}.(int)這個過程就像從接口值到反射對象的鏡面過程一樣，從接口值到反射對象需要經過從基本類型到接口類型的類型轉換和從接口類型到反射對象類型的轉換，反過來的話，所有的反射對象也都需要先轉換成接口類型，再通過強制類型轉換變成原始類型：
當然不是所有的變量都需要類型轉換這一過程，如果本身就是 interface{} 類型的，那麼它其實並不需要經過類型轉換，對於大多數的變量來說，類型轉換這一過程很多時候都是隱式發生的，只有在我們需要將反射對象轉換回基本類型時才需要做顯示的轉換操作。
第三法則
Go 語言反射的最後一條法則是與值是否可以被更改相關的，如果我們想要更新一個 reflect.Value，那麼它持有的值一定是可以被更新的，假設我們有以下代碼：
複製代碼
func main() { i := 1 v := reflect.ValueOf(i) v.SetInt(10) fmt.Println(i)} $ go run reflect.gopanic: reflect: reflect.flag.mustBeAssignable using unaddressable value goroutine 1 [running]:reflect.flag.mustBeAssignableSlow(0x82, 0x1014c0) /usr/local/go/src/reflect/value.go:247 +0x180reflect.flag.mustBeAssignable(...) /usr/local/go/src/reflect/value.go:234reflect.Value.SetInt(0x100dc0, 0x414020, 0x82, 0x1840, 0xa, 0x0) /usr/local/go/src/reflect/value.go:1606 +0x40main.main() /tmp/sandbox590309925/prog.go:11 +0xe0運行上述代碼時會導致程序 panic 並報出 reflect: reflect.flag.mustBeAssignable using unaddressable value 錯誤，仔細想一下其實能夠發現出錯的原因，Go 語言的 函數調用 都是傳值的，所以我們得到的反射對象其實跟最開始的變量沒有任何關係，沒有任何變量持有複製出來的值，所以直接對它修改會導致崩潰。
想要修改原有的變量我們只能通過如下所示的方法，首先通過 reflect.ValueOf 獲取變量指針，然後通過 Elem 方法獲取指針指向的變量並調用 SetInt 方法更新變量的值：
複製代碼
func main() { i := 1 v := reflect.ValueOf(&i) v.Elem().SetInt(10) fmt.Println(i)} $ go run reflect.go10這種獲取指針對應的 reflect.Value 並通過 Elem 方法迂迴的方式就能夠獲取到可以被設置的變量，這一複雜的過程主要也是因為 Go 語言的函數調用都是值傳遞的，我們可以將上述代碼理解成：
複製代碼
func main() { i := 1 v := &i *v = 10}如果不能直接操作 i 變量修改其持有的值，我們就只能獲取 i 變量所在地址並使用 *v 修改所在地址中存儲的整數。
實現原理
我們在上面的部分已經對 Go 語言中反射的三大法則進行了介紹，對於接口值和反射對象互相轉換的操作和過程都有了一定的瞭解，接下來我們就深入研究反射的實現原理，分析 reflect 包提供的方法是如何獲取接口值對應的反射類型和值、判斷協議的實現以及方法調用的過程。
類型和值
Golang 的 interface{} 類型在語言內部都是通過 emptyInterface 這個結體來表示的，其中包含一個 rtype 字段用於表示變量的類型以及一個 word 字段指向內部封裝的數據：
複製代碼
type emptyInterface struct { typ *rtype word unsafe.Pointer}用於獲取變量類型的 TypeOf 函數就是將傳入的 i 變量強制轉換成 emptyInterface 類型並獲取其中存儲的類型信息 rtype：
複製代碼
func TypeOf(i interface{}) Type { eface := *(*emptyInterface)(unsafe.Pointer(&i)) return toType(eface.typ)} func toType(t *rtype) Type { if t == nil { return nil } return t}rtype 就是一個實現了 Type 接口的接口體，我們能在 reflect 包中找到如下所示的 Name 方法幫助我們獲取當前類型的名稱等信息：
複製代碼
func (t *rtype) String() string { s := t.nameOff(t.str).name() if t.tflag&tflagExtraStar != 0 { return s[1:] } return s}TypeOf 函數的實現原理其實並不複雜，它只是將一個 interface{} 變量轉換成了內部的 emptyInterface 表示，然後從中獲取相應的類型信息。
用於獲取接口值 Value 的函數 ValueOf 實現也非常簡單，在該函數中我們先調用了 escapes 函數保證當前值逃逸到堆上，然後通過 unpackEface 方法從接口中獲取 Value 結構體：
複製代碼
func ValueOf(i interface{}) Value { if i == nil { return Value{} } escapes(i) return unpackEface(i)} func unpackEface(i interface{}) Value { e := (*emptyInterface)(unsafe.Pointer(&i)) t := e.typ if t == nil { return Value{} } f := flag(t.Kind()) if ifaceIndir(t) { f |= flagIndir } return Value{t, e.word, f}}unpackEface 函數會將傳入的接口 interface{} 轉換成 emptyInterface 結構體然後將其中表示接口值類型、指針以及值的類型包裝成 Value 結構體並返回。
TypeOf 和 ValueOf 兩個方法的實現其實都非常簡單，從一個 Go 語言的基本變量中獲取反射對象以及類型的過程中，TypeOf 和 ValueOf 兩個方法的執行過程並不是特別的複雜，我們還需要注意基本變量到接口值的轉換過程：
複製代碼
package main import ( "reflect") func main() { i := 20 _ = reflect.TypeOf(i)} $ go build -gcflags="-S -N" main.go...MOVQ $20, ""..autotmp_20+56(SP) // autotmp = 20LEAQ type.int(SB), AX // AX = type.int(SB)MOVQ AX, ""..autotmp_19+280(SP) // autotmp_19+280(SP) = type.int(SB)LEAQ ""..autotmp_20+56(SP), CX // CX = 20MOVQ CX, ""..autotmp_19+288(SP) // autotmp_19+288(SP) = 20...我們使用 -S -N 編譯指令編譯了上述代碼，從這段截取的彙編語言中我們可以發現，在函數調用之前其實發生了類型轉換，我們將 int 類型的變量轉換成了佔用 16 字節 autotmp_19+280(SP) ~ autotmp_19+288(SP) 的 interface{} 結構體，兩個 LEAQ 指令分別獲取了類型的指針 type.int(SB) 以及變量 i 所在的地址。
總的來說，在 Go 語言的編譯期間我們就完成了類型轉換的工作，將變量的類型和值轉換成了 interface{} 等待運行期間使用 reflect 包獲取其中存儲的信息。
更新變量
當我們想要更新一個 reflect.Value 時，就需要調用 Set 方法更新反射對象，該方法會調用 mustBeAssignable 和 mustBeExported 分別檢查當前反射對象是否是可以被設置的和對外暴露的公開字段：
複製代碼
func (v Value) Set(x Value) { v.mustBeAssignable() x.mustBeExported() // do not let unexported x leak var target unsafe.Pointer if v.kind() == Interface { target = v.ptr } x = x.assignTo("reflect.Set", v.typ, target) if x.flag&flagIndir != 0 { typedmemmove(v.typ, v.ptr, x.ptr) } else { *(*unsafe.Pointer)(v.ptr) = x.ptr }}Set Set 方法中會調用 assignTo，該方法會返回一個新的 reflect.Value 反射對象，我們可以將反射對象的指針直接拷貝到被設置的反射變量上：
複製代碼
func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value { if v.flag&flagMethod != 0 { v = makeMethodValue(context, v) } switch { case directlyAssignable(dst, v.typ): fl := v.flag&(flagAddr|flagIndir) | v.flag.ro() fl |= flag(dst.Kind()) return Value{dst, v.ptr, fl} case implements(dst, v.typ): if target == nil { target = unsafe_New(dst) } if v.Kind() == Interface && v.IsNil() { return Value{dst, nil, flag(Interface)} } x := valueInterface(v, false) if dst.NumMethod() == 0 { *(*interface{})(target) = x } else { ifaceE2I(dst, x, target) } return Value{dst, target, flagIndir | flag(Interface)} } panic(context + ": value of type " + v.typ.String() + " is not assignable to type " + dst.String())}assignTo 會根據當前和被設置的反射對象類型創建一個新的 Value 結構體，當兩個反射對象的類型是可以被直接替換時，就會直接將目標反射對象返回；如果當前反射對象是接口並且目標對象實現了接口，就會將目標對象簡單包裝成接口值，上述方法返回反射對象的 ptr 最終會覆蓋當前反射對象中存儲的值。
實現協議
reflect 包還為我們提供了 Implements 方法用於判斷某些類型是否遵循協議實現了全部的方法，在 Go 語言中想要獲取結構體的類型還是比較容易的，但是想要獲得接口的類型就需要比較黑魔法的方式：
複製代碼
reflect.TypeOf((*<interface>)(nil)).Elem()/<interface>
只有通過上述方式才能獲得一個接口類型的反射對象，假設我們有以下代碼，我們需要判斷 CustomError 是否實現了 Go 語言標準庫中的 error 協議：
複製代碼
type CustomError struct{} func (*CustomError) Error() string { return ""} func main() { typeOfError := reflect.TypeOf((*error)(nil)).Elem() customErrorPtr := reflect.TypeOf(&CustomError{}) customError := reflect.TypeOf(CustomError{}) fmt.Println(customErrorPtr.Implements(typeOfError)) // #=> true fmt.Println(customError.Implements(typeOfError)) // #=> false}運行上述代碼我們會發現 CustomError 類型並沒有實現 error 接口，而 *CustomError 指針類型卻實現了接口，這其實也比較好理解，我們在 接口 一節中也介紹過可以使用結構體和指針兩種不同的類型實現接口。
複製代碼
func (t *rtype) Implements(u Type) bool { if u == nil { panic("reflect: nil type passed to Type.Implements") } if u.Kind() != Interface { panic("reflect: non-interface type passed to Type.Implements") } return implements(u.(*rtype), t)}Implements 方法會檢查傳入的類型是不是接口，如果不是接口或者是空值就會直接 panic 中止當前程序，否則就會調用私有的函數 implements 判斷類型之間是否有實現關係：
複製代碼
func implements(T, V *rtype) bool { t := (*interfaceType)(unsafe.Pointer(T)) if len(t.methods) == 0 { return true } // ... v := V.uncommon() i := 0 vmethods := v.methods() for j := 0; j < int(v.mcount); j++ { tm := &t.methods[i] tmName := t.nameOff(tm.name) vm := vmethods[j] vmName := V.nameOff(vm.name) if vmName.name() == tmName.name() && V.typeOff(vm.mtyp) == t.typeOff(tm.typ) { if i++; i >= len(t.methods) { return true } } } return false}如果接口中不包含任何方法，也就意味著這是一個空的 interface{}，任意的類型都可以實現該協議，所以就會直接返回 true。
在其他情況下，由於方法是按照一定順序排列的，implements 中就會維護兩個用於遍歷接口和類型方法的索引 i 和 j，所以整個過程的實現複雜度是 O(n+m)，最多隻會進行 n + m 次數的比較，不會出現次方級別的複雜度。
方法調用
作為一門靜態語言，如果我們想要通過 reflect 包利用反射在運行期間執行方法並不是一件容易的事情，下面的代碼就使用了反射來執行 Add(0, 1) 這一表達式：
複製代碼
func Add(a, b int) int { return a + b } func main() { v := reflect.ValueOf(Add) if v.Kind() != reflect.Func { return } t := v.Type() argv := make([]reflect.Value, t.NumIn()) for i := range argv { if t.In(i).Kind() != reflect.Int { return } argv[i] = reflect.ValueOf(i) } result := v.Call(argv) if len(result) != 1 || result[0].Kind() != reflect.Int { return } fmt.Println(result[0].Int()) // #=> 1}- 通過 reflect.ValueOf 獲取函數 Add 對應的反射對象；
- 根據反射對象 NumIn 方法返回的參數個數創建 argv 數組；
- 多次調用 reflect.Value 逐一設置 argv 數組中的各個參數；
- 調用反射對象 Add 的 Call 方法並傳入參數列表；
- 獲取返回值數組、驗證數組的長度以及類型並打印其中的數據；
使用反射來調用方法非常複雜，原本只需要一行代碼就能完成的工作，現在需要 10 多行代碼才能完成，但是這也是在靜態語言中使用這種動態特性需要付出的成本，理解這個調用過程能夠幫助我們深入理解 Go 語言函數和方法調用的原理。
複製代碼
func (v Value) Call(in []Value) []Value { v.mustBe(Func) v.mustBeExported() return v.call("Call", in)}Call 作為反射包運行時調用方法的入口，通過兩個 MustBe 方法保證了當前反射對象的類型和可見性，隨後調用 call 方法完成運行時方法調用的過程，這個過程會被分成以下的幾個部分：
- 檢查輸入參數的合法性以及類型等信息；
- 將傳入的 reflect.Value 參數數組設置到棧上；
- 通過函數指針和輸入參數調用函數；
- 從棧上獲取函數的返回值；
我們將按照上面的順序依次詳細介紹使用 reflect 進行函數調用的幾個過程。
參數檢查
參數檢查是通過反射調用方法的第一步，在參數檢查期間我們會從反射對象中取出當前的函數指針 unsafe.Pointer，如果待執行的函數是方法，就會通過 methodReceiver 函數獲取方法的接受者和函數指針。
複製代碼
func (v Value) call(op string, in []Value) []Value { t := (*funcType)(unsafe.Pointer(v.typ)) var ( fn unsafe.Pointer rcvr Value rcvrtype *rtype ) if v.flag&flagMethod != 0 { rcvr = v rcvrtype, t, fn = methodReceiver(op, v, int(v.flag)>>flagMethodShift) } else if v.flag&flagIndir != 0 { fn = *(*unsafe.Pointer)(v.ptr) } else { fn = v.ptr } n := t.NumIn() if len(in) < n { panic("reflect: Call with too few input arguments") } if len(in) > n { panic("reflect: Call with too many input arguments") } for i := 0; i < n; i++ { if xt, targ := in[i].Type(), t.In(i); !xt.AssignableTo(targ) { panic("reflect: " + op + " using " + xt.String() + " as type " + targ.String()) } } nin := len(in) if nin != t.NumIn() { panic("reflect.Value.Call: wrong argument count") }除此之外，在參數檢查的過程中我們還會檢查當前傳入參數的個數以及所有參數的類型是否能被傳入該函數中，任何參數不匹配的問題都會導致當前函數直接 panic 並中止整個程序。
準備參數
當我們已經對當前方法的參數驗證完成之後，就會進入函數調用的下一個階段，為函數調用準備參數，在前面的章節 函數調用 中我們已經介紹過 Go 語言的函數調用的慣例，所有的參數都會被依次放置到堆棧上。
複製代碼
nout := t.NumOut() frametype, _, retOffset, _, framePool := funcLayout(t, rcvrtype) var args unsafe.Pointer if nout == 0 { args = framePool.Get().(unsafe.Pointer) } else { args = unsafe_New(frametype) } off := uintptr(0) if rcvrtype != nil { storeRcvr(rcvr, args) off = ptrSize } for i, v := range in { targ := t.In(i).(*rtype) a := uintptr(targ.align) off = (off + a - 1) &^ (a - 1) n := targ.size if n == 0 { v.assignTo("reflect.Value.Call", targ, nil) continue } addr := add(args, off, "n > 0") v = v.assignTo("reflect.Value.Call", targ, addr) if v.flag&flagIndir != 0 { typedmemmove(targ, addr, v.ptr) } else { *(*unsafe.Pointer)(addr) = v.ptr } off += n }- 通過 funcLayout 函數計算當前函數需要的參數和返回值的堆棧佈局，也就是每一個參數和返回值所佔的空間大小；
- 如果當前函數有返回值，需要為當前函數的參數和返回值分配一片內存空間 args；
- 如果當前函數是方法，需要向將方法的接受者拷貝到 args 這片內存中；
- 將所有函數的參數按照順序依次拷貝到對應 args 內存中使用 funcLayout 返回的參數計算參數在內存中的位置；通過 typedmemmove 或者尋址的放置拷貝參數；
準備參數的過程其實就是計算各個參數和返回值佔用的內存空間，並將所有的參數都拷貝內存空間對應的位置上。
調用函數
準備好調用函數需要的全部參數之後，就會通過以下的表達式開始方法的調用了，我們會向該函數中傳入棧類型、函數指針、參數和返回值的內存空間、棧的大小以及返回值的偏移量：
複製代碼
call(frametype, fn, args, uint32(frametype.size), uint32(retOffset))
這個函數實際上並不存在，它會在編譯期間被鏈接到 runtime.reflectcall 這個用匯編實現的函數上，我們在這裡並不會展開介紹該函數的具體實現，感興趣的讀者可以自行了解其實現原理。
處理返回值
當函數調用結束之後，我們就會開始處理函數的返回值了，如果函數沒有任何返回值我們就會直接清空 args 中的全部內容來釋放內存空間，不過如果當前函數有返回值就會進入另一個分支：
複製代碼
var ret []Value if nout == 0 { typedmemclr(frametype, args) framePool.Put(args) } else { typedmemclrpartial(frametype, args, 0, retOffset) ret = make([]Value, nout) off = retOffset for i := 0; i < nout; i++ { tv := t.Out(i) a := uintptr(tv.Align()) off = (off + a - 1) &^ (a - 1) if tv.Size() != 0 { fl := flagIndir | flag(tv.Kind()) ret[i] = Value{tv.common(), add(args, off, "tv.Size() != 0"), fl} } else { ret[i] = Zero(tv) } off += tv.Size() } } return ret} - 將 args 中與輸入參數有關的內存空間清空；
- 創建一個 nout 長度的切片用於保存由反射對象構成的返回值數組；
- 從函數對象中獲取返回值的類型和內存大小，將 args 內存中的數據轉換成 reflect.Value 類型的返回值；
由 reflect.Value 構成的 ret 數組最終就會被返回到上層，使用反射進行函數調用的過程也就結束了。
總結
我們在這一節中 Go 語言的 reflect 包為我們提供的多種能力，其中包括如何使用反射來動態修改變量、判斷類型是否實現了某些協議以及動態調用方法，通過對反射包中方法原理的分析幫助我們理解之前看起來比較怪異、令人困惑的現象。
閱讀更多 InfoQ 的文章
