一些基本方法
本篇不會介紹反射的基本概念和原理等，會從每個常用的方法入手，講解一些基本和進階用法，反射不太適合在業務層使用，因為會幾何倍的降低運行速度，而且用反射做出來的程序健壯度不高，一旦一個環節沒有處理好就會直接panic，影響程序的運行，但是在后台上使用還是很適合的，可以極大的降低代碼量，從繁復的增刪改查操作和無邊的拋err（面向錯誤編程，太貼切了）中解脫出來。
reflect.TypeOf()
可以獲取任何變量的類型對象，使用該對象可以獲取變量的Name和Kind，Name代表的是變量類型的名稱，Kind代表的是變量的底層類型名稱，以下是兩個典型的例子。
// 系統變量
str := "張三"
reflectType := reflect.TypeOf(str)
fmt.Printf("name: %v kind: %v", reflectType.Name(), reflectType.Kind()) // name: string kind: string
// 自定義變量
type person string
a := person("張三")
reflectType := reflect.TypeOf(a)
fmt.Printf("name: %v kind: %v", reflectType.Name(), reflectType.Kind()) // name: person kind: string
Elem()方法
主要用來獲取指針類型（只能使用在數組、chan、map、指針、切片幾個類型上）的類型對象
str := "張三"
reflectType := reflect.TypeOf(&str)
reflectElem := reflectType.Elem()
fmt.Printf("name: %v kind: %v", reflectElem.Name(), reflectElem.Kind()) // name: string kind: string
reflect.ValueOf()
可以獲取任意變量的值對象，它的類型是reflect.Value，使用該對象同樣可以獲取變量的Name和Kind，通過獲取Kind可以使用類型斷言獲取變量的值。
這里的
reflect.ValueOf其實作用不大，在實際應用場景中多先使用reflect.ValueOf獲取變量的reflect.Value然后接Interface()方法把變量轉化為Interface{}類型，獲取reflect.Value的方法多采用reflect.TypeOf()加reflect.New()方法，后面實戰部分會有詳細用法。
isNil()
判斷值對象是否為nil，只能對通道、切片、數組、map、函數、interface等使用。
isValid()
判斷值對象是否為有效值，即非其默認0值，例如數字類型的0，字符串類型的""，在實際使用中，如果不對這些值進行處理，可能會直接panic。
reflect.SliceOf()
配合reflect.TypeOf返回單個類型的切片類型。
str := "張三"
reflectType := reflect.TypeOf(str)
reflectSlice := reflect.SliceOf(reflectType)
fmt.Printf("name: %v kind: %v", reflectSlice.Name(), reflectSlice.Kind()) // name: kind: slice
// 獲取切片中元素的值
a := []int{8, 9, 10}
reflectType := reflect.ValueOf(a)
for i := 0; i < reflectType.Len(); i++ {
fmt.Println(reflectType.Index(i))
}
// 8 9 10
這里注意數組、指針、切片、map等一些類型是沒有類型名稱的。
reflect.New()
配合reflect.TypeOf實例化一個該類型的值對象，返回該值對象的指針（想要使用反射設置值，必須使用指針）。
str := "張三"
reflectType := reflect.TypeOf(str)
reflectValue := reflect.New(reflectType)
// 設置值
reflectValue.Elem().SetString("李四")
fmt.Printf("value: %v kind: %v", reflectValue.Elem(), reflectValue.Elem().Kind()) // value: 李四 kind: string
reflect.PtrTo()
返回值對象的指針。
str := "張三"
reflectType := reflect.TypeOf(str)
if reflectType.Kind() != reflect.Ptr {
reflectType = reflect.PtrTo(reflectType)
}
fmt.Printf("value: %v kind: %v", reflectType, reflectType.Kind()) // value: *string kind: ptr
結構體的反射
上面的幾個方法只是開胃菜，真正常用仍然是結構體的反射，業務中各種增刪改查操作都要通過數據庫完成，而數據庫交互使用的都是結構體，這里會先列出一些結構體反射要用到的方法，然后通過一篇后台公用model類的實戰來完成這篇的內容。
和上面幾個基本方法有關的內容這里就不再贅述，有興趣的可以自己私底下去試試，這里只針對一些結構體的專用方法進行說明。
結構體字段相關的幾種方法
NumField()
返回結構體的字段數量，NumField()使用的對象必須是結構體，否則會panic。
type Student struct {
Name string
Age int
}
a := &Student{
Name: "張三",
Age: 18,
}
reflectValue := reflect.ValueOf(a)
fmt.Println(reflectValue.Elem().NumField()) // 2
Field()
通過字段的索引獲取字段的值，從0開始，順序參照結構體定義時的由上到下的順序。
a := &Student{
Name: "張三",
Age: 18,
}
reflectValue := reflect.ValueOf(a)
for i := 0; i < reflectValue.Elem().NumField(); i++ {
fmt.Println(reflectValue.Elem().Field(i))
}
FieldByName()
通過字段名稱獲取字段的值。
a := &Student{
Name: "張三",
Age: 18,
}
reflectValue := reflect.ValueOf(a)
fmt.Println(reflectValue.Elem().FieldByName("Name")) // 張三
NumMethod()
返回結構體的方法數量。
FieldByNameFunc()
根據傳入的匿名函數返回對應名稱的方法。
Method()
直接通過方法的索引，返回對應的方法。
MethodByName()
通過方法名稱返回對應的方法。
以上四個方法相關的函數就不放例子了，通過對應的函數獲取到方法后，使用Call()進行調用，其中特別注意的是，調用時傳入的參數必須是[]reflect.Value格式的。
實戰篇一：編寫一個公用的后台查詢方法
這里用到的數據庫類為gorm本篇不探討其相關知識，如有疑惑，請自行實踐。
首先編寫model，根目錄下創建文件夾model，在model文件夾中創建search.go
// Student 學生
type Student struct {
Name string
Age int
ID int
}
// TableName 表名
func (Student) TableName() string {
return "student"
}
編寫實現公用方法的接口，根目錄下創建search.go
// SearchModel 搜索接口
type SearchModel interface {
TableName() string
}
// SearchModelHandler 存儲一些查詢過程中的必要信息
type SearchModelHandler struct {
Model SearchModel
}
// GetSearchModelHandler 獲取處理器
func GetSearchModelHandler(model SearchModel) *SearchModelHandler {
return &SearchModelHandler{
Model: model,
}
}
// Search 查找
func (s *SearchModelHandler) Search() string {
query := db.model(s.Model)
itemPtrType := reflect.TypeOf(s.Model)
if itemPtrType.Kind() != reflect.Ptr {
itemPtrType = reflect.PtrTo(itemPtrType)
}
itemSlice := reflect.SliceOf(itemPtrType)
res := reflect.New(itemSlice)
// 這一步至關重要，雖然Scan方法接收的是一個interface{}類型，但是因為我們這里傳入的SearchModel，如果直接使用s.Model執行傳入會報錯
// 原因在於這里的Scan的interface和我們傳入的model實現的是不同的接口，Scan只認識gorm包中定義的接口類型
err := query.Scan(res.Interface()).Error
if err != nil {
// 這里不要學我
panic("error")
}
ret, _ := json.Marshal(res)
return string(ret)
}
就這樣一個簡單的公用類就誕生了，接下來就是調用了，在更目錄下創建main.go
func main() {
handler := GetSearchModelHandler(&model.Student{})
handler.Search()
}
實戰進階篇：為單個表添加上附加信息
比如我們還有一個班級表，而在返回學生信息的時候需要加上班級信息，這該怎么操作呢，這里我只提供自己的一種思路，如果有更好的建議，請寫在下方的評論里 共同交流。
首先，創建class的結構體，在model文件夾內創建class.go
// Class 班級
type Class struct {
ID int
Name string
}
// TableName 表名
func (Class) TableName() string {
return "class"
}
然后編寫一個公用的接口，在model文件夾下創建文件additional_api.go
// AdditionalInfo 附加信息獲取幫助
type AdditionalInfo struct {
FieldName string
Method func(ids []int32) string
}
// MinMapAPI 獲取總內容接口，相當於實戰一中的SearchModel
type MinMapAPI interface {
TableName() string
}
// MinMapInterface 最小信息獲取接口
type MinMapInterface interface {
TransFields() string
}
上面的方法先定義好，后面有用，然后修改model的內容，打開class.go輸入
// ClassMin 最小班級信息
type ClassMin struct {
ID int
Name string
}
// TransFields 轉換名稱，填寫你要獲取的字段的名稱
func (c *ClassMin) TransFields() string {
return "Name"
}
接下來編寫具體獲取附加信息的方法，打開additional_api.go，輸入以下內容
// GetMinMap 獲取最小信息
func GetMinMap(ids []int32, model MinMapAPI, minModel MinMapInterface) string {
// 獲取總數據的切片
modelType := reflect.TypeOf(model)
modelSliceType := reflect.SliceOf(modelType)
res := reflect.New(modelSliceType)
err := db.Model(model).Where("id in (?)", ids).Scan(res.Interface()).Error
if err != nil {
panic("error")
}
minModelType := reflect.TypeOf(minModel).Elem()
resValue := res.Elem()
resLen := resValue.Len()
ret := make(map[int]MinMapInterface, resLen)
for i := 0; i < resLen; i++ {
// 獲取當前下標的數據
item := resValue.Index(i).Elem()
// 獲取要得到的字段
name := item.FieldByName(minModel.TransFields())
id := item.FieldByName("ID")
// 拼接返回值
setItem := reflect.New(minModelType)
setItem.Elem().FieldByName("ID").SetInt(int64(id.Interface().(int)))
setItem.Elem().FieldByName(minModel.TransFields()).SetString(name.Interface().(string))
// 查詢出來的內容是具體的model，這里類型斷言轉化回去
ret[id.Interface().(int)] = setItem.Interface().(MinMapInterface)
}
data, _ := json.Marshal(ret)
return string(data)
}
修改student.go，加上獲取附加數據的方法，這里使用了一個匿名函數，既保證了每個model都有其獨有的參數，也保證了代碼的復用性
// AdditionalParams 附加數據參數
func (s *Student) AdditionalParams() map[string]AdditionalInfo {
return map[string]AdditionalInfo{
"class": {
FieldName: "ClassID",
Method: func(ids []int32) string {
return GetMinMap(ids, &Class{}, &ClassMin{})
},
},
}
}
相應的，也要修改search.go，為借口添加上AdditionalParams方法，這里直接貼上search.go的最終代碼以供比對
// SearchModel 搜索接口
type SearchModel interface {
TableName() string
AdditionalParams() map[string]model.AdditionalInfo
}
// SearchModelHandler 存儲一些查詢過程中的必要信息
type SearchModelHandler struct {
Model SearchModel
ListValue reflect.Value
AdditionalData string
}
// GetSearchModelHandler 獲取處理器
func GetSearchModelHandler(model SearchModel) *SearchModelHandler {
return &SearchModelHandler{
Model: model,
}
}
// Search 查找
func (s *SearchModelHandler) Search() interface{} {
query := db.model(s.Model)
itemPtrType := reflect.TypeOf(s.Model)
if itemPtrType.Kind() != reflect.Ptr {
itemPtrType = reflect.PtrTo(itemPtrType)
}
itemSlice := reflect.SliceOf(itemPtrType)
res := reflect.New(itemSlice)
// 這一步至關重要，雖然Scan方法接收的是一個interface{}類型，但是因為我們這里傳入的SearchModel，如果直接使用s.Model執行傳入會報錯
// 原因在於這里的Scan的interface和我們傳入的model實現的是不同的接口，Scan只認識gorm包中定義的接口類型
err := query.Scan(res.Interface()).Error
if err != nil {
// 這里不要學我
panic("error")
}
s.ListValue = res.Elem()
data, _ := json.Marshal(res)
ret := map[string]string {
"list": string(data),
"additional": s.AdditionalData,
}
return ret
}
// GetAdditionalData 獲取附加信息
func (s *SearchModelHandler) GetAdditionalData() {
additionParams := s.Model.AdditionalParams()
list := s.ListValue
listLen := list.Len()
if len(additionParams) < 1 || list.Len() < 1 {
s.AdditionalData = ""
return
}
additionalIDs := make(map[string][]int)
additionalData := make(map[string]string, len(additionParams))
for i := 0; i < listLen; i++ {
for key, val := range additionParams {
fieldName := val.FieldName
// 判斷Map中的鍵是否已存在
if _, ok := additionalIDs[key]; !ok {
additionalIDs[key] = make([]int, 0, listLen)
}
fields := list.Index(i).Elem().FieldByName(fieldName)
if !fields.IsValid() {
continue
}
additionalIDs[key] = append(additionalIDs[key], fields.Interface().(int))
}
}
for k, v := range additionalIDs {
additionalData[k] = additionParams[k].Method(v)
}
ret, _ := json.Marshal(additionalData)
s.AdditionalData = string(ret)
}