Go 反射深度解析：动态结构体作为非指针对象传递的实践

func (h RouteHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    t := reflect.TypeOf(h.Handler) // h.Handler 是 home 函数
    paramType := t.In(0)           // paramType 是 struct{Category string}

    // reflect.New(paramType) 会创建一个指向 paramType 零值的新指针
    // newParamValue 是一个 reflect.Value，其类型是 *struct{Category string}
    newParamValue := reflect.New(paramType)

    // handlerArgs 是一个 interface{}，其底层值是 *struct{Category string}
    handlerArgs := newParamValue.Interface()

    // ... 填充 handlerArgs 的逻辑 ...

    f := reflect.ValueOf(h.Handler) // f 是 home 函数的 reflect.Value

    // 问题所在：这里将 *struct{Category string} 类型的 reflect.Value 传递给了期望 struct{Category string} 的函数
    args := []reflect.Value{reflect.ValueOf(handlerArgs)}
    f.Call(args) // 导致 panic
}

reflect: Call using *struct { Category string } as type struct { Category string }

package main

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

    "github.com/gorilla/mux"
)

// mapToStruct 函数保持不变，因为它已经通过 reflect.Indirect 妥善处理了指针
func mapToStruct(obj interface{}, mapping map[string]string) error {
    // reflect.Indirect 会解引用指针，确保 dataStruct 是结构体本身
    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.Println("Can't set field:", key)
            continue
        }

        var v interface{}

        switch structField.Type().Kind() {
        case reflect.Slice:
            v = data // 这里可能需要更复杂的逻辑来处理切片类型
        case reflect.String:
            v = string(data)
        case reflect.Bool:
            v = string(data) == "1"
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32:
            x, err := strconv.Atoi(string(data))
            if err != nil {
                return errors.New("arg " + key + " as int: " + err.Error())
            }
            v = x
        case reflect.Int64:
            x, err := strconv.ParseInt(string(data), 10, 64)
            if err != nil {
                return errors.New("arg " + key + " as int64: " + err.Error())
            }
            v = x
        case reflect.Float32, reflect.Float64:
            x, err := strconv.ParseFloat(string(data), 64)
            if err != nil {
                return errors.New("arg " + key + " as float64: " + err.Error())
            }
            v = x
        case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
            x, err := strconv.ParseUint(string(data), 10, 64)
            if err != nil {
                return errors.New("arg " + key + " as uint: " + err.Error())
            }
            v = x
        default:
            return errors.New("unsupported type in Scan: " + structField.Type().String())
        }
        structField.Set(reflect.ValueOf(v))
    }
    return nil
}

type RouteHandler struct {
    Handler interface{}
}

func (h RouteHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    t := reflect.TypeOf(h.Handler)
    // 确保 h.Handler 是一个函数，并且至少有一个参数
    if t.Kind() != reflect.Func || t.NumIn() == 0 {
        panic("Handler must be a function with at least one parameter")
    }

    paramType := t.In(0) // 获取第一个参数的类型，例如 struct{Category string}

    // reflect.New(paramType) 返回一个 reflect.Value，代表 *paramType
    newParamValue := reflect.New(paramType)

    // 将 newParamValue 的接口形式（*paramType）传递给 mapToStruct 进行填充
    // mapToStruct 内部会使用 reflect.Indirect 解引用这个指针
    if err := mapToStruct(newParamValue.Interface(), mux.Vars(req)); err != nil {
        panic(fmt.Sprintf("Error converting params: %v", err))
    }

    f := reflect.ValueOf(h.Handler)

    // 关键修正：使用 Elem() 获取指针指向的实际结构体值
    // newParamValue 是 *struct，通过 Elem() 得到 struct
    args := []reflect.Value{newParamValue.Elem()}
    f.Call(args) // 现在类型匹配，不会 panic

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

type App struct {
    Router *mux.Router // 使用指针以确保初始化
}

func (app *App) Run(bind string, port int) {
    if app.Router == nil {
        app.Router = mux.NewRouter() // 确保 Router 被初始化
    }
    bind_to := fmt.Sprintf("%s:%d", bind, port)
    http.Handle("/", app.Router) // http.Handle 期望 http.Handler 接口
    fmt.Printf("Server listening on %s\n", bind_to)
    http.ListenAndServe(bind_to, app.Router)
}

func (app *App) Route(pat string, h interface{}) {
    if app.Router == nil {
        app.Router = mux.NewRouter()
    }
    app.Router.Handle(pat, RouteHandler{Handler: h})
}

func home(args struct{ Category string }) {
    fmt.Println("home handler called with Category:", args.Category)
}

func main() {
    app := &App{}
    app.Route("/products/{Category}", home)
    app.Run("0.0.0.0", 8080)
}