Go语言：使用反射动态调用结构体方法

package main

import (
    "fmt"
    "reflect"
)

// MyStruct 定义一个示例结构体
type MyStruct struct {
    Name string
}

// MyMethod 定义一个MyStruct的指针接收者方法，无参数无返回值
func (p *MyStruct) MyMethod() {
    fmt.Printf("MyMethod called on %s. This is a dynamic call!\n", p.Name)
}

// AnotherMethod 定义一个MyStruct的值接收者方法，无参数无返回值
func (p MyStruct) AnotherMethod() {
    fmt.Printf("AnotherMethod called on %s. This is a value receiver method.\n", p.Name)
}

func main() {
    // 1. 实例化结构体
    myInstance := &MyStruct{Name: "ReflectExample"} // 对于指针接收者方法，需要传入地址

    // 2. 获取结构体实例的反射值
    // 注意：如果MyMethod是*MyStruct接收者，这里必须传入指针
    value := reflect.ValueOf(myInstance)

    // 3. 查找名为"MyMethod"的方法
    method := value.MethodByName("MyMethod")

    // 4. 检查方法是否存在且可调用
    if !method.IsValid() {
        fmt.Println("错误：方法 MyMethod 不存在或不可调用。请检查方法名和可见性（是否导出）。")
        return
    }

    // 5. 调用方法
    // 因为MyMethod没有参数，所以传入一个空的reflect.Value切片
    method.Call([]reflect.Value{})

    fmt.Println("--------------------")

    // 示例：调用值接收者方法
    myValueInstance := MyStruct{Name: "ValueReceiver"}
    // 对于值接收者方法，可以直接传入值
    valueForValueMethod := reflect.ValueOf(myValueInstance)
    anotherMethod := valueForValueMethod.MethodByName("AnotherMethod")

    if !anotherMethod.IsValid() {
        fmt.Println("错误：方法 AnotherMethod 不存在或不可调用。")
        return
    }
    anotherMethod.Call([]reflect.Value{})

    fmt.Println("--------------------")

    // 尝试调用不存在的方法
    invalidMethod := value.MethodByName("NonExistentMethod")
    if !invalidMethod.IsValid() {
        fmt.Println("提示：NonExistentMethod 不存在，IsValid() 返回 false，符合预期。")
    }
}

package main

import (
    "fmt"
    "reflect"
)

type Calculator struct {
    Result int
}

// Add 是一个带参数和返回值的指针接收者方法
func (c *Calculator) Add(a, b int) (sum int, err error) {
    if a < 0 || b < 0 {
        return 0, fmt.Errorf("numbers must be non-negative")
    }
    c.Result = a + b
    return c.Result, nil
}

// GetResult 是一个无参数带返回值的指针接收者方法
func (c *Calculator) GetResult() int {
    return c.Result
}

func main() {
    calc := &Calculator{} // 实例化计算器

    // 获取反射值
    calcValue := reflect.ValueOf(calc)

    // 1. 动态调用带参数和返回值的方法: Add
    addMethod := calcValue.MethodByName("Add")
    if !addMethod.IsValid() {
        fmt.Println("Add 方法不存在。")
        return
    }

    // 准备方法参数：将Go类型转换为reflect.Value
    args := []reflect.Value{
        reflect.ValueOf(10), // 第一个参数 a
        reflect.ValueOf(20), // 第二个参数 b
    }

    // 调用方法并获取返回值
    results := addMethod.Call(args)

    // 处理返回值
    if len(results) == 2 { // Add 方法有两个返回值 (int, error)
        sum := results[0].Interface().(int) // 提取第一个返回值 (int)
        errResult := results[1].Interface() // 提取第二个返回值 (error)

        fmt.Printf("调用 Add(10, 20) 结果: Sum = %d, Error = %v\n", sum, errResult)
        fmt.Printf("Calculator.Result after Add: %d\n", calc.Result)
    }

    fmt.Println("--------------------")

    // 2. 动态调用带参数且返回错误的方法示例 (传入负数)
    negativeArgs := []reflect.Value{
        reflect.ValueOf(-5),
        reflect.ValueOf(10),
    }
    negativeResults := addMethod.Call(negativeArgs)
    if len(negativeResults) == 2 {
        sum := negativeResults[0].Interface().(int)
        errResult := negativeResults[1].Interface()
        fmt.Printf("调用 Add(-5, 10) 结果: Sum = %d, Error = %v\n", sum, errResult)
    }

    fmt.Println("--------------------")

    // 3. 动态调用无参数带返回值的方法: GetResult
    getResultMethod := calcValue.MethodByName("GetResult")
    if !getResultMethod.IsValid() {
        fmt.Println("GetResult 方法不存在。")
        return
    }

    // 调用方法，无参数传入空切片
    getResultResults := getResultMethod.Call([]reflect.Value{})

    // 处理返回值
    if len(getResultResults) == 1 { // GetResult 方法有一个返回值 (int)
        currentResult := getResultResults[0].Interface().(int) // 提取返回值
        fmt.Printf("调用 GetResult() 结果: %d\n", currentResult)
    }
}