Golang使用reflect遍历结构体字段实践

reflect

reflect

reflect.Type

reflect.Value

package main

import (
    "fmt"
    "reflect"
)

// User 示例结构体，包含不同类型的字段和结构体标签
type User struct {
    Name    string `json:"user_name" db:"name"` // 包含json和db标签
    Age     int    `json:"user_age" db:"age"`
    IsAdmin bool   `json:"is_admin,omitempty"` // 包含omitempty选项
    secret  string // 小写字段，不可导出
}

// Product 示例结构体，包含匿名嵌入的User结构体
type Product struct {
    ID    int
    Name  string
    Price float64
    User  // 匿名嵌入结构体，字段会提升到Product层面
}

func main() {
    fmt.Println("--- 遍历 User 结构体 ---")
    user := User{Name: "Alice", Age: 30, IsAdmin: true, secret: "super_secret"}
    inspectStruct(user) // 传入值类型

    fmt.Println("\n--- 遍历 Product 结构体 (含匿名嵌入) ---")
    product := Product{
        ID:    1,
        Name:  "Go Book",
        Price: 49.99,
        User:  User{Name: "Bob", Age: 25, IsAdmin: false},
    }
    inspectStruct(product) // 传入值类型

    fmt.Println("\n--- 尝试修改 User 结构体字段 (传入指针) ---")
    ptrUser := &User{Name: "Charlie", Age: 20} // 传入指针才能修改
    modifyStructField(ptrUser, "Age", 21)
    fmt.Printf("修改后: %+v\n", ptrUser)

    modifyStructField(ptrUser, "Name", "Charles")
    fmt.Printf("修改后: %+v\n", ptrUser)

    modifyStructField(ptrUser, "secret", "new_secret") // 尝试修改不可导出字段
}

// inspectStruct 函数用于接收一个接口类型的值，并利用反射遍历其字段
func inspectStruct(s interface{}) {
    val := reflect.ValueOf(s) // 获取值的反射对象
    typ := reflect.TypeOf(s)  // 获取类型的反射对象

    // 如果传入的是指针，我们需要获取它指向的实际元素
    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 < typ.NumField(); i++ {
        field := typ.Field(i)       // 获取字段的 Type 信息
        fieldValue := val.Field(i) // 获取字段的 Value 信息

        fmt.Printf("字段名: %s, 类型: %s, 值: %v, 可导出: %t, 可设置: %t\n",
            field.Name,               // 字段名
            field.Type,               // 字段类型
            fieldValue.Interface(),   // 字段值 (以interface{}形式)
            field.IsExported(),       // 字段是否可导出 (大写开头)
            fieldValue.CanSet(),      // 字段值是否可设置 (需要可导出且传入的是指针)
        )

        // 处理结构体标签 (struct tags)
        if field.Tag != "" {
            fmt.Printf("  - 原始Tag: `%s`\n", field.Tag)
            fmt.Printf("  - JSON Tag: %s\n", field.Tag.Get("json")) // 获取json标签的值
            fmt.Printf("  - DB Tag: %s\n", field.Tag.Get("db"))   // 获取db标签的值
        }

        // 递归处理匿名嵌入的结构体
        // field.Anonymous 为 true 表示这是一个匿名嵌入字段
        if field.Anonymous && field.Type.Kind() == reflect.Struct {
            fmt.Printf("  (发现匿名嵌入结构体: %s, 递归遍历)\n", field.Name)
            inspectStruct(fieldValue.Interface()) // 递归调用自身处理嵌入结构体
        }
    }
}

// modifyStructField 示例如何通过反射修改字段值
// 注意：要修改结构体字段，必须传入结构体的指针，并且字段必须是可导出的。
func modifyStructField(s interface{}, fieldName string, newValue interface{}) {
    val := reflect.ValueOf(s)
    // 检查是否是有效的非空指针
    if val.Kind() != reflect.Ptr || val.IsNil() {
        fmt.Println("错误: 修改字段需要传入非空的结构体指针。")
        return
    }

    elem := val.Elem() // 获取指针指向的实际值 (结构体本身)
    if elem.Kind() != reflect.Struct {
        fmt.Println("错误: 传入的指针不是指向结构体。")
        return
    }

    field := elem.FieldByName(fieldName) // 根据字段名查找字段
    if !field.IsValid() {
        fmt.Printf("错误: 字段 '%s' 不存在。\n", fieldName)
        return
    }

    if !field.CanSet() {
        fmt.Printf("错误: 字段 '%s' 不可设置 (可能未导出或未传入结构体指针)。\n", fieldName)
        return
        // 尝试设置不可导出字段会引发panic，这里提前检查避免
    }

    newVal := reflect.ValueOf(newValue)
    // 检查新值的类型是否可以转换为字段的类型
    if !newVal.Type().ConvertibleTo(field.Type()) {
        fmt.Printf("错误: 新值类型 %s 无法转换为字段 '%s' 的类型 %s。\n", newVal.Type(), fieldName, field.Type())
        return
    }

    field.Set(newVal.Convert(field.Type())) // 设置字段的新值
    fmt.Printf("信息: 字段 '%s' 已成功修改为 %v。\n", fieldName, newValue)
}

reflect

reflect

reflect

reflect