如何用Golang通过反射获取字段类型_Golang 反射字段类型获取实践

package main

import (
    "fmt"
    "reflect"
)

// Address 是一个嵌套结构体
type Address struct {
    City    string `json:"city"`
    ZipCode int    `json:"zip_code"`
}

// User 包含多种字段类型，包括基本类型、嵌套结构体、切片、指针和匿名字段
type User struct {
    Name    string    `json:"name" validate:"required"`
    Age     int       `json:"age"`
    Email   string    `json:"email"`
    Address Address   `json:"address"`
    Tags    []string  `json:"tags"`
    Secret  *string   `json:"secret,omitempty"` // 指针类型
    // 匿名字段，它本身也是一个类型，但其字段会被提升到User层面
    ID string `json:"id"` // 这是一个匿名字段，等同于 struct { ID string }
}

func main() {
    u := User{
        Name:  "张三",
        Age:   30,
        Email: "zhangsan@example.com",
        Address: Address{
            City:    "北京",
            ZipCode: 100000,
        },
        Tags: []string{"developer", "golang"},
        ID:   "user_123",
    }

    // 为了演示指针字段，我们给Secret赋值
    secretVal := "my_secret_key"
    u.Secret = &secretVal

    // 获取User实例的类型。reflect.TypeOf会返回值的动态类型。
    t := reflect.TypeOf(u)

    // 如果传入的是指针，需要用Elem()解引用才能获取到实际结构体的类型信息。
    // 比如：tPtr := reflect.TypeOf(&u)
    // if tPtr.Kind() == reflect.Ptr {
    //  t = tPtr.Elem()
    // }

    // 确保我们处理的是结构体类型
    if t.Kind() != reflect.Struct {
        fmt.Printf("错误：传入的不是结构体类型，而是 %s\n", t.Kind())
        return
    }

    fmt.Printf("结构体 %s 有 %d 个字段:\n", t.Name(), t.NumField())

    // 遍历结构体的所有字段
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i) // field 是 reflect.StructField 类型

        // field.Name: 字段名称 (如 "Name", "Age")
        // field.Type.String(): 字段的完整类型字符串 (如 "string", "int", "main.Address", "[]string", "*string")
        // field.Type.Kind(): 字段的基础种类 (如 reflect.String, reflect.Int, reflect.Struct, reflect.Slice, reflect.Ptr)
        // field.Anonymous: 是否是匿名字段
        // field.Tag: 字段的标签，可以通过 .Get("key") 获取特定标签值

        fmt.Printf("  字段名: %-8s | 类型: %-15s | Kind: %-8s | 匿名: %t | Tag(json): %s\n",
            field.Name,
            field.Type.String(),
            field.Type.Kind(),
            field.Anonymous,
            field.Tag.Get("json"),
        )

        // 进一步处理复杂类型：嵌套结构体、切片、指针
        if field.Type.Kind() == reflect.Struct && !field.Anonymous {
            // 这是一个非匿名的嵌套结构体
            fmt.Printf("    - 这是一个嵌套结构体 '%s'，其内部字段:\n", field.Type.Name())
            for j := 0; j < field.Type.NumField(); j++ {
                nestedField := field.Type.Field(j)
                fmt.Printf("      字段名: %-8s | 类型: %-10s | Kind: %-8s | Tag(json): %s\n",
                    nestedField.Name,
                    nestedField.Type.String(),
                    nestedField.Type.Kind(),
                    nestedField.Tag.Get("json"),
                )
            }
        } else if field.Type.Kind() == reflect.Slice {
            // 这是一个切片类型，通过 Elem() 获取其元素类型
            fmt.Printf("    - 这是一个切片类型，元素类型是: %s (Kind: %s)\n",
                field.Type.Elem().String(),
                field.Type.Elem().Kind(),
            )
        } else if field.Type.Kind() == reflect.Ptr {
            // 这是一个指针类型，通过 Elem() 获取其指向的元素类型
            fmt.Printf("    - 这是一个指针类型，指向的元素类型是: %s (Kind: %s)\n",
                field.Type.Elem().String(),
                field.Type.Elem().Kind(),
            )
        }
    }
}