Go语言中利用反射精简重复函数：reflect.MakeFunc实践指南

package main

import (
    "fmt"
    "log"
    "reflect"
)

// Foo 示例结构体
type Foo struct {
    ID   int
    Name string
}

// makeRequestFunc 是一个通用函数，用于动态创建请求函数
// req: 标识具体请求的字符串，例如 "FooStore.GetFoo"
// fptr: 指向目标函数变量的指针，例如 &getFooRequest
func makeRequestFunc(req string, fptr interface{}) {
    // baseRequestFunc 是所有动态生成函数的核心逻辑
    // 它的签名是固定的：func(params []reflect.Value) []reflect.Value
    baseRequestFunc := func(params []reflect.Value) []reflect.Value {
        log.Printf("正在发送请求: %s，参数: %v\n", req, params)

        // 这里是实际调用 XML-RPC 客户端的逻辑
        // 假设 XML-RPC 客户端根据 req 获取数据，并返回一个 interface{}
        // 然后我们需要将这个 interface{} 转换为目标类型（例如 []Foo）
        // 为了简化示例，我们直接构造一个符合目标返回类型的 reflect.Value
        // 在实际应用中，这里会涉及类型断言和数据转换

        // 获取目标函数的返回类型，这里假设只有一个返回值
        // fnType.Out(0) 获取第一个返回值的类型
        fnType := reflect.TypeOf(fptr).Elem() // 获取 fptr 指向的函数类型
        returnType := fnType.Out(0)           // 获取函数第一个返回值的类型 (例如 []Foo)

        // 根据 returnType 创建一个符合类型要求的 reflect.Value
        // 实际场景中，这里应该通过 RPC 客户端调用并处理返回数据
        // 例如：
        // var rawResult interface{}
        // err := store.client.Call(req, nil, &rawResult) // 假设 Call 方法
        // if err != nil { /* 处理错误 */ }
        // // 将 rawResult 转换为 returnType
        // // 这里为了演示，我们直接构造一个 []Foo 或 []int 的 reflect.Value
        switch returnType.String() {
        case "[]main.Foo":
            // 模拟返回 []Foo
            return []reflect.Value{reflect.ValueOf([]Foo{{ID: 1, Name: "Foo1"}, {ID: 2, Name: "Foo2"}})}
        case "[]int":
            // 模拟返回 []int
            return []reflect.Value{reflect.ValueOf([]int{10, 20, 30})}
        default:
            log.Printf("未知返回类型: %s, 返回空切片\n", returnType.String())
            // 返回一个空切片，类型与期望的返回类型匹配
            return []reflect.Value{reflect.Zero(returnType)}
        }
    }

    // 获取 fptr 指向的函数变量的 reflect.Value
    fn := reflect.ValueOf(fptr).Elem()
    // 使用 reflect.MakeFunc 创建一个新的函数值
    // 第一个参数是目标函数的类型（从 fn.Type() 获取）
    // 第二个参数是上面定义的桥接函数 baseRequestFunc
    reqFun := reflect.MakeFunc(fn.Type(), baseRequestFunc)
    // 将新创建的函数值赋给 fn 指向的函数变量
    fn.Set(reqFun)
}

func main() {
    // 1. 定义一个原型函数变量，其签名与期望的请求函数一致
    var getFooRequest func() []Foo
    // 2. 调用 makeRequestFunc，将具体请求名和函数变量的指针传入
    makeRequestFunc("FooStore.GetFoo", &getFooRequest)

    // 3. 现在可以直接调用 getFooRequest，它会执行 makeRequestFunc 中定义的逻辑
    fmt.Println("--- 调用 getFooRequest ---")
    fooResult := getFooRequest()
    fmt.Printf("获取到的 Foo 数据: %+v\n", fooResult)

    fmt.Println("\n--- 演示另一个类型：[]int ---")
    var getIntRequest func() []int
    makeRequestFunc("IntStore.GetIDs", &getIntRequest)
    intResult := getIntRequest()
    fmt.Printf("获取到的 int 数据: %+v\n", intResult)

    fmt.Println("\n--- 演示一个未知类型 ---")
    var getUnknownRequest func() []float64
    makeRequestFunc("UnknownStore.GetValues", &getUnknownRequest)
    unknownResult := getUnknownRequest()
    fmt.Printf("获取到的 float64 数据: %+v\n", unknownResult)
}