Go语言反射：跨越接收器类型，动态调用interface{}方法

package main

import (
    "fmt"
    "reflect"
)

type Test struct {
    Start string
}

func (t *Test) Finish() string { // 指针接收器方法
    return t.Start + "finish"
}

func Pass(i interface{}) {
    // 这里的&i是对interface{}类型本身取地址，而不是其内部存储的具体值
    // 因此reflect.TypeOf(&i)得到的是*interface{}的类型，而不是*Test的类型
    _, ok := reflect.TypeOf(&i).MethodByName("Finish")
    if ok {
        fmt.Println(reflect.ValueOf(&i).MethodByName("Finish").Call([]reflect.Value{})[0])
    } else {
        fmt.Println("Pass() fail") // 这里会失败
    }
}

func main() {
    i := Test{Start: "start"}

    Pass(i) // 传入的是Test值类型

    // 这里i是main函数局部变量Test类型，&i是*Test类型，可以正确找到方法
    _, ok := reflect.TypeOf(&i).MethodByName("Finish")
    if ok {
        fmt.Println(reflect.ValueOf(&i).MethodByName("Finish").Call([]reflect.Value{})[0])
    } else {
        fmt.Println("main() fail")
    }
}

Pass() fail
startfinish

package main

import (
    "fmt"
    "reflect"
)

// 定义一个结构体
type Test struct {
    Start string
}

// 值接收器方法
func (t Test) Finish() string {
    return t.Start + "finish"
}

// 指针接收器方法
func (t *Test) Another() string {
    return t.Start + "another"
}

// CallMethod 动态调用interface{}中存储的对象的指定方法
// i: 包含目标对象的interface{}
// methodName: 要调用的方法名
func CallMethod(i interface{}, methodName string) interface{} {
    var ptrValue reflect.Value // 存储对象的指针形式的reflect.Value
    var actualValue reflect.Value // 存储对象的值形式的reflect.Value
    var finalMethod reflect.Value // 最终找到的方法

    // 1. 获取interface{}中实际存储的值的reflect.Value
    initialValue := reflect.ValueOf(i)

    // 2. 根据initialValue的类型，规范化出ptrValue和actualValue
    if initialValue.Type().Kind() == reflect.Ptr {
        // 如果initialValue本身就是指针类型（例如传入的是&Test{}）
        ptrValue = initialValue
        actualValue = initialValue.Elem() // 获取指针指向的值
    } else {
        // 如果initialValue是值类型（例如传入的是Test{}）
        actualValue = initialValue
        // 创建一个指向这个值的新指针
        ptrValue = reflect.New(initialValue.Type())
        // 将值设置到新创建的指针所指向的位置
        ptrValue.Elem().Set(initialValue)
    }

    // 3. 在值形式上查找方法
    method := actualValue.MethodByName(methodName)
    if method.IsValid() {
        finalMethod = method
    }

    // 4. 在指针形式上查找方法 (如果值形式上没有找到，或者为了覆盖所有情况)
    // 注意：Go的方法集规则，值类型的方法集包含所有值接收器方法，
    // 指针类型的方法集包含所有值接收器和指针接收器方法。
    // 因此，这里检查ptrValue可以找到所有可能的方法。
    if !finalMethod.IsValid() { // 只有在值形式上没找到时才检查指针形式
        method = ptrValue.MethodByName(methodName)
        if method.IsValid() {
            finalMethod = method
        }
    }

    // 5. 如果找到了有效方法，则调用它并返回结果
    if finalMethod.IsValid() {
        // 调用方法，不带参数，并获取第一个返回值
        // .Interface() 将reflect.Value转换回interface{}
        return finalMethod.Call([]reflect.Value{})[0].Interface()
    }

    // 如果方法未找到，返回空字符串或panic，根据业务需求决定
    return ""
}

func main() {
    i := Test{Start: "start"} // 值类型实例
    j := Test{Start: "start2"} // 另一个值类型实例

    // 测试值接收器方法 "Finish"
    fmt.Println(CallMethod(i, "Finish"))    // 传入值类型，调用值接收器方法
    fmt.Println(CallMethod(&i, "Finish"))   // 传入指针类型，调用值接收器方法

    // 测试指针接收器方法 "Another"
    fmt.Println(CallMethod(i, "Another"))   // 传入值类型，调用指针接收器方法
    fmt.Println(CallMethod(&i, "Another"))  // 传入指针类型，调用指针接收器方法

    // 再次测试，确保逻辑的通用性
    fmt.Println(CallMethod(j, "Finish"))
    fmt.Println(CallMethod(&j, "Finish"))
    fmt.Println(CallMethod(j, "Another"))
    fmt.Println(CallMethod(&j, "Another"))
}

startfinish
startfinish
startanother
startanother
start2finish
start2finish
start2another
start2another