Golang如何通过反射获取嵌套结构体类型_Golang 嵌套结构体类型获取实践

package main

import (
    "fmt"
    "reflect"
)

type Address struct {
    Street  string `json:"street_name"`
    City    string `json:"city_name"`
    ZipCode string `json:"zip_code,omitempty"`
}

type User struct {
    ID      int       `json:"id"`
    Name    string    `json:"user_name"`
    Email   string    `json:"email_addr"`
    Contact Address   `json:"contact_info"` // 嵌套结构体
    Details *Metadata `json:"user_details"` // 嵌套结构体指针
    Secret  `json:"-"` // 匿名嵌套结构体
}

type Metadata struct {
    LastLogin string `json:"last_login"`
    IPAddress string `json:"ip_address"`
}

type Secret struct {
    PasswordHash string `json:"password_hash"`
    TwoFactorKey string `json:"two_factor_key"`
}

func printStructFields(t reflect.Type, indent string) {
    if t.Kind() == reflect.Ptr { // 如果是指针，获取其指向的元素类型
        t = t.Elem()
    }
    if t.Kind() != reflect.Struct {
        // fmt.Printf("%sType is not a struct: %s\n", indent, t.String())
        return
    }

    fmt.Printf("%sStruct Type: %s\n", indent, t.String())
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("%s  Field Name: %s, Type: %s, Tag: %s\n", indent, field.Name, field.Type.String(), field.Tag)

        // 检查字段是否是结构体或结构体指针，然后递归处理
        if field.Type.Kind() == reflect.Struct || (field.Type.Kind() == reflect.Ptr && field.Type.Elem().Kind() == reflect.Struct) {
            fmt.Printf("%s  (Nested Struct/Pointer to Struct)\n", indent)
            printStructFields(field.Type, indent+"    ") // 递归调用，增加缩进
        }
    }
}

func main() {
    user := User{
        ID:    1,
        Name:  "Alice",
        Email: "alice@example.com",
        Contact: Address{
            Street:  "123 Main St",
            City:    "Anytown",
            ZipCode: "12345",
        },
        Details: &Metadata{
            LastLogin: "2023-10-27",
            IPAddress: "192.168.1.1",
        },
        Secret: Secret{
            PasswordHash: "somehash",
            TwoFactorKey: "somekey",
        },
    }

    userType := reflect.TypeOf(user)
    fmt.Println("--- Traversing User Struct ---")
    printStructFields(userType, "")
}

type User struct {
    // ...
    Secret  `json:"-"` // 匿名嵌套结构体
}

// 延续上面的printStructFields函数，稍作修改
func printStructFieldsWithAnonymousCheck(t reflect.Type, indent string) {
    if t.Kind() == reflect.Ptr {
        t = t.Elem()
    }
    if t.Kind() != reflect.Struct {
        return
    }

    fmt.Printf("%sStruct Type: %s\n", indent, t.String())
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        anonymousIndicator := ""
        if field.Anonymous {
            anonymousIndicator = " (Anonymous Field)"
        }
        fmt.Printf("%s  Field Name: %s%s, Type: %s, Tag: %s\n", indent, field.Name, anonymousIndicator, field.Type.String(), field.Tag)

        if field.Type.Kind() == reflect.Struct || (field.Type.Kind() == reflect.Ptr && field.Type.Elem().Kind() == reflect.Struct) {
            fmt.Printf("%s  (Nested Struct/Pointer to Struct)\n", indent)
            printStructFieldsWithAnonymousCheck(field.Type, indent+"    ")
        }
    }
}

// 在main函数中调用
// fmt.Println("\n--- Traversing User Struct with Anonymous Check ---")
// printStructFieldsWithAnonymousCheck(userType, "")

// 沿用之前的结构体定义
// type Address struct {
//  Street  string `json:"street_name"`
//  City    string `json:"city_name"`
//  ZipCode string `json:"zip_code,omitempty"`
// }

// type User struct {
//  ID      int       `json:"id"`
//  Name    string    `json:"user_name"`
//  Email   string    `json:"email_addr"`
//  Contact Address   `json:"contact_info"` // 嵌套结构体
//  Details *Metadata `json:"user_details"` // 嵌套结构体指针
//  Secret  `json:"-"` // 匿名嵌套结构体
// }

// ...

func extractFieldTags(t reflect.Type, indent string) {
    if t.Kind() == reflect.Ptr {
        t = t.Elem()
    }
    if t.Kind() != reflect.Struct {
        return
    }

    fmt.Printf("%sProcessing Struct: %s\n", indent, t.String())
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("%s  Field Name: %s\n", indent, field.Name)

        // 获取原始标签字符串
        rawTag := string(field.Tag)
        fmt.Printf("%s    Raw Tag: \"%s\"\n", indent, rawTag)

        // 使用StructTag的Get方法获取特定键的值
        jsonTag := field.Tag.Get("json")
        if jsonTag != "" {
            fmt.Printf("%s    JSON Tag Value: \"%s\"\n", indent, jsonTag)
        } else {
            fmt.Printf("%s    No 'json' tag found.\n", indent)
        }

        // 检查是否存在某个键
        if _, ok := field.Tag.Lookup("omitempty"); ok {
            fmt.Printf("%s    'omitempty' option is present.\n", indent)
        }

        // 如果字段是嵌套结构体，递归处理
        if field.Type.Kind() == reflect.Struct || (field.Type.Kind() == reflect.Ptr && field.Type.Elem().Kind() == reflect.Struct) {
            fmt.Printf("%s    (Diving into nested struct for tags)\n", indent)
            extractFieldTags(field.Type, indent+"      ")
        }
    }
}

func main() {
    // ... (user struct initialization as before)

    userType := reflect.TypeOf(user)
    fmt.Println("\n--- Extracting Field Tags from User Struct ---")
    extractFieldTags(userType, "")
}