Go语言中通过反射动态调用接口类型方法：处理值接收者与指针接收者的通用方案

package main

import (
    "fmt"
    "reflect"
)

type Test struct {
    Start string
}

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

func Pass(i interface{}) {
    // 尝试在 interface{} 的地址上查找方法
    // reflect.TypeOf(&i) 实际上是 *interface{} 类型，而非底层数据的指针类型
    _, 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 函数
    Pass(i)

    // 在 main 函数中直接对 *Test 类型查找方法
    _, ok := reflect.TypeOf(&i).MethodByName("Finish") // 这里 &i 是 *Test 类型
    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"
)

// Test 结构体
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{} 中的方法
func CallMethod(i interface{}, methodName string) interface{} {
    var ptr reflect.Value   // 用于存储数据的指针形式
    var value reflect.Value // 用于存储数据的值形式
    var finalMethod reflect.Value // 最终找到的方法

    // 1. 获取 interface{} 中实际存储数据的 reflect.Value
    value = reflect.ValueOf(i)

    // 2. 标准化为值和指针形式
    // 如果原始数据是指针类型，则获取其指向的值
    if value.Type().Kind() == reflect.Ptr {
        ptr = value
        value = ptr.Elem() // 获取指针指向的元素（值）
    } else {
        // 如果原始数据是值类型，则创建一个指向该值的指针
        ptr = reflect.New(reflect.TypeOf(i)) // 创建一个新指针，类型为 *i.Type()
        temp := ptr.Elem()                   // 获取新指针指向的元素（值）
        temp.Set(value)                      // 将原始值设置给新指针指向的元素
    }

    // 3. 在值和指针形式上查找方法
    // 尝试在值形式上查找方法
    method := value.MethodByName(methodName)
    if method.IsValid() {
        finalMethod = method
    }

    // 尝试在指针形式上查找方法（如果值形式未找到，或者方法定义在指针接收者上）
    // 注意：如果值形式已找到，这里会优先使用指针形式的方法，这取决于业务需求。
    // 一般情况下，我们会优先匹配最直接的，但这里为了确保找到，可以覆盖。
    // 更严谨的做法是：如果finalMethod已经IsValid()，则不再尝试。
    // 但为了兼容所有情况，这里简单覆盖，确保找到的是有效方法。
    method = ptr.MethodByName(methodName)
    if method.IsValid() {
        finalMethod = method
    }

    // 4. 调用找到的方法
    if finalMethod.IsValid() {
        // 调用方法，并返回第一个结果的 Interface()
        // 这里假设方法没有参数，且返回至少一个值
        return finalMethod.Call([]reflect.Value{})[0].Interface()
    }

    // 如果方法未找到，返回空字符串或 panic，取决于错误处理策略
    return ""
}

func main() {
    // 实例化 Test 结构体
    i := Test{Start: "start"}
    j := Test{Start: "start2"}

    fmt.Println("--- 调用 i (值类型) ---")
    // 调用值接收者方法
    fmt.Println(CallMethod(i, "Finish"))
    // 调用指针接收者方法 (CallMethod 会自动创建指针)
    fmt.Println(CallMethod(i, "Another"))

    fmt.Println("\n--- 调用 &i (指针类型) ---")
    // 调用值接收者方法 (CallMethod 会获取指针指向的值)
    fmt.Println(CallMethod(&i, "Finish"))
    // 调用指针接收者方法
    fmt.Println(CallMethod(&i, "Another"))

    fmt.Println("\n--- 调用 j (值类型) ---")
    fmt.Println(CallMethod(j, "Finish"))
    fmt.Println(CallMethod(j, "Another"))

    fmt.Println("\n--- 调用 &j (指针类型) ---")
    fmt.Println(CallMethod(&j, "Finish"))
    fmt.Println(CallMethod(&j, "Another"))
}

--- 调用 i (值类型) ---
startfinish
startanother

--- 调用 &i (指针类型) ---
startfinish
startanother

--- 调用 j (值类型) ---
start2finish
start2another

--- 调用 &j (指针类型) ---
start2finish
start2another