變量機制
在Go語言中，變量分為兩部分。
類型信息：預先定義好的變量類型，屬於元信息
值信息：程序運行過程中可變化的一部分信息
反射介紹
反射是指在程序運行期對程序本身進行訪問和修改的能力。程序在編譯時，變量被轉換為內存地址，變量名不會被編譯器寫入到可執行部分。在運行程序時，程序無法獲取自身的信息。
支持反射的語言可以在程序編譯期將變量的反射信息，如字段名稱、類型信息、結構體信息等整合到可執行文件中，並給程序提供接口訪問反射信息，這樣就可以在程序運行期獲取類型的反射信息，並且有能力修改它們。
Go程序在運行期使用reflect包訪問程序的反射信息。
空接口可以存儲任意類型的變量，那我們如何知道這個空接口保存的數據是什么呢？ 反射就是在運行時動態的獲取一個變量的類型信息和值信息。
反射就是對空接口擁有更靈活的處理
reflect包
在Go語言的反射機制中，任何接口值都由是一個具體類型和具體類型的值兩部分組成的。
在Go語言中反射的相關功能由內置的reflect包提供，任意接口值在反射中都可以理解為由reflect.Type和reflect.Value兩部分組成，並且reflect包提供了reflect.TypeOf和reflect.ValueOf兩個函數來獲取任意對象的Value和Type。
TypeOf()
在Go語言中，使用reflect.TypeOf()函數可以獲得任意值的類型對象（reflect.Type），程序通過類型對象可以訪問任意值的類型信息。
該方法獲取的類型對象是淺層的，意思在於如果是自定義對象不能獲取到其根本的對象。
package main
import (
"fmt"
"reflect"
)
func getType(v1 interface{}){
t := reflect.TypeOf(v1)
fmt.Println(t) // float64
}
func main(){
var num float64
num = 3.14
getType(num)
}
深層類型與種類
Go中由於支持自定義類型，所以還存在深層類型的說法，除此之外還有種類的說法。
如何理解種類呢？比如一個map[string]int64與map[string]interface{}它們的類型並不一樣，但是都是屬於map這個種類的。
注意：Go語言的反射中像數組、切片、Map、指針等類型的變量，它們的.Name()都是返回空。
package main
import (
"fmt"
"reflect"
)
func getType(v1 interface{}) string {
t := reflect.TypeOf(v1)
return fmt.Sprintf("淺層類型Type：%s,深層類型Name:%s,種類Kind:%s", t, t.Name(), t.Kind())
}
func main() {
var n1 float64
n1 = 3.14
result := getType(n1)
fmt.Println(result) // 淺層類型Type：float64,深層類型Name:float64,種類Kind:float64
type iInt int // 自定義類型
var n2 iInt
n2 = 1000
result = getType(n2)
fmt.Println(result) // 淺層類型Type：main.iInt,深層類型Name:iInt,種類Kind:int
type iFloat = float64 // 類型別名
var n3 iFloat
n3 = 3.15
result = getType(n3)
fmt.Println(result) // 淺層類型Type：float64,深層類型Name:float64,種類Kind:float64
}
在reflect包中，定義的種類Kind如下：
type Kind uint
const (
Invalid Kind = iota // 非法類型
Bool // 布爾型
Int // 有符號整型
Int8 // 有符號8位整型
Int16 // 有符號16位整型
Int32 // 有符號32位整型
Int64 // 有符號64位整型
Uint // 無符號整型
Uint8 // 無符號8位整型
Uint16 // 無符號16位整型
Uint32 // 無符號32位整型
Uint64 // 無符號64位整型
Uintptr // 指針
Float32 // 單精度浮點數
Float64 // 雙精度浮點數
Complex64 // 64位復數類型
Complex128 // 128位復數類型
Array // 數組
Chan // 通道
Func // 函數
Interface // 接口
Map // 映射
Ptr // 指針
Slice // 切片
String // 字符串
Struct // 結構體
UnsafePointer // 底層指針
)
ValueOf()
reflect.ValueOf()用於返回原始值，下面是支持獲取值的類型。
| 方法 | 說明 |
|---|---|
| Interface() interface {} | 將值以 interface{} 類型返回，可以通過類型斷言轉換為指定類型 |
| Int() int64 | 將值以 int 類型返回，所有有符號整型均可以此方式返回 |
| Uint() uint64 | 將值以 uint 類型返回，所有無符號整型均可以此方式返回 |
| Float() float64 | 將值以雙精度（float64）類型返回，所有浮點數（float32、float64）均可以此方式返回 |
| Bool() bool | 將值以 bool 類型返回 |
| Bytes() []bytes | 將值以字節數組 []bytes 類型返回 |
| String() string | 將值以字符串類型返回 |
反射獲取值
如下示例：
package main
import (
"reflect"
"fmt"
)
func getValue(v1 interface{}) interface{} {
value := reflect.ValueOf(v1) // 獲取原始值
kind := value.Kind() // 獲取種類
switch kind {
case reflect.Int64:
return int64(value.Int()) // 返回
case reflect.Float32, reflect.Float64:
return float32(value.Float())
default:
return "不支持獲取該類型"
}
}
func main() {
var n1 float32
n1 = 3.14
result := getValue(n1)
fmt.Printf("%T\n",result) // float32
}
反射設置值
由於在函數中傳遞的都是值拷貝，以前我們想設置原本的值必須傳入指針變量。
通過反射的Elem()方法可以進行值設置，這常用在傳入值是空接口時。
package main
import (
"fmt"
"reflect"
)
func setValue(v1 interface{}) { // 傳入空接口
value := reflect.ValueOf(v1) // 獲取原始值
kind := value.Elem().Kind()
switch kind { // 進行種類捕獲
case reflect.Int64:
value.Elem().SetInt(1000) // 若不使用Elem則會拋出異常
case reflect.Float32, reflect.Float64:
value.Elem().SetFloat(1.11)
default:
fmt.Println("你傳入的類型讓我無法設置")
}
}
func main() {
var n1 float32
n1 = 3.14
setValue(&n1) // 傳入地址
fmt.Println(n1) // 1.11
}
IsNil()
使用格式：
func (v Value) IsNil() bool
IsNil()報告v持有的值是否為nil。v持有的值的分類必須是通道、函數、接口、映射、指針、切片之一；否則IsNil()函數會導致panic。
IsNil()常被用於判斷指針是否為空
package main
import (
"fmt"
"reflect"
)
func main() {
var a *int // int類型空指針
fmt.Println(reflect.ValueOf(a).IsNil()) // true
}
IsVaild()
使用格式：
func (v Value) IsValid() bool
IsValid()返回v是否持有一個值。如果v是Value零值會返回假，此時v除了IsValid()、String()、Kind()之外的方法都會導致panic()。
IsValid()常被用於判定返回值是否有效。
package main
import (
"fmt"
"reflect"
)
func main() {
b := struct{}{}
// 嘗試從結構體中查找"abc"字段
fmt.Println("不存在的結構體成員:", reflect.ValueOf(b).FieldByName("abc").IsValid())
// 嘗試從結構體中查找"abc"方法
fmt.Println("不存在的結構體方法:", reflect.ValueOf(b).MethodByName("abc").IsValid())
// map
c := map[string]int{}
// 嘗試從map中查找一個不存在的鍵
fmt.Println("map中不存在的鍵：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("和尚")).IsValid())
}
結構體反射
JSON是如何反序列化為結構體的？這就蘊含結構體反射的內容了。
任意值通過reflect.TypeOf()獲得反射對象信息后，如果它的類型是結構體，可以通過反射值對象（reflect.Type）的NumField()和Field()方法獲得結構體成員的詳細信息。
reflect.Type中與獲取結構體成員相關的的方法如下表所示。
| 方法 | 說明 |
|---|---|
| Field(i int) StructField | 根據索引，返回索引對應的結構體字段的信息。 |
| NumField() int | 返回結構體成員字段數量。 |
| FieldByName(name string) (StructField, bool) | 根據給定字符串返回字符串對應的結構體字段的信息。 |
| FieldByIndex(index []int) StructField | 多層成員訪問時，根據 []int 提供的每個結構體的字段索引，返回字段的信息。 |
| FieldByNameFunc(match func(string) bool) (StructField,bool) | 根據傳入的匹配函數匹配需要的字段。 |
| NumMethod() int | 返回該類型的方法集中方法的數目 |
| Method(int) Method | 返回該類型方法集中的第i個方法 |
| MethodByName(string)(Method, bool) | 根據方法名返回該類型方法集中的方法 |
StructField類型
StructField類型用來描述結構體中的一個字段的信息。
StructField的定義如下：
type StructField struct {
// Name是字段的名字。PkgPath是非導出字段的包路徑，對導出字段該字段為""。
// 參見http://golang.org/ref/spec#Uniqueness_of_identifiers
Name string
PkgPath string
Type Type // 字段的類型
Tag StructTag // 字段的標簽
Offset uintptr // 字段在結構體中的字節偏移量
Index []int // 用於Type.FieldByIndex時的索引切片
Anonymous bool // 是否匿名字段
}
結構體反射示例
當我們使用反射得到一個結構體數據之后可以通過索引依次獲取其字段信息，也可以通過字段名去獲取指定的字段信息。
type student struct {
Name string `json:"name"`
Score int `json:"score"`
}
func main() {
stu1 := student{
Name: "小王子",
Score: 90,
}
t := reflect.TypeOf(stu1)
fmt.Println(t.Name(), t.Kind()) // student struct
// 通過for循環遍歷結構體的所有字段信息
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
fmt.Printf("name:%s index:%d type:%v json tag:%v\n", field.Name, field.Index, field.Type, field.Tag.Get("json"))
}
// 通過字段名獲取指定結構體字段信息
if scoreField, ok := t.FieldByName("Score"); ok {
fmt.Printf("name:%s index:%d type:%v json tag:%v\n", scoreField.Name, scoreField.Index, scoreField.Type, scoreField.Tag.Get("json"))
}
}
接下來編寫一個函數printMethod(s interface{})來遍歷打印s包含的方法。
// 給student添加兩個方法 Study和Sleep(注意首字母大寫)
func (s student) Study() string {
msg := "好好學習，天天向上。"
fmt.Println(msg)
return msg
}
func (s student) Sleep() string {
msg := "好好睡覺，快快長大。"
fmt.Println(msg)
return msg
}
func printMethod(x interface{}) {
t := reflect.TypeOf(x)
v := reflect.ValueOf(x)
fmt.Println(t.NumMethod())
for i := 0; i < v.NumMethod(); i++ {
methodType := v.Method(i).Type()
fmt.Printf("method name:%s\n", t.Method(i).Name)
fmt.Printf("method:%s\n", methodType)
// 通過反射調用方法傳遞的參數必須是 []reflect.Value 類型
var args = []reflect.Value{}
v.Method(i).Call(args)
}
}
反射是把雙刃劍
反射是一個強大並富有表現力的工具，能讓我們寫出更靈活的代碼。但是反射不應該被濫用，原因有以下三個。
- 基於反射的代碼是極其脆弱的，反射中的類型錯誤會在真正運行的時候才會引發panic，那很可能是在代碼寫完的很長時間之后。
- 大量使用反射的代碼通常難以理解。
- 反射的性能低下，基於反射實現的代碼通常比正常代碼運行速度慢一到兩個數量級。
實例操作
需求分析
解析ini配置文件，如下有一個ini配置文件。
[mysql]
address = 10.20.30.40
port = 3306
username = root
password = rootroot
如何將內容解析到下面這個結構體中？
package main
import (
"errors"
"fmt"
"io/ioutil"
"reflect"
"strconv"
"strings"
)
// Config 配置文件結構體
type Config struct {
MysqlConfig `ini:"mysql"`
}
// MysqlConfig MySQL配置結構體，結構體字段需要與配置文件中的對應。
type MysqlConfig struct {
Address string `ini:"address"`
Port int `ini:"port"`
Username string `ini:"username"`
Password string `ini:"password"`
}
func loadIni(fileName string, data interface{}) (err error) {
// 補全代碼
}
func main() {
var cfg Config
err := loadIni("./conf.ini", &cfg)
if err != nil {
fmt.Printf("load ini failed err%v \n", err)
return
}
fmt.Println(cfg)
}
解決方案
其實只要打開配置文件每一行進行讀取，再拿到結構體字段后對比tag。如果tag相同則將配置文件中的數據寫入到結構體中即可。
package main
import (
"errors"
"fmt"
"io/ioutil"
"reflect"
"strconv"
"strings"
)
// Config 配置文件結構體
type Config struct {
MysqlConfig `ini:"mysql"`
}
// MysqlConfig MySQL配置結構體
type MysqlConfig struct {
Address string `ini:"address"`
Port int `ini:"port"`
Username string `ini:"username"`
Password string `ini:"password"`
}
func loadIni(fileName string, data interface{}) (err error) {
var sectionName string // 節點名稱
var structName string // 結構體名字
// 參數校驗：
// 傳入的data參數是否是一個結構體指針類型（要對結構體進行字段填充）
t := reflect.TypeOf(data)
// 判斷是否是指針
if t.Kind() != reflect.Ptr {
err = errors.New("data should be a pointer")
return err
}
// 判斷是否是結構體指針
if t.Elem().Kind() != reflect.Struct {
err = errors.New("data should be a Struct pointer")
return err
}
// 1.讀文件，得到字節類型的數據,轉換為字符串
b, err := ioutil.ReadFile(fileName)
if err != nil {
return
}
lineSlice := strings.Split(string(b), "\n")
// 2 一行一行讀數據，如果是注釋就忽略
// 3 一行一行讀數據，如果是[開頭的則代表是一個節點
// 4 一行一行讀數據，如不不是[開頭的就是=號分割的鍵值對
for idex, line := range lineSlice {
// 去空格
line = strings.TrimSpace(line)
// 過濾空行
if len(line) == 0 {
continue
}
// 這是注釋
if strings.HasPrefix(line, ";") {
continue
}
// 這是[開頭的節點
if strings.HasPrefix(line, "[") {
// 不合格的節點
if line[0] != '[' || line[len(line)-1] != ']' {
err = fmt.Errorf("line:%d syntax error", idex+1)
return err
}
// []里沒有內容
sectionName = strings.TrimSpace(line[1:(len(line) - 1)])
if len(sectionName) == 0 {
err = fmt.Errorf("line:%d syntax error", idex+1)
return err
}
// v := reflect.ValueOf(data)
// 根據sectionName找結構體
for i := 0; i < t.Elem().NumField(); i++ {
field := t.Elem().Field(i)
if sectionName == field.Tag.Get("ini") {
// 找到了嵌套結構體，記錄字段名
structName = field.Name
fmt.Printf("找到%s對應的嵌套結構體%s\n", sectionName, structName)
}
}
} else {
// 等號進行分割，k = v
if strings.Index(line, "=") == -1 || strings.HasPrefix(line, "=") || strings.HasSuffix(line, "=") {
err = fmt.Errorf("line:%d syntax error", idex+1)
return err
}
index := strings.Index(line, "=")
key := strings.TrimSpace(line[:index])
value := strings.TrimSpace(line[index+1:])
// 根據strucrName在data中拿到對應的嵌套結構體
v := reflect.ValueOf(data)
sValue := v.Elem().FieldByName(structName) // 拿到嵌套結構體的值信息
sType := sValue.Type() // 拿到嵌套結構體的類型信息
if sType.Kind() != reflect.Struct {
err = fmt.Errorf("data中的%s字段在結構體中不存在", structName)
return err
}
var filedName string
var fileType reflect.StructField
// 遍歷嵌套結構體的字段，判斷tag是否等於key
for i := 0; i < sValue.NumField(); i++ {
filed := sType.Field(i) // tag信息存儲在類型中
fileType = filed
if filed.Tag.Get("ini") == key {
// 找到字段
filedName = filed.Name
break
}
}
if len(filedName) == 0 {
// 結構體中找不到對應的字段
continue
}
// 如果key == tag 給字段進行賦值
fileObj := sValue.FieldByName(filedName)
// 賦值
switch fileType.Type.Kind() {
case reflect.String:
fileObj.SetString(value)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
var valueInt int64
valueInt, err = strconv.ParseInt(value, 10, 64)
if err != nil {
err = fmt.Errorf("line:%d value type error", idex+1)
return err
}
fileObj.SetInt(valueInt)
case reflect.Bool:
var valueBool bool
valueBool, err = strconv.ParseBool(value)
if err != nil {
err = fmt.Errorf("line:%d value type error", idex+1)
return err
}
fileObj.SetBool(valueBool)
case reflect.Float32, reflect.Float64:
var valueFloat float64
valueFloat, err = strconv.ParseFloat(value, 64)
if err != nil {
err = fmt.Errorf("line:%d value type error", idex+1)
return err
}
fileObj.SetFloat(valueFloat)
}
}
}
return
}
func main() {
var cfg Config
err := loadIni("./conf.ini", &cfg)
if err != nil {
fmt.Printf("load ini failed err%v \n", err)
return
}
fmt.Println(cfg)
}