var fieldCache = make(map[reflect.Type]map[string]reflect.StructField)

func getCachedField(typ reflect.Type, fieldName string) (reflect.StructField, bool) {
    if cache, ok := fieldCache[typ]; ok {
        field, exists := cache[fieldName]
        return field, exists
    }
    
    fields := make(map[string]reflect.StructField)
    for i := 0; i < typ.NumField(); i++ {
        field := typ.Field(i)
        fields[field.Name] = field
    }
    fieldCache[typ] = fields
    return fields[fieldName], true
}

type MethodCaller func(args ...interface{}) []interface{}

var methodCache = make(map[reflect.Type]map[string]MethodCaller)

func getMethodCaller(obj interface{}, methodName string) MethodCaller {
    typ := reflect.TypeOf(obj)
    if methodCache[typ] == nil {
        methodCache[typ] = make(map[string]MethodCaller)
    }
    if caller, ok := methodCache[typ][methodName]; ok {
        return caller
    }

    method := reflect.ValueOf(obj).MethodByName(methodName)
    if !method.IsValid() {
        return nil
    }

    caller := func(args ...interface{}) []interface{} {
        in := make([]reflect.Value, len(args))
        for i, arg := range args {
            in[i] = reflect.ValueOf(arg)
        }
        results := method.Call(in)
        out := make([]interface{}, len(results))
        for i, r := range results {
            out[i] = r.Interface()
        }
        return out
    }

    methodCache[typ][methodName] = caller
    return caller
}

switch v := data.(type) {
case int:
    handleInt(v)
case string:
    handleString(v)
case *User:
    handleUser(v)
default:
    // 仅在无法确定类型时才使用反射兜底
    useReflectFallback(data)
}