Golang中如何通过反射调用具有不同参数的多个方法

我的评论是关于更改函数签名的：

我还有一个限制，就是不能更改应用包的函数。例如：参数类型等。

如果我正确理解了示例代码，它要求接受任意长度的参数并将其类型设为接口。

func main() {
    fmt.Println("hello world")
}

可以使用反射来动态调用方法，避免大量的switch/case语句。以下是实现方案：

func (m *Middleware) Process(a *App, method string, args []interface{}) error {
    // 获取App的类型
    appType := reflect.TypeOf(a)
    
    // 查找方法
    methodVal := reflect.ValueOf(a).MethodByName(method)
    if !methodVal.IsValid() {
        return fmt.Errorf("method %s not found", method)
    }
    
    // 获取方法类型信息
    methodType := methodVal.Type()
    
    // 检查参数数量
    if methodType.NumIn() != len(args) {
        return fmt.Errorf("method %s expects %d arguments, got %d", 
            method, methodType.NumIn(), len(args))
    }
    
    // 转换参数类型
    callArgs := make([]reflect.Value, len(args))
    for i := 0; i < len(args); i++ {
        // 获取方法参数的实际类型
        paramType := methodType.In(i)
        
        // 如果参数已经是正确的类型，直接使用
        argValue := reflect.ValueOf(args[i])
        if argValue.Type().ConvertibleTo(paramType) {
            callArgs[i] = argValue.Convert(paramType)
        } else {
            // 尝试JSON反序列化
            if paramType.Kind() == reflect.Struct || 
               paramType.Kind() == reflect.Ptr && paramType.Elem().Kind() == reflect.Struct {
                jsonBytes, err := json.Marshal(args[i])
                if err != nil {
                    return fmt.Errorf("failed to marshal arg %d: %v", i, err)
                }
                
                paramValue := reflect.New(paramType)
                if paramType.Kind() == reflect.Ptr {
                    paramValue = reflect.New(paramType.Elem())
                }
                
                if err := json.Unmarshal(jsonBytes, paramValue.Interface()); err != nil {
                    return fmt.Errorf("failed to unmarshal arg %d: %v", i, err)
                }
                
                if paramType.Kind() == reflect.Ptr {
                    callArgs[i] = paramValue
                } else {
                    callArgs[i] = paramValue.Elem()
                }
            } else {
                return fmt.Errorf("arg %d type mismatch: expected %v, got %T", 
                    i, paramType, args[i])
            }
        }
    }
    
    // 调用方法
    results := methodVal.Call(callArgs)
    
    // 处理返回值
    for i, result := range results {
        if err, ok := result.Interface().(error); ok && err != nil {
            return fmt.Errorf("method %s returned error: %v", method, err)
        }
        // 处理其他返回值
        fmt.Printf("Result %d: %v\n", i, result.Interface())
    }
    
    return nil
}

对于更复杂的参数处理，可以创建一个参数解析器：

type ParamParser struct {
    args []interface{}
}

func (p *ParamParser) Parse(method reflect.Method) ([]reflect.Value, error) {
    methodType := method.Type
    params := make([]reflect.Value, methodType.NumIn())
    
    for i := 0; i < methodType.NumIn(); i++ {
        paramType := methodType.In(i)
        
        if i >= len(p.args) {
            return nil, fmt.Errorf("missing argument %d", i)
        }
        
        arg := p.args[i]
        argValue := reflect.ValueOf(arg)
        
        // 处理字符串到其他基本类型的转换
        if argValue.Kind() == reflect.String && paramType.Kind() != reflect.String {
            parsed, err := parseString(arg.(string), paramType)
            if err != nil {
                return nil, err
            }
            params[i] = parsed
        } else if argValue.Type().ConvertibleTo(paramType) {
            params[i] = argValue.Convert(paramType)
        } else {
            return nil, fmt.Errorf("cannot convert %T to %v", arg, paramType)
        }
    }
    
    return params, nil
}

func parseString(s string, targetType reflect.Type) (reflect.Value, error) {
    switch targetType.Kind() {
    case reflect.Int:
        val, err := strconv.Atoi(s)
        if err != nil {
            return reflect.Value{}, err
        }
        return reflect.ValueOf(val), nil
    case reflect.Bool:
        val, err := strconv.ParseBool(s)
        if err != nil {
            return reflect.Value{}, err
        }
        return reflect.ValueOf(val), nil
    case reflect.Float64:
        val, err := strconv.ParseFloat(s, 64)
        if err != nil {
            return reflect.Value{}, err
        }
        return reflect.ValueOf(val), nil
    default:
        return reflect.Value{}, fmt.Errorf("unsupported type: %v", targetType)
    }
}

使用示例：

func (m *Middleware) Process(a *App, method string, args []interface{}) error {
    methodVal := reflect.ValueOf(a).MethodByName(method)
    if !methodVal.IsValid() {
        return fmt.Errorf("method not found: %s", method)
    }
    
    parser := &ParamParser{args: args}
    params, err := parser.Parse(reflect.Method{
        Type: methodVal.Type(),
    })
    if err != nil {
        return err
    }
    
    results := methodVal.Call(params)
    // 处理结果...
    return nil
}

这种方法完全消除了switch/case语句，通过反射动态处理任意数量和类型的参数。反射会自动进行参数数量检查，并通过类型转换处理不同类型的参数。