go反射实例

Golang

1. go反射结构体类型切片

type Man struct {
    Id   int
    Name string
}
s1 := make([]Man, 0)
s1 = append(s1, Man{1, "a"})
s1 = append(s1, Man{2, "b"})
s1 = append(s1, Man{3, "c"})
func(v interface{}) {
    getValue := reflect.ValueOf(v) // Value of v
    if getValue.Kind() != reflect.Slice {
        panic("need slice kind")
    }
    l := getValue.Len()
    for i := 0; i < l; i++ {
        value := getValue.Index(i) // Value of item
        typel := value.Type() // Type of item
        if typel.Kind() != reflect.Struct {
            panic("need struct kind")
        }
        fmt.Printf("type-kind: %s, type-name: %s, value: %v\n", typel.Kind(), typel.Name(), value.Interface())
        num := value.NumField()
        for j := 0; j < num; j++ {
            fmt.Printf("name: %s, type: %s, value: %v\n", typel.Field(j).Name, value.Field(j).Type(), value.Field(j).Interface())
        }
        fmt.Println()
    }
}(s1)

执行打印：

type-kind: struct, type-name: Man, value: {1 a}
name: Id, type: int, value: 1
name: Name, type: string, value: a
type-kind: struct, type-name: Man, value: {2 b}
name: Id, type: int, value: 2
name: Name, type: string, value: b
type-kind: struct, type-name: Man, value: {3 c}
name: Id, type: int, value: 3
name: Name, type: string, value: c

根据示例：

通过 reflect.ValueOf(v) 得到 v 的 Value 对象，它的 Len() 方法可以得到切片的长度；
通过 Value 对象的 Index(i) 方法得到第 i 的元素 Value 对象，然后通过 Value 对象得到 Type 对象；

值得注意的是:

Index 方法可以适用于获取 Array, Slice, or String 其中的字段
Len 方法获取长度，可以适用于 Array, Chan, Map, Slice, or String

Filed 方法用于Struct的其中字段。
NumField 方法，用于获取Struct的长度。

2. go反射结构体

package main
import (
    "fmt"
    "reflect"
)
type User struct  {
    Id int `json:"id"`
    Name string `json:"name"`
    addr string `json:"_"`
}
func main(){
    u := User{Id:1001, Name:"aaa" , addr:"bbb"}
    t := reflect.TypeOf(u)
    v := reflect.ValueOf(u)
    for i := 0; i < v.NumField(); i++ {
        if v.Field(i).CanInterface() {  //判断是否为可导出字段
            fmt.Printf("%s %s = %v -tag:%s n", 
                t.Field(i).Name, 
                t.Field(i).Type, 
                v.Field(i).Interface(), 
                t.Field(i).Tag)
        }
    }
}

执行打印：

Id int = 1001 -tag:json:"id" 
Name string = aaa -tag:json:"name" 

注：当结构体中含有非导出字段时，v.Field(i).Interface()会panic, 所以使用v.Field(i).CanInterface()先判断一下

3. go反射结构体嵌套

package main
import (
    "reflect"
    "fmt"
)
type User struct {
    Id int
    Name string
    Address Address
}
type Address struct {
    Add string
    Res int
}
func main(){
    u := User{Id:1001, Name:"aaa" , Address:Address{Add:"ccccccccc", Res:12}}
    t := reflect.TypeOf(u)
    v := reflect.ValueOf(u)
    for i := 0; i < v.NumField(); i++ {
        //判断是否为可导出字段
        if v.Field(i).CanInterface() {  
            //判断是否是嵌套结构
            if v.Field(i).Type().Kind() == reflect.Struct{
                structField := v.Field(i).Type()
                for j :=0 ; j< structField.NumField(); j++ {
                    fmt.Printf("%s %s = %v -tag:%s \n",
                        structField.Field(j).Name,
                        structField.Field(j).Type,
                        v.Field(i).Field(j).Interface(),
                        structField.Field(j).Tag)
                }
            } else {
                fmt.Printf("%s %s = %v -tag:%s \n",
                t.Field(i).Name,
                t.Field(i).Type,
                v.Field(i).Interface(),
                t.Field(i).Tag)
            }
        }
    }
}

打印：

Id int = 1001 -tag: 
Name string = aaa -tag: 
Add string = ccccccccc -tag: 
Res int = 12 -tag: 

4. 反射切片

package main
import (
    "reflect"
    "fmt"
)
func main(){
    var data []int
    data = []int{1, 2, 3, 4}
    //反射值
    v := reflect.ValueOf(data)
    //数组/切片长度
    dataNum := v.Len()
    for i := 0; i < dataNum; i++ {
        fmt.Printf("%v, ", v.Index(i).Interface())
    }
}

打印：

1,2,3,4,

5. 通过反射将struct切片如何转换为map切片

package main
import (
    "fmt"
    "reflect"
)
type Student struct {
    Name string `json:"name"`
    Age  uint   `json:"age"`
}
type Teacher struct {
    Name string `json:"name"`
    Gender  uint   `json:"gender"`
}
// StructSliceToMapSlice : struct切片转为map切片
func StructSliceToMapSlice(source interface{}) {
    // 判断，interface转为[]interface{}
    v := reflect.ValueOf(source)
    if v.Kind() != reflect.Slice {
        panic("ERROR: Unknown type, slice expected.")
    }
    l := v.Len()
    ret := make([]interface{}, l)
    for i := 0; i < l; i++ {
        ret[i] = v.Index(i).Interface()
    }
    // 转换之后的结果变量
    res := make([]map[string]interface{}, 0)
    // 通过遍历，每次迭代将struct转为map
    for _, elem := range ret {
        data := make(map[string]interface{})
        objT := reflect.TypeOf(elem)
        objV := reflect.ValueOf(elem)
        for i := 0; i < objT.NumField(); i++ {
            data[objT.Field(i).Name] = objV.Field(i).Interface()
        }
        res = append(res, data)
    }
    fmt.Printf("==== Convert Result ====\n%+v\n", res)
}
func main() {
    var people []interface{}
    // 切片添加Student元素
    stu1 := Student{
        Name: "Ame",
        Age:  18,
    }
    stu2 := Student{
        Name: "Maybe",
        Age:  20,
    }
    people = append(people, stu1)
    people = append(people, stu2)
    // 切片添加Teacher元素
    tech := Teacher{
        Name: "Rotk",
        Gender:  0,
    }
    people = append(people, tech)
    StructSliceToMapSlice(people)
}

打印：

==== Convert Result ====
[map[Age:18 Name:Ame] map[Age:20 Name:Maybe] map[Gender:0 Name:Rotk]]

6. 将map转换为struct

func MapToStruct(mapData map[string]string, result interface{}) error {
    if reflect.ValueOf(result).Kind() != reflect.Ptr {
        return e.setErrorInfo(errors.New("第二参数请传指针变量！"))
    }
    if reflect.ValueOf(result).IsNil() {
        return e.setErrorInfo(errors.New("第二参数不能是空指针！"))
    }
    //获取元素值
    v := reflect.ValueOf(result).Elem()
    t := v.Type()
    //遍历结构体
    for i := 0; i < t.NumField(); i++ {
        //看下是否有sql别名
        sqlTag := t.Field(i).Tag.Get("sql")
        var fieldName string
        if sqlTag != "" {
            fieldName = strings.Split(sqlTag, ",")[0]
        } else {
            fieldName = t.Field(i).Name
        }
        //从map中取值
        value, ok := mapData[fieldName]
        if !ok {
            continue
        }
        switch v.Field(i).Kind() {
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            res, err := strconv.ParseInt(value, 10, 64)
            if err != nil {
                return e.setErrorInfo(err)
            }
            v.Field(i).SetInt(res)
        case reflect.String:
            v.Field(i).SetString(value)
        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
            res, err := strconv.ParseUint(value, 10, 64)
            if err != nil {
                return e.setErrorInfo(err)
            }
            v.Field(i).SetUint(res)
        case reflect.Float32:
            res, err := strconv.ParseFloat(value, 32)
            if err != nil {
                return e.setErrorInfo(err)
            }
            v.Field(i).SetFloat(res)
        case reflect.Float64:
            res, err := strconv.ParseFloat(value, 64)
            if err != nil {
                return e.setErrorInfo(err)
            }
            v.Field(i).SetFloat(res)
        case reflect.Bool:
            res, err := strconv.ParseBool(value)
            if err != nil {
                return e.setErrorInfo(err)
            }
            v.Field(i).SetBool(res)
        case reflect.Slice:
            var strArray []string
            var valArray []reflect.Value
            var valArr reflect.Value
            elemKind := v.Field(i).Type().Elem().Kind()
            elemType := t.Field(i).Type.Elem()
            value = strings.Trim(strings.Trim(value, "["), "]")
            strArray = strings.Split(value, ",")
            switch elemKind {
            case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                for _, e := range strArray {
                    ee, err := strconv.ParseInt(e, 10, 64)
                    if err != nil {
                        return err
                    }
                    valArray = append(valArray, reflect.ValueOf(ee).Convert(elemType))
                }
            case reflect.String:
                for _, e := range strArray {
                    valArray = append(valArray, reflect.ValueOf(strings.Trim(e, "\"")).Convert(elemType))
                }
            }
            valArr = reflect.Append(v.Field(i), valArray...)
            v.Field(i).Set(valArr)
        }
    }
    return nil
}

测试一下：

m1 := map[string]string{"created": "2021-12-12", "departname": "233", "status": "2", "uid": "131733", "username":"EE2"}
type User2 struct {
    Uid string `sql:"uid,auto_increment"`
    Username   string `sql:"username"`
    Departname string `sql:"departname"`
    Created    string `sql:"created"`
    Status     int64 `sql:"status"`
}
user3 := new(User2)
err := MapToStruct(m1, user3)
fmt.Printf("%+v", user3)
//输出： &{Uid:131733 Username:EE2 Departname:233 Created:2021-12-12 Status:2}

7. 通过反射将map切片转换为struct切片

func MapSliceToStructSlice(mapSliceData []map[string]string, values interface{}) error {
    //原始struct的切片值
    destSlice := reflect.ValueOf(values).Elem()
    //原始单个struct的类型
    destType := destSlice.Type().Elem()
    //遍历切片
    for j := 0; j < len(mapSliceData); j++ {
        //新建1个原始struct的类型
        dest := reflect.New(destType).Elem()
        //遍历结构体
        for i := 0; i < destType.NumField(); i++ {
            //看下是否有sql别名
            sqlTag := destType.Field(i).Tag.Get("sql")
            var fieldName string
            if sqlTag != "" {
                fieldName = strings.Split(sqlTag, ",")[0]
            } else {
                fieldName = destType.Field(i).Name
            }
            //从map中取值
            value, ok := mapSliceData[j][fieldName]
            if !ok {
                continue
            }
            //无法赋值
            if !dest.Field(i).CanSet() {
                continue
            }
            switch dest.Field(i).Kind() {
            case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                res, err := strconv.ParseInt(value, 10, 64)
                if err != nil {
                    return e.setErrorInfo(err)
                }
                dest.Field(i).SetInt(res)
            case reflect.String:
                dest.Field(i).SetString(value)
            case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
                res, err := strconv.ParseUint(value, 10, 64)
                if err != nil {
                    return e.setErrorInfo(err)
                }
                dest.Field(i).SetUint(res)
            case reflect.Float32:
                res, err := strconv.ParseFloat(value, 32)
                if err != nil {
                    return e.setErrorInfo(err)
                }
                dest.Field(i).SetFloat(res)
            case reflect.Float64:
                res, err := strconv.ParseFloat(value, 64)
                if err != nil {
                    return e.setErrorInfo(err)
                }
                dest.Field(i).SetFloat(res)
            case reflect.Bool:
                res, err := strconv.ParseBool(value)
                if err != nil {
                    return e.setErrorInfo(err)
                }
                dest.Field(i).SetBool(res)
            }
        }
        //赋值
        destSlice.Set(reflect.Append(destSlice, dest))
    }
    return nil
}

或者，我们简化一下套用上面的MapToStruct:

func MapSliceToStructSlice(mapSliceData []map[string]string, values interface{}) error {
    //原始struct的切片值
    destSlice := reflect.ValueOf(values).Elem()
    //原始单个struct的类型
    destType := destSlice.Type().Elem()
    //遍历切片
    for j := 0; j < len(mapSliceData); j++ {
        //新建1个原始struct的类型
        dest := reflect.New(destType).Elem()
        //循环调用
        err := e.MapToStruct(mapSliceData[j], dest.Addr().Interface())
        if err != nil {
            return err
        }
        //赋值
        destSlice.Set(reflect.Append(destSlice, dest))
    }
    return nil
}

测试一下：

m1 := []map[string]string{{"created": "2021-12-12", "departname": "233", "status": "2", "uid": "131733", "username": "EE2"}, {"created": "2021-12-12", "departname": "233", "status": "2", "uid": "131733", "username": "EE2"}}
type User2 struct {
    Uid        int    `sql:"uid,auto_increment"`
    Username   string `sql:"username"`
    Departname string `sql:"departname"`
    Created    string `sql:"created"`
    Status     int64  `sql:"status"`
}
var user3 []User2
err = MapSliceToStructSlice(m1, &user3)
if err != nil {
    fmt.Println(err.Error())
    return
}
fmt.Printf("%#v", user3)

打印结果如下：

[]main.User2{main.User2{Uid:131733, Username:"EE2", Departname:"233", Created:"2021-12-12", Status:2}, main.User2{Uid:131733, Username:"EE2", Departname:"233", Created:"2021-12-12", Status:2}}