Go 反射：正确传递动态创建的非指针结构体对象

package main

import (
    "errors"
    "fmt"
    "net/http"
    "reflect"
    "strconv"

    "github.com/gorilla/mux"
)

// mapToStruct 辅助函数：将 map 中的数据映射到结构体字段
func mapToStruct(obj interface{}, mapping map[string]string) error {
    // reflect.Indirect 会解引用指针，确保我们操作的是底层结构体的值
    dataStruct := reflect.Indirect(reflect.ValueOf(obj))

    if dataStruct.Kind() != reflect.Struct {
        return errors.New("expected a pointer to a struct") // 实际上，这里期望的是一个指向结构体的指针，或者直接是结构体值
    }

    for key, data := range mapping {
        structField := dataStruct.FieldByName(key)

        if !structField.CanSet() {
            fmt.Printf("Can't set field '%s'\n", key) // 打印具体字段，方便调试
            continue
        }

        var v interface{}

        // 根据字段类型进行类型转换
        switch structField.Type().Kind() {
        case reflect.Slice:
            v = data // 简单处理，实际可能需要更复杂的解析
        case reflect.String:
            v = data // 直接使用 string(data) 即可
        case reflect.Bool:
            v = data == "1"
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32:
            x, err := strconv.Atoi(data)
            if err != nil {
                return fmt.Errorf("arg %s as int: %w", key, err)
            }
            v = x
        case reflect.Int64:
            x, err := strconv.ParseInt(data, 10, 64)
            if err != nil {
                return fmt.Errorf("arg %s as int64: %w", key, err)
            }
            v = x
        case reflect.Float32, reflect.Float64:
            x, err := strconv.ParseFloat(data, 64)
            if err != nil {
                return fmt.Errorf("arg %s as float64: %w", key, err)
            }
            v = x
        case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
            x, err := strconv.ParseUint(data, 10, 64)
            if err != nil {
                return fmt.Errorf("arg %s as uint: %w", key, err)
            }
            v = x
        default:
            return fmt.Errorf("unsupported type in Scan: %s", structField.Type().String())
        }

        // 设置字段值
        structField.Set(reflect.ValueOf(v))
    }
    return nil
}

// RouteHandler 封装了路由处理逻辑
type RouteHandler struct {
    Handler interface{} // 实际的处理器函数
}

// ServeHTTP 实现 http.Handler 接口
func (h RouteHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    t := reflect.TypeOf(h.Handler) // 获取处理器函数的类型

    // 确保处理器函数只有一个参数
    if t.NumIn() != 1 {
        panic("Handler function must have exactly one argument")
    }

    // 获取处理器函数的第一个参数类型 (例如 struct{Category string})
    handlerParamType := t.In(0)

    // 使用 reflect.New 创建一个指向该参数类型的指针的 reflect.Value
    // 此时 ptrToHandlerArgs 是 reflect.Value 类型，代表 *struct{Category string}
    ptrToHandlerArgs := reflect.New(handlerParamType)

    // mapToStruct 需要一个 interface{} 类型，我们传递 ptrToHandlerArgs 的接口值
    // mapToStruct 内部会通过 reflect.Indirect 解引用
    if err := mapToStruct(ptrToHandlerArgs.Interface(), mux.Vars(req)); err != nil {
        panic(fmt.Sprintf("Error converting params: %v", err)) // 打印详细错误信息
    }

    f := reflect.ValueOf(h.Handler) // 获取处理器函数的 reflect.Value

    // 关键步骤：使用 Elem() 获取指针指向的实际值
    // ptrToHandlerArgs.Elem() 返回一个 reflect.Value，代表 struct{Category string}
    args := []reflect.Value{ptrToHandlerArgs.Elem()}

    // 调用处理器函数
    f.Call(args)

    fmt.Fprint(w, "Hello World")
}

// App 结构体，用于管理路由和启动服务
type App struct {
    Router *mux.Router // 将 mux.Router 改为指针，避免零值问题
}

// NewApp 创建并初始化 App 实例
func NewApp() *App {
    return &App{
        Router: mux.NewRouter(), // 初始化 mux.Router
    }
}

// Run 启动 HTTP 服务器
func (app *App) Run(bind string, port int) error {
    bindTo := fmt.Sprintf("%s:%d", bind, port)
    http.Handle("/", app.Router) // 直接使用 app.Router
    fmt.Printf("Server listening on %s\n", bindTo)
    return http.ListenAndServe(bindTo, nil) // 使用 nil 作为 handler，让 http.Handle 处理路由
}

// Route 注册路由
func (app *App) Route(pat string, h interface{}) {
    app.Router.Handle(pat, RouteHandler{Handler: h})
}

// home 处理器函数，接收一个值类型结构体参数
func home(args struct{ Category string }) {
    fmt.Println("home handler called, Category:", args.Category)
}

func main() {
    app := NewApp()
    app.Route("/products/{Category}", home)
    // 尝试访问 http://localhost:8080/products/electronics
    if err := app.Run("0.0.0.0", 8080); err != nil {
        fmt.Printf("Server failed: %v\n", err)
    }
}

// ...
ptrToHandlerArgs := reflect.New(handlerParamType) // ptrToHandlerArgs 是 *struct{Category string} 的 reflect.Value
// ...
args := []reflect.Value{ptrToHandlerArgs.Elem()} // 使用 Elem() 获取底层 struct{Category string} 的 reflect.Value
// ...