Golang如何通过反射遍历结构体_Golang 结构体遍历实践

package main

import (
    "fmt"
    "reflect"
)

// User 定义一个示例结构体
type User struct {
    ID       int    `json:"id" db:"user_id"`
    Name     string `json:"name"`
    Email    string `json:"email,omitempty"`
    Age      int    `json:"age,omitempty"`
    Password string `json:"-"` // 忽略此字段
    Address  Address
    Skills   []string
    Extra    map[string]interface{}
}

type Address struct {
    City   string `json:"city"`
    Street string `json:"street"`
}

func main() {
    user := User{
        ID:    1,
        Name:  "张三",
        Email: "zhangsan@example.com",
        Age:   30,
        Address: Address{
            City:   "北京",
            Street: "朝阳路",
        },
        Skills: []string{"Go", "Python"},
        Extra: map[string]interface{}{
            "hobby": "reading",
            "level": 5,
        },
    }

    fmt.Println("--- 遍历结构体字段 ---")
    traverseStruct(user)

    fmt.Println("\n--- 修改结构体字段（需要指针）---")
    // 注意：要修改结构体字段，必须传入结构体的指针，否则会报panic
    // Elem() 方法会返回指针指向的实际值
    ptrUser := &user
    modifyStructField(ptrUser, "Name", "李四")
    modifyStructField(ptrUser, "Age", 35)
    fmt.Printf("修改后用户: %+v\n", user)

    fmt.Println("\n--- 遍历嵌套结构体 ---")
    traverseNestedStruct(user)
}

// traverseStruct 遍历并打印结构体的所有字段信息
func traverseStruct(obj interface{}) {
    val := reflect.ValueOf(obj)
    typ := reflect.TypeOf(obj)

    // 如果传入的是指针，需要获取其指向的实际值
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
        typ = typ.Elem()
    }

    // 确保是结构体类型
    if val.Kind() != reflect.Struct {
        fmt.Printf("非结构体类型: %s\n", val.Kind())
        return
    }

    for i := 0; i < val.NumField(); i++ {
        fieldValue := val.Field(i)
        fieldType := typ.Field(i)

        fmt.Printf("字段名: %s, 类型: %s, 值: %v, Tag(json): %s\n",
            fieldType.Name,
            fieldType.Type,
            fieldValue.Interface(), // 获取字段的实际值
            fieldType.Tag.Get("json"),
        )

        // 进一步处理嵌套结构体、切片、Map等
        if fieldValue.Kind() == reflect.Struct && fieldValue.CanSet() { // CanSet() 检查是否可设置，这里只是演示
            fmt.Printf("  -> 这是一个嵌套结构体，字段名: %s\n", fieldType.Name)
            // 可以递归调用 traverseStruct(fieldValue.Interface()) 来遍历嵌套结构体
        } else if fieldValue.Kind() == reflect.Slice {
            fmt.Printf("  -> 这是一个切片，元素数量: %d\n", fieldValue.Len())
            for j := 0; j < fieldValue.Len(); j++ {
                fmt.Printf("    切片[%d]值: %v\n", j, fieldValue.Index(j).Interface())
            }
        } else if fieldValue.Kind() == reflect.Map {
            fmt.Printf("  -> 这是一个Map，元素数量: %d\n", fieldValue.Len())
            for _, key := range fieldValue.MapKeys() {
                fmt.Printf("    Map键: %v, 值: %v\n", key.Interface(), fieldValue.MapIndex(key).Interface())
            }
        }
    }
}

// modifyStructField 示例：通过反射修改结构体字段的值
func modifyStructField(obj interface{}, fieldName string, newValue interface{}) {
    val := reflect.ValueOf(obj)

    // 必须是可设置的指针类型
    if val.Kind() != reflect.Ptr || val.IsNil() {
        fmt.Println("修改失败: 必须传入非空的结构体指针")
        return
    }

    val = val.Elem() // 获取指针指向的实际值

    if val.Kind() != reflect.Struct {
        fmt.Println("修改失败: 必须是结构体类型")
        return
    }

    field := val.FieldByName(fieldName)
    if !field.IsValid() {
        fmt.Printf("修改失败: 字段 '%s' 不存在\n", fieldName)
        return
    }

    if !field.CanSet() {
        fmt.Printf("修改失败: 字段 '%s' 不可设置 (可能是非导出字段)\n", fieldName)
        return
    }

    newVal := reflect.ValueOf(newValue)
    // 确保新值的类型与字段类型兼容
    if field.Type() != newVal.Type() {
        fmt.Printf("修改失败: 字段 '%s' 类型不匹配，期望 %s, 得到 %s\n", fieldName, field.Type(), newVal.Type())
        return
    }

    field.Set(newVal)
    fmt.Printf("字段 '%s' 已修改为: %v\n", fieldName, newValue)
}

// traverseNestedStruct 遍历嵌套结构体的示例
func traverseNestedStruct(obj interface{}) {
    val := reflect.ValueOf(obj)
    typ := reflect.TypeOf(obj)

    if val.Kind() == reflect.Ptr {
        val = val.Elem()
        typ = typ.Elem()
    }

    if val.Kind() != reflect.Struct {
        return
    }

    for i := 0; i < val.NumField(); i++ {
        fieldValue := val.Field(i)
        fieldType := typ.Field(i)

        if fieldValue.Kind() == reflect.Struct {
            fmt.Printf("发现嵌套结构体: %s\n", fieldType.Name)
            // 递归遍历嵌套结构体
            traverseStruct(fieldValue.Interface())
        }
    }
}

// 示例代码片段，通常集成在遍历函数中
func getFieldTags(obj interface{}) {
    typ := reflect.TypeOf(obj)
    if typ.Kind() == reflect.Ptr {
        typ = typ.Elem()
    }
    if typ.Kind() != reflect.Struct {
        return
    }

    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        jsonTag := field.Tag.Get("json")
        dbTag, ok := field.Tag.Lookup("db") // 更安全的查找方式

        fmt.Printf("字段: %s, JSON Tag: %s", field.Name, jsonTag)
        if ok {
            fmt.Printf(", DB Tag: %s\n", dbTag)
        } else {
            fmt.Printf(", DB Tag: (不存在)\n")
        }
    }
}

// 调用示例
// user := User{...}
// getFieldTags(user)

// 示例：尝试访问非导出字段
type Secret struct {
    ExportedField   string
    unexportedField string // 非导出字段
}

func tryAccessUnexportedField(s Secret) {
    val := reflect.ValueOf(s)
    typ := reflect.TypeOf(s)

    for i := 0; i < val.NumField(); i++ {
        fieldValue := val.Field(i)
        fieldType := typ.Field(i)

        fmt.Printf("字段名: %s, 类型: %s\n", fieldType.Name, fieldType.Type)

        // 检查字段是否可以被设置或获取值
        if fieldValue.CanSet() {
            fmt.Printf("  -> 可以设置，值: %v\n", fieldValue.Interface())
        } else {
            fmt.Printf("  -> 不可设置。尝试获取值会 panic。\n")
            // 警告：以下代码会引发 panic
            // fmt.Printf("  -> 值: %v\n", fieldValue.Interface())
        }
    }
}

// 调用示例
// secret := Secret{ExportedField: "Hello", unexportedField: "World"}
// tryAccessUnexportedField(secret)