Go 嵌入结构体方法反射外部结构体字段的策略与实践

package main

import (
    "fmt"
    "reflect"
)

type Inner struct {
    // Inner 结构体本身没有额外的字段
}

type Outer struct {
    Inner        // 嵌入 Inner 结构体
    Id   int     // 外部结构体字段
    name string  // 外部结构体字段
}

// Fields 方法定义在 Inner 结构体上
func (i *Inner) Fields() map[string]bool {
    // 这里 typ 始终是 reflect.TypeOf(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 fieldIndex := 0; fieldIndex < typ.NumField(); fieldIndex++ {
        p := typ.Field(fieldIndex)
        // 这里的逻辑主要是为了演示，实际 CanSet 需要 reflect.Value
        // 但核心问题是 typ 已经是 Inner 类型
        attrs[p.Name] = true // 简化为只记录字段名
    }

    return attrs
}

func main() {
    val := Outer{}
    // 调用 Outer 实例的 Fields 方法，实际上是调用了 Inner 的 Fields 方法
    fmt.Println(val.Fields()) // 输出: map[]，而不是期望的 map[Id:true name:true]
}

package main

import (
    "fmt"
    "reflect"
)

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

type Inner struct {
    // Inner 结构体
}

type Outer struct {
    Inner
    Id   int
    Name string // 导出字段，便于反射
}

// GetFields 方法现在定义在 Outer 结构体上
func (o *Outer) GetFields() map[string]bool {
    attrs := make(map[string]bool)
    // 反射 Outer 结构体自身
    typ := reflect.TypeOf(*o)

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

    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        // 忽略匿名字段（即嵌入的 Inner 字段本身），只关注 Outer 自己的字段
        if !field.Anonymous {
            attrs[field.Name] = true
        }
    }
    return attrs
}

func main() {
    val := Outer{}
    // 直接调用 Outer 实例的 GetFields 方法
    fmt.Println(val.GetFields()) // 输出: map[Id:true Name:true]

    // 也可以通过接口调用
    var accessor FieldAccessor = &val
    fmt.Println(accessor.GetFields()) // 输出: map[Id:true Name:true]
}

package main

import (
    "fmt"
    "reflect"
)

type Inner struct {
    // Inner 结构体
}

type Outer struct {
    Inner
    Id   int
    Name string
}

// GetStructFieldNames 是一个通用函数，用于获取任何结构体的字段名
func GetStructFieldNames(s interface{}) map[string]bool {
    attrs := make(map[string]bool)
    val := reflect.ValueOf(s)

    // 如果传入的是指针，则解引用
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }

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

    typ := val.Type()
    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        // 同样，可以根据需求过滤匿名字段
        if !field.Anonymous {
            attrs[field.Name] = true
        }
    }
    return attrs
}

func main() {
    val := Outer{}
    // 将 Outer 实例传递给通用函数
    fmt.Println(GetStructFieldNames(val))   // 输出: map[Id:true Name:true]
    fmt.Println(GetStructFieldNames(&val))  // 输出: map[Id:true Name:true]
}

package main

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

type Inner struct {
    // Inner 结构体
}

type Outer struct {
    Inner
    Id   int
    Name string
}

// FieldsUnsafe 方法尝试通过 unsafe.Pointer 访问外部结构体
func (i *Inner) FieldsUnsafe() map[string]bool {
    attrs := make(map[string]bool)

    // 假设我们知道 Inner 总是嵌入在 Outer 中
    // 将 Inner 的指针强制转换为 Outer 的指针
    outer := (*Outer)(unsafe.Pointer(i))

    // 现在反射 Outer 结构体
    typ := reflect.TypeOf(*outer)

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

    for fieldIndex := 0; fieldIndex < typ.NumField(); fieldIndex++ {
        p := typ.Field(fieldIndex)
        if !p.Anonymous { // 过滤掉 Inner 自身（作为匿名字段）
            attrs[p.Name] = true
        }
    }

    return attrs
}

func main() {
    val := Outer{}
    fmt.Println(val.FieldsUnsafe()) // 输出: map[Id:true Name:true]
}