利用 Go 反射机制动态生成函数，实现代码精简与优化

func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value

package main

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

// Foo 和 Bar 是我们从 XML-RPC 服务器获取数据的目标结构体
type Foo struct {
    ID   int
    Name string
}

type Bar struct {
    Code string
    Value float64
}

// 假设我们有如下原型函数，用于获取不同类型的切片
var getFooRequest func() []Foo
var getBarRequest func() []Bar

// buildRequest 接收请求的服务名称和目标函数指针
// 它会创建一个新的函数，并将其赋值给目标函数指针
func buildRequest(serviceName string, fptr interface{}) {
    // 确保 fptr 是一个函数指针
    fnVal := reflect.ValueOf(fptr)
    if fnVal.Kind() != reflect.Ptr || fnVal.Elem().Kind() != reflect.Func {
        log.Fatalf("Expected a function pointer, got %v", fnVal.Kind())
    }

    // 获取目标函数指针指向的函数类型
    fnType := fnVal.Elem().Type()

    // 定义桥接函数，这是新函数被调用时实际执行的逻辑
    // params 是新函数被调用时传入的参数 (这里是空，因为我们的原型函数没有参数)
    // results 是新函数需要返回的值
    baseRequestFunc := func(params []reflect.Value) []reflect.Value {
        log.Printf("正在发送请求到服务: %s", serviceName)

        // 模拟 XML-RPC 客户端调用，这里是核心业务逻辑
        // 实际应用中，这里会调用 store.client.Call(serviceName, ...)
        // 并根据 fnType.Out(0) （即返回类型）进行数据解析和转换。

        // 获取函数的返回类型 (例如 []Foo 或 []Bar)
        returnType := fnType.Out(0) // 假设函数只有一个返回值

        // 创建一个该返回类型的切片
        // 注意：这里的模拟数据类型需要与实际返回类型匹配
        // 实际应用中，你需要根据 returnType 创建实例并填充数据
        var result reflect.Value
        switch returnType.String() {
        case "[]main.Foo":
            // 模拟返回 []Foo
            mockFoos := []Foo{
                {ID: 1, Name: "Sample Foo 1"},
                {ID: 2, Name: "Sample Foo 2"},
            }
            result = reflect.ValueOf(mockFoos)
        case "[]main.Bar":
            // 模拟返回 []Bar
            mockBars := []Bar{
                {Code: "A", Value: 10.5},
                {Code: "B", Value: 20.0},
            }
            result = reflect.ValueOf(mockBars)
        default:
            log.Printf("未知返回类型: %s", returnType.String())
            // 返回一个空的该类型切片
            result = reflect.MakeSlice(returnType, 0, 0)
        }

        return []reflect.Value{result}
    }

    // 使用 reflect.MakeFunc 创建一个新的函数值
    // 这个新函数的类型是 fnType，其逻辑由 baseRequestFunc 提供
    newFunc := reflect.MakeFunc(fnType, baseRequestFunc)

    // 将新创建的函数值赋给目标函数指针
    fnVal.Elem().Set(newFunc)
}

func main() {
    // 动态构建获取 Foo 数据的请求函数
    buildRequest("FooStore.GetFoo", &getFooRequest)

    // 动态构建获取 Bar 数据的请求函数
    buildRequest("BarStore.GetBar", &getBarRequest)

    fmt.Println("--- 调用 getFooRequest ---")
    foos := getFooRequest() // 像调用普通函数一样
    fmt.Printf("获取到 Foos: %+v\n", foos)

    fmt.Println("\n--- 调用 getBarRequest ---")
    bars := getBarRequest() // 像调用普通函数一样
    fmt.Printf("获取到 Bars: %+v\n", bars)
}

--- 调用 getFooRequest ---
2023/10/27 10:00:00 正在发送请求到服务: FooStore.GetFoo
获取到 Foos: [{ID:1 Name:Sample Foo 1} {ID:2 Name:Sample Foo 2}]

--- 调用 getBarRequest ---
2023/10/27 10:00:00 正在发送请求到服务: BarStore.GetBar
获取到 Bars: [{Code:A Value:10.5} {Code:B Value:20}]