Go语言中从嵌入结构体方法反射外部结构体字段的实践与陷阱

package main

import (
    "fmt"
    "reflect"
)

type Inner struct {
}

type Outer struct {
    Inner
    Id   int
    name string // 小写字母开头的字段是私有的
}

func (i *Inner) Fields() map[string]bool {
    // 这里的 *i 指向的是 Inner 类型本身，而不是 Outer
    typ := reflect.TypeOf(*i)
    attrs := make(map[string]bool)

    if typ.Kind() != reflect.Struct {
        fmt.Printf("%v type can't have attributes inspected\n", typ.Kind())
        return attrs
    }

    for j := 0; j < typ.NumField(); j++ {
        p := typ.Field(j)
        // 这里的逻辑尝试获取字段的 CanSet 属性，但它作用于 reflect.Type，通常不正确
        // 正确的做法是获取 reflect.Value 后再检查 CanSet
        attrs[p.Name] = true // 简化为直接添加字段名
    }

    return attrs
}

func main() {
    val := Outer{}
    fmt.Println(val.Fields()) // 预期 map[Id:true name:true]，实际输出 map[]
}

package main

import (
    "fmt"
    "reflect"
)

// Persistable 接口定义了获取结构体字段信息的方法
type Persistable interface {
    GetFields() map[string]bool
}

type Inner struct {
    // Inner 可以包含一些通用的持久化逻辑，但不直接反射外部结构体
}

type Outer struct {
    Inner // 嵌入 Inner
    Id    int
    Name  string // 字段名大写，以便反射可以访问
}

// GetFields 为 Outer 结构体实现 Persistable 接口
func (o *Outer) GetFields() map[string]bool {
    typ := reflect.TypeOf(*o)
    attrs := make(map[string]bool)

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

    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        // 忽略嵌入字段本身，只处理 Outer 自己的字段
        if field.Anonymous && field.Type == reflect.TypeOf(Inner{}) {
            continue
        }
        // 检查字段是否可导出（首字母大写）
        if field.IsExported() {
            attrs[field.Name] = true
        }
    }
    return attrs
}

// 假设有一个通用的持久化函数
func Save(p Persistable) {
    fmt.Printf("Saving fields: %v\n", p.GetFields())
    // ... 实际的数据库保存逻辑
}

func main() {
    val := Outer{Id: 1, Name: "Test"}
    Save(&val) // 输出: Saving fields: map[Id:true Name:true]
}

package main

import (
    "fmt"
    "reflect"
)

type Inner struct {
    // ... 可以在这里放置一些通用的方法或字段，但与反射外部结构体无关
}

type Outer struct {
    Inner
    Id   int
    Name string // 字段名大写，以便反射可以访问
}

// GetStructFields 是一个泛型函数，用于反射任何结构体的字段
func GetStructFields(obj interface{}) map[string]bool {
    typ := reflect.TypeOf(obj)
    // 如果传入的是指针，则获取其指向的元素类型
    if typ.Kind() == reflect.Ptr {
        typ = typ.Elem()
    }

    attrs := make(map[string]bool)
    if typ.Kind() != reflect.Struct {
        fmt.Printf("%v is not a struct type\n", typ.Kind())
        return attrs
    }

    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        // 忽略嵌入字段本身，只处理外部结构体自身的字段或其可导出的嵌入字段
        // 如果是匿名字段，且是Inner类型，则跳过
        if field.Anonymous && field.Type == reflect.TypeOf(Inner{}) {
            continue
        }
        if field.IsExported() { // 检查字段是否可导出
            attrs[field.Name] = true
        }
    }
    return attrs
}

func main() {
    val := Outer{Id: 10, Name: "Example"}
    // 直接将 Outer 实例传递给泛型函数
    fmt.Println(GetStructFields(val))  // map[Id:true Name:true]
    fmt.Println(GetStructFields(&val)) // map[Id:true Name:true]
}

package main

import (
    "fmt"
    "reflect"
)

type Inner struct {
}

type Outer struct {
    Inner
    Id   int
    Name string
}

// FieldsOfOuter 方法现在显式地接收 *Outer 类型的参数
func (i *Inner) FieldsOfOuter(outer *Outer) map[string]bool {
    typ := reflect.TypeOf(*outer) // 现在反射的是 Outer 类型
    attrs := make(map[string]bool)

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

    for j := 0; j < typ.NumField(); j++ {
        p := typ.Field(j)
        // 忽略嵌入字段本身
        if p.Anonymous && p.Type == reflect.TypeOf(Inner{}) {
            continue
        }
        if p.IsExported() {
            attrs[p.Name] = true
        }
    }
    return attrs
}

func main() {
    val := Outer{Id: 1, Name: "Test"}
    // 显式传递 val 的地址
    fmt.Println(val.Inner.FieldsOfOuter(&val)) // map[Id:true Name:true]
}

package main

import (
    "fmt"
    "reflect"
    "unsafe" // 引入 unsafe 包
)

type Inner struct {
}

type Outer struct {
    Inner
    Id   int
    Name string // 字段名大写，以便反射可以访问
}

func (i *Inner) FieldsUnsafe() map[string]bool {
    // 将 *Inner 类型的指针转换为 *Outer 类型的指针
    // 这假设 i 确实被嵌入在一个 Outer 实例中
    outer := (*Outer)(unsafe.Pointer(i))
    typ := reflect.TypeOf(*outer) // 现在反射的是 Outer 类型
    attrs := make(map[string]bool)

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

    for j := 0; j < typ.NumField(); j++ {
        p := typ.Field(j)
        // 忽略嵌入字段本身
        if p.Anonymous && p.Type == reflect.TypeOf(Inner{}) {
            continue
        }
        if p.IsExported() {
            attrs[p.Name] = true
        }
    }
    return attrs
}

func main() {
    val := Outer{Id: 100, Name: "Unsafe Example"}
    fmt.Println(val.FieldsUnsafe()) // map[Id:true Name:true]
}