chore: update v.mod version

app.v

@@ -40,6 +40,10 @@ pub mut:
 	use_fast_router bool = true  // 新增：是否使用快速路由器
 	context_middlewares []ContextMiddleware
 	route_middlewares map[string][]ContextMiddleware  // 路由前缀对应的中间件
+	// 优化：预排序的中间件前缀列表（启动时计算一次）
+	sorted_middleware_prefixes []string
+	// 优化：标记是否有中间件（用于零中间件快速路径）
+	has_middlewares bool
 }
 
 // Context 中间件类型
@@ -185,6 +189,14 @@ pub fn (mut app Hono) all(path string, handler fn (mut Context) http.Response) {
 // Context 中间件
 pub fn (mut app Hono) use(mw ContextMiddleware) {
 	app.context_middlewares << mw
+	app.has_middlewares = true
+}
+
+// 预计算中间件前缀排序（在服务器启动前调用）
+pub fn (mut app Hono) precompute_middleware_prefixes() {
+	app.sorted_middleware_prefixes = app.route_middlewares.keys()
+	app.sorted_middleware_prefixes.sort(a.len < b.len)
+	app.has_middlewares = app.context_middlewares.len > 0 || app.route_middlewares.len > 0
 }
 
 // notFound() - 自定义 404 处理器
@@ -234,12 +246,18 @@ fn (mut s ServerHanler) handle(req http.Request) http.Response {
 			body := req.data
 			// 构造 Context
 			mut ctx := Context.new(req, param_map, query_map, body)
+			
+			// 优化：零中间件快速路径
+			if !s.app.has_middlewares {
+				return route_match.handler.handle(mut ctx)
+			}
+			
 			// 获取该路径对应的中间件
 			middlewares := s.get_middlewares_for_path(url.path)
 			// 洋葱模型递归执行中间件
 			return s.exec_context_middlewares_with_list(0, middlewares, mut ctx, fn [route_match] (mut c Context) http.Response {
 				return route_match.handler.handle(mut c)
-			})
+		})
 		}
 		
 		// 如果快速路由器没有匹配，回退到混合路由器
@@ -250,6 +268,12 @@ fn (mut s ServerHanler) handle(req http.Request) http.Response {
 			body := req.data
 			// 构造 Context
 			mut ctx := Context.new(req, param_map, query_map, body)
+			
+			// 优化：零中间件快速路径
+			if !s.app.has_middlewares {
+				return route_match.handler.handle(mut ctx)
+			}
+			
 			// 获取该路径对应的中间件
 			middlewares := s.get_middlewares_for_path(url.path)
 			// 洋葱模型递归执行中间件
@@ -265,6 +289,12 @@ fn (mut s ServerHanler) handle(req http.Request) http.Response {
 			body := req.data
 			// 构造 Context
 			mut ctx := Context.new(req, param_map, query_map, body)
+			
+			// 优化：零中间件快速路径
+			if !s.app.has_middlewares {
+				return route_match.handler.handle(mut ctx)
+			}
+			
 			// 获取该路径对应的中间件
 			middlewares := s.get_middlewares_for_path(url.path)
 			// 洋葱模型递归执行中间件
@@ -291,15 +321,17 @@ fn (mut s ServerHanler) handle(req http.Request) http.Response {
 	})
 }
 
-// 获取路径对应的所有中间件（全局 + 路由前缀匹配的）
+// 获取路径对应的所有中间件（全局 + 路由前缀匹配的）- 优化版
 fn (s ServerHanler) get_middlewares_for_path(path string) []ContextMiddleware {
+	// 优化：只有全局中间件时，直接返回引用（避免克隆）
+	if s.app.route_middlewares.len == 0 {
+		return s.app.context_middlewares
+	}
+	
 	mut middlewares := s.app.context_middlewares.clone()
 	
-	// 按前缀长度排序，确保更具体的前缀后执行
-	mut prefixes := s.app.route_middlewares.keys()
-	prefixes.sort(a.len < b.len)
-	
-	for prefix in prefixes {
+	// 优化：使用预排序的前缀列表（启动时已排序，不需要每次请求都排序）
+	for prefix in s.app.sorted_middleware_prefixes {
 		if path.starts_with(prefix) || prefix == '/' {
 			if mws := s.app.route_middlewares[prefix] {
 				middlewares << mws
@@ -342,6 +374,9 @@ pub fn (mut app Hono) listen(port string) {
 		return
 	}
 	
+	// 优化：预计算中间件前缀排序
+	app.precompute_middleware_prefixes()
+	
 	// 使用优化配置的 picoev 高性能服务器（支持高并发）
 	app.listen_picoev_with_config(PicoevConfig{
 		port: port_num
@@ -372,6 +407,7 @@ pub fn (mut app Hono) route(prefix string, mut subapp Hono) {
 		} else {
 			app.route_middlewares[prefix] = subapp.context_middlewares.clone()
 		}
+		app.has_middlewares = true
 	}
 	
 	// 继承子应用的 notFound 和 onError 处理器（如果主应用没有设置）
@@ -508,5 +544,7 @@ pub fn Hono.new() Hono {
 		fast_router: FastRouter.new()
 		use_fast_router: true
 		route_middlewares: map[string][]ContextMiddleware{}
+		sorted_middleware_prefixes: []string{}
+		has_middlewares: false
 	}
 }

benchmark/README.md

@@ -2,27 +2,19 @@
 
 Performance benchmarks for V-Hono web framework.
 
-## Backend Comparison
+## Framework Comparison (500 connections, 100K requests)
 
-### uSockets vs Picoev (200 connections, 100K requests)
+| Framework | RPS | Errors | Avg Latency | P50 | P95 | P99 |
+|-----------|-----|--------|-------------|-----|-----|-----|
+| **v-hono (uSockets)** | **20,231** | **0** | **24.62ms** | **23.65ms** | **33.82ms** | **57.29ms** |
+| v-hono (picoev) | 16,177 | 0 | 30.75ms | 26.25ms | 35.37ms | 111.38ms |
+| veb (V官方) | 7,278 | 772 | 68.06ms | 55.79ms | 71.62ms | 98.90ms |
 
-| Backend | RPS | Avg Latency | P95 | P99 |
-|---------|-----|-------------|-----|-----|
-| uSockets | ~22,000 | 8.75ms | 16.66ms | 25.73ms |
-| picoev | ~15,000 | 13.36ms | 18.89ms | 31.66ms |
+### Performance Summary
 
-**uSockets provides ~50% higher throughput under high concurrency.**
-
-### High Concurrency Test (500 connections, 100K requests)
-
-| Metric | uSockets |
-|--------|----------|
-| RPS | ~20,000 |
-| Errors | 0 |
-| Avg Latency | 25.04ms |
-| P50 | 24.32ms |
-| P95 | 32.97ms |
-| P99 | 64.59ms |
+- **v-hono (uSockets) vs veb**: **2.78x faster**, zero errors
+- **v-hono (uSockets) vs picoev**: **25% faster**, better P99 latency
+- **v-hono (picoev) vs veb**: **2.22x faster**, zero errors
 
 ## Running Benchmarks
 

fast_router.v

@@ -171,17 +171,18 @@ fn (router FastRouter) precompile_route(method string, handler IHandler) !Precom
 	}
 }
 
-// 快速路由匹配（优化版：静态路由跳过缓存 + 预分配结果）
+// 快速路由匹配（优化版：静态路由跳过缓存 + 预分配结果 + 复用 cache key）
 pub fn (mut router FastRouter) match_route(method string, path string) ?ContextRouteMatch {
+	// 优化：只拼接一次 cache key，复用于静态路由和缓存查找
+	cache_key := '${method}:${path}'
+	
 	// 1. 静态路由直接返回预分配的结果（零分配）
-	static_key := '${method}:${path}'
-	if result := router.static_route_results[static_key] {
+	if result := router.static_route_results[cache_key] {
 		return result
 	}
 	
 	// 2. 动态路由先检查 LRU 缓存（避免重复正则匹配）
 	if router.cache_enabled {
-		cache_key := '${method}:${path}'
 		if cached := router.lru_cache.get(cache_key) {
 			return cached
 		}
@@ -208,9 +209,8 @@ pub fn (mut router FastRouter) match_route(method string, path string) ?ContextR
 				base_path: ''
 			}
 			
-			// 只缓存动态路由结果
+			// 只缓存动态路由结果（复用 cache_key）
 			if router.cache_enabled {
-				cache_key := '${method}:${path}'
 				router.lru_cache.put(cache_key, result)
 			}
 			

picoev_server.v

@@ -79,7 +79,15 @@ fn picoev_callback(user_data voidptr, req picohttpparser.Request, mut res picoht
 	if ctx.app.use_fast_router {
 		if route_match := ctx.app.fast_router.match_route(method_str, path) {
 			mut hono_ctx := create_picoev_context(req, route_match.params, query_map)
-			middlewares := get_middlewares_for_path_picoev(ctx.app, path)
+			
+			// 优化：零中间件快速路径
+			if !ctx.app.has_middlewares {
+				response := route_match.handler.handle(mut hono_ctx)
+				send_picoev_response(mut res, hono_ctx, response, keepalive, ctx.config)
+				return
+			}
+			
+			middlewares := get_middlewares_for_path_picoev_optimized(ctx.app, path)
 			response := exec_middlewares_picoev(0, middlewares, mut hono_ctx, route_match.handler)
 			send_picoev_response(mut res, hono_ctx, response, keepalive, ctx.config)
 			return
@@ -89,7 +97,15 @@ fn picoev_callback(user_data voidptr, req picohttpparser.Request, mut res picoht
 	// 回退到混合路由器
 	if route_match := ctx.app.context_hybrid_router.match_route(method_str, path) {
 		mut hono_ctx := create_picoev_context(req, route_match.params, query_map)
-		middlewares := get_middlewares_for_path_picoev(ctx.app, path)
+		
+		// 优化：零中间件快速路径
+		if !ctx.app.has_middlewares {
+			response := route_match.handler.handle(mut hono_ctx)
+			send_picoev_response(mut res, hono_ctx, response, keepalive, ctx.config)
+			return
+		}
+		
+		middlewares := get_middlewares_for_path_picoev_optimized(ctx.app, path)
 		response := exec_middlewares_picoev(0, middlewares, mut hono_ctx, route_match.handler)
 		send_picoev_response(mut res, hono_ctx, response, keepalive, ctx.config)
 		return
@@ -129,14 +145,17 @@ fn check_keepalive_request(req picohttpparser.Request) bool {
 	return true // HTTP/1.1 默认 Keep-Alive
 }
 
-// 获取路径对应的所有中间件
-fn get_middlewares_for_path_picoev(app &Hono, path string) []ContextMiddleware {
+// 获取路径对应的所有中间件（优化版：使用预排序的前缀列表）
+fn get_middlewares_for_path_picoev_optimized(app &Hono, path string) []ContextMiddleware {
+	// 优化：只有全局中间件时，直接返回引用（避免克隆）
+	if app.route_middlewares.len == 0 {
+		return app.context_middlewares
+	}
+	
 	mut middlewares := app.context_middlewares.clone()
 	
-	mut prefixes := app.route_middlewares.keys()
-	prefixes.sort(a.len < b.len)
-	
-	for prefix in prefixes {
+	// 优化：使用预排序的前缀列表（启动时已排序，不需要每次请求都排序）
+	for prefix in app.sorted_middleware_prefixes {
 		if path.starts_with(prefix) || prefix == '/' {
 			if mws := app.route_middlewares[prefix] {
 				middlewares << mws
@@ -147,6 +166,11 @@ fn get_middlewares_for_path_picoev(app &Hono, path string) []ContextMiddleware {
 	return middlewares
 }
 
+// 获取路径对应的所有中间件（保留旧版本兼容）
+fn get_middlewares_for_path_picoev(app &Hono, path string) []ContextMiddleware {
+	return get_middlewares_for_path_picoev_optimized(app, path)
+}
+
 // 执行中间件链
 fn exec_middlewares_picoev(idx int, middlewares []ContextMiddleware, mut ctx Context, handler IHandler) http.Response {
 	if idx < middlewares.len {

router.v

@@ -208,10 +208,34 @@ pub fn (router ContextHybridRouter) match_static_route(method string, path strin
 	return none
 }
 
-// Context 版本的动态路径匹配
+// Context 版本的动态路径匹配（保留旧版本兼容）
 fn (mut router ContextHybridRouter) match_dynamic_route(method string, path string) ?ContextRouteMatch {
-	// 先检查缓存
 	cache_key := '${method}:${path}'
+	return router.match_dynamic_route_with_key(cache_key, method, path)
+}
+
+// Context 版本的主匹配函数（优化版：复用 cache key）
+pub fn (mut router ContextHybridRouter) match_route(method string, path string) ?ContextRouteMatch {
+	// 优化：只拼接一次 cache key
+	cache_key := '${method}:${path}'
+	
+	// 1. 先尝试静态路径匹配（最快）
+	if cache_key in router.static_routes {
+		return ContextRouteMatch{
+			handler: router.static_routes[cache_key]
+			params: map[string]string{}
+			path: path
+			base_path: ''
+		}
+	}
+	
+	// 2. 再尝试动态路径匹配（复用 cache_key）
+	return router.match_dynamic_route_with_key(cache_key, method, path)
+}
+
+// Context 版本的动态路径匹配（优化版：接收预计算的 cache_key）
+fn (mut router ContextHybridRouter) match_dynamic_route_with_key(cache_key string, method string, path string) ?ContextRouteMatch {
+	// 先检查缓存
 	if cached := router.cache.get(cache_key) {
 		return cached
 	}
@@ -240,22 +264,6 @@ fn (mut router ContextHybridRouter) match_dynamic_route(method string, path stri
 	return none
 }
 
-// Context 版本的主匹配函数
-pub fn (mut router ContextHybridRouter) match_route(method string, path string) ?ContextRouteMatch {
-	// 1. 先尝试静态路径匹配（最快）
-	if static_handler := router.match_static_route(method, path) {
-		return ContextRouteMatch{
-			handler: static_handler
-			params: map[string]string{}
-			path: path
-			base_path: ''
-		}
-	}
-	
-	// 2. 再尝试动态路径匹配
-	return router.match_dynamic_route(method, path)
-}
-
 // Context 版本的获取所有路由
 pub fn (router ContextHybridRouter) get_all_routes() ([]string, []string) {
 	mut static_paths := []string{}

tests/test_middleware_optimization.v

@@ -0,0 +1,355 @@
+// 中间件优化测试
+// 测试三个优化点：
+// 1. 零中间件快速路径
+// 2. 中间件预计算（启动时排序）
+// 3. 复用 cache key
+
+import hono
+import time
+import net.http
+
+// 测试统计
+struct TestStats {
+mut:
+	total_tests  int
+	passed_tests int
+	failed_tests int
+}
+
+fn (mut stats TestStats) start_test(test_name string) {
+	stats.total_tests++
+	print('🧪 ${test_name}... ')
+}
+
+fn (mut stats TestStats) pass_test() {
+	stats.passed_tests++
+	println('✅')
+}
+
+fn (mut stats TestStats) fail_test(error string) {
+	stats.failed_tests++
+	println('❌ ${error}')
+}
+
+fn (stats TestStats) print_summary() {
+	println('\n=== 测试总结 ===')
+	println('总测试数: ${stats.total_tests}')
+	println('通过: ${stats.passed_tests}')
+	println('失败: ${stats.failed_tests}')
+	if stats.failed_tests == 0 {
+		println('🎉 所有测试通过！')
+	} else {
+		println('⚠️  有 ${stats.failed_tests} 个测试失败')
+	}
+}
+
+// 测试1：零中间件快速路径 - has_middlewares 标志
+fn test_zero_middleware_flag(mut stats TestStats) {
+	stats.start_test('零中间件标志 (has_middlewares)')
+	
+	mut app := hono.Hono.new()
+	
+	// 新创建的应用应该没有中间件
+	if app.has_middlewares {
+		stats.fail_test('新应用不应该有中间件标志')
+		return
+	}
+	
+	// 添加中间件后标志应该为 true
+	app.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
+		return next(mut c)
+	})
+	
+	if !app.has_middlewares {
+		stats.fail_test('添加中间件后标志应该为 true')
+		return
+	}
+	
+	stats.pass_test()
+}
+
+// 测试2：中间件预计算 - sorted_middleware_prefixes
+fn test_middleware_precompute(mut stats TestStats) {
+	stats.start_test('中间件预计算 (sorted_middleware_prefixes)')
+	
+	mut app := hono.Hono.new()
+	
+	// 添加路由
+	app.get('/test', fn (mut c hono.Context) http.Response {
+		return c.text('test')
+	})
+	
+	// 创建子应用并添加中间件
+	mut sub_app := hono.Hono.new()
+	sub_app.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
+		return next(mut c)
+	})
+	sub_app.get('/hello', fn (mut c hono.Context) http.Response {
+		return c.text('hello')
+	})
+	
+	// 挂载子应用
+	app.route('/api', mut sub_app)
+	
+	// 预计算前，sorted_middleware_prefixes 应该为空
+	if app.sorted_middleware_prefixes.len != 0 {
+		stats.fail_test('预计算前 sorted_middleware_prefixes 应该为空')
+		return
+	}
+	
+	// 调用预计算
+	app.precompute_middleware_prefixes()
+	
+	// 预计算后，sorted_middleware_prefixes 应该包含前缀
+	if app.sorted_middleware_prefixes.len == 0 && app.route_middlewares.len > 0 {
+		stats.fail_test('预计算后 sorted_middleware_prefixes 应该包含前缀')
+		return
+	}
+	
+	// 验证 has_middlewares 标志
+	if app.route_middlewares.len > 0 && !app.has_middlewares {
+		stats.fail_test('有路由中间件时 has_middlewares 应该为 true')
+		return
+	}
+	
+	stats.pass_test()
+}
+
+// 测试3：FastRouter cache key 复用
+fn test_fast_router_cache_key_reuse(mut stats TestStats) {
+	stats.start_test('FastRouter cache key 复用')
+	
+	mut router := hono.FastRouter.new()
+	
+	// 添加静态路由
+	static_handler := hono.ContextHandler{
+		path: '/users'
+		handler: fn (mut c hono.Context) http.Response {
+			return c.text('users')
+		}
+	}
+	router.add_route('GET', static_handler, '') or {
+		stats.fail_test('添加静态路由失败')
+		return
+	}
+	
+	// 添加动态路由
+	dynamic_handler := hono.ContextHandler{
+		path: '/users/:id'
+		handler: fn (mut c hono.Context) http.Response {
+			return c.text('user')
+		}
+	}
+	router.add_route('GET', dynamic_handler, '') or {
+		stats.fail_test('添加动态路由失败')
+		return
+	}
+	
+	// 测试静态路由匹配
+	if _ := router.match_route('GET', '/users') {
+		// 成功
+	} else {
+		stats.fail_test('静态路由匹配失败')
+		return
+	}
+	
+	// 测试动态路由匹配（第一次，会缓存）
+	if match1 := router.match_route('GET', '/users/123') {
+		if match1.params['id'] != '123' {
+			stats.fail_test('参数提取失败')
+			return
+		}
+	} else {
+		stats.fail_test('动态路由匹配失败')
+		return
+	}
+	
+	// 测试动态路由匹配（第二次，应该命中缓存）
+	if match2 := router.match_route('GET', '/users/123') {
+		if match2.params['id'] != '123' {
+			stats.fail_test('缓存命中后参数提取失败')
+			return
+		}
+	} else {
+		stats.fail_test('缓存命中失败')
+		return
+	}
+	
+	// 验证缓存状态
+	_, _, cache_count := router.get_stats()
+	if cache_count == 0 {
+		stats.fail_test('缓存应该有条目')
+		return
+	}
+	
+	stats.pass_test()
+}
+
+// 测试4：HybridRouter cache key 复用
+fn test_hybrid_router_cache_key_reuse(mut stats TestStats) {
+	stats.start_test('HybridRouter cache key 复用')
+	
+	mut router := hono.ContextHybridRouter.new()
+	
+	// 添加动态路由
+	dynamic_handler := hono.ContextHandler{
+		path: '/posts/:id'
+		handler: fn (mut c hono.Context) http.Response {
+			return c.text('post')
+		}
+	}
+	router.add_route('GET', dynamic_handler, '')
+	
+	// 第一次匹配（无缓存）
+	if match1 := router.match_route('GET', '/posts/456') {
+		if match1.params['id'] != '456' {
+			stats.fail_test('参数提取失败')
+			return
+		}
+	} else {
+		stats.fail_test('动态路由匹配失败')
+		return
+	}
+	
+	// 第二次匹配（应该命中缓存）
+	if match2 := router.match_route('GET', '/posts/456') {
+		if match2.params['id'] != '456' {
+			stats.fail_test('缓存命中后参数提取失败')
+			return
+		}
+	} else {
+		stats.fail_test('缓存命中失败')
+		return
+	}
+	
+	stats.pass_test()
+}
+
+// 测试5：性能对比 - 有中间件 vs 无中间件
+fn test_middleware_performance_comparison(mut stats TestStats) {
+	stats.start_test('中间件性能对比')
+	
+	// 创建无中间件的路由器
+	mut router_no_mw := hono.FastRouter.new()
+	handler := hono.ContextHandler{
+		path: '/api/users/:id'
+		handler: fn (mut c hono.Context) http.Response {
+			return c.text('user')
+		}
+	}
+	router_no_mw.add_route('GET', handler, '') or {
+		stats.fail_test('添加路由失败')
+		return
+	}
+	
+	// 预热
+	for _ in 0 .. 100 {
+		_ := router_no_mw.match_route('GET', '/api/users/123') or { continue }
+	}
+	
+	// 测试无中间件性能
+	iterations := 10000
+	start_no_mw := time.now()
+	for _ in 0 .. iterations {
+		_ := router_no_mw.match_route('GET', '/api/users/123') or { continue }
+	}
+	duration_no_mw := time.since(start_no_mw)
+	
+	// 创建有中间件的应用
+	mut app_with_mw := hono.Hono.new()
+	app_with_mw.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
+		return next(mut c)
+	})
+	app_with_mw.get('/api/users/:id', fn (mut c hono.Context) http.Response {
+		return c.text('user')
+	})
+	app_with_mw.precompute_middleware_prefixes()
+	
+	// 预热
+	for _ in 0 .. 100 {
+		_ := app_with_mw.fast_router.match_route('GET', '/api/users/123') or { continue }
+	}
+	
+	// 测试有中间件性能
+	start_with_mw := time.now()
+	for _ in 0 .. iterations {
+		_ := app_with_mw.fast_router.match_route('GET', '/api/users/123') or { continue }
+	}
+	duration_with_mw := time.since(start_with_mw)
+	
+	println('')
+	println('  📊 无中间件: ${duration_no_mw.milliseconds()}ms (${iterations} 次)')
+	println('  📊 有中间件: ${duration_with_mw.milliseconds()}ms (${iterations} 次)')
+	
+	// 性能差异不应该太大（路由匹配本身不受中间件影响）
+	stats.pass_test()
+}
+
+// 测试6：预计算排序正确性
+fn test_precompute_sorting(mut stats TestStats) {
+	stats.start_test('预计算排序正确性')
+	
+	mut app := hono.Hono.new()
+	
+	// 添加多个子应用，模拟不同长度的前缀
+	mut sub1 := hono.Hono.new()
+	sub1.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
+		return next(mut c)
+	})
+	sub1.get('/test', fn (mut c hono.Context) http.Response {
+		return c.text('test')
+	})
+	
+	mut sub2 := hono.Hono.new()
+	sub2.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
+		return next(mut c)
+	})
+	sub2.get('/test', fn (mut c hono.Context) http.Response {
+		return c.text('test')
+	})
+	
+	mut sub3 := hono.Hono.new()
+	sub3.use(fn (mut c hono.Context, next fn (mut hono.Context) http.Response) http.Response {
+		return next(mut c)
+	})
+	sub3.get('/test', fn (mut c hono.Context) http.Response {
+		return c.text('test')
+	})
+	
+	// 按不同顺序挂载（长前缀先挂载）
+	app.route('/api/v1/users', mut sub1)
+	app.route('/api', mut sub2)
+	app.route('/api/v1', mut sub3)
+	
+	// 预计算
+	app.precompute_middleware_prefixes()
+	
+	// 验证排序：短前缀应该在前面
+	if app.sorted_middleware_prefixes.len >= 2 {
+		for i in 0 .. app.sorted_middleware_prefixes.len - 1 {
+			if app.sorted_middleware_prefixes[i].len > app.sorted_middleware_prefixes[i + 1].len {
+				stats.fail_test('前缀排序不正确：${app.sorted_middleware_prefixes[i]} 应该在 ${app.sorted_middleware_prefixes[i + 1]} 之后')
+				return
+			}
+		}
+	}
+	
+	stats.pass_test()
+}
+
+fn main() {
+	println('🚀 开始中间件优化测试...\n')
+	
+	mut stats := TestStats{}
+	
+	// 运行所有测试
+	test_zero_middleware_flag(mut stats)
+	test_middleware_precompute(mut stats)
+	test_fast_router_cache_key_reuse(mut stats)
+	test_hybrid_router_cache_key_reuse(mut stats)
+	test_middleware_performance_comparison(mut stats)
+	test_precompute_sorting(mut stats)
+	
+	// 打印测试总结
+	stats.print_summary()
+}

usockets_server.v

@@ -49,6 +49,9 @@ pub fn (mut app Hono) listen_usockets(port int) {
 
 // 使用 uSockets 启动服务器（带配置）
 pub fn (mut app Hono) listen_usockets_with_config(config UsocketsConfig) {
+	// 优化：预计算中间件前缀排序
+	app.precompute_middleware_prefixes()
+	
 	// 存储到全局变量
 	g_usockets_app = unsafe { &app }
 	g_usockets_config = config
@@ -102,9 +105,16 @@ fn usockets_on_data(s usockets.Socket, data &char, length int) usockets.Socket {
 	if g_usockets_app.use_fast_router {
 		if route_match := g_usockets_app.fast_router.match_route(method, path) {
 			mut hono_ctx := create_usockets_context(method, path, route_match.params, query_map, body)
-			middlewares := get_middlewares_for_path_usockets(g_usockets_app, path)
-			response := exec_middlewares_usockets(0, middlewares, mut hono_ctx, route_match.handler)
-			send_usockets_response(s, hono_ctx, response)
+			
+			// 优化1：零中间件快速路径
+			if !g_usockets_app.has_middlewares {
+				response := route_match.handler.handle(mut hono_ctx)
+				send_usockets_response(s, hono_ctx, response)
+			} else {
+				middlewares := get_middlewares_for_path_usockets_optimized(g_usockets_app, path)
+				response := exec_middlewares_usockets(0, middlewares, mut hono_ctx, route_match.handler)
+				send_usockets_response(s, hono_ctx, response)
+			}
 			response_sent = true
 		}
 	}
@@ -113,9 +123,16 @@ fn usockets_on_data(s usockets.Socket, data &char, length int) usockets.Socket {
 	if !response_sent {
 		if route_match := g_usockets_app.context_hybrid_router.match_route(method, path) {
 			mut hono_ctx := create_usockets_context(method, path, route_match.params, query_map, body)
-			middlewares := get_middlewares_for_path_usockets(g_usockets_app, path)
-			response := exec_middlewares_usockets(0, middlewares, mut hono_ctx, route_match.handler)
-			send_usockets_response(s, hono_ctx, response)
+			
+			// 优化1：零中间件快速路径
+			if !g_usockets_app.has_middlewares {
+				response := route_match.handler.handle(mut hono_ctx)
+				send_usockets_response(s, hono_ctx, response)
+			} else {
+				middlewares := get_middlewares_for_path_usockets_optimized(g_usockets_app, path)
+				response := exec_middlewares_usockets(0, middlewares, mut hono_ctx, route_match.handler)
+				send_usockets_response(s, hono_ctx, response)
+			}
 			response_sent = true
 		}
 	}
@@ -216,14 +233,17 @@ fn create_usockets_context(method string, path string, params map[string]string,
 	}
 }
 
-// 获取路径对应的所有中间件
-fn get_middlewares_for_path_usockets(app &Hono, path string) []ContextMiddleware {
+// 获取路径对应的所有中间件（优化版：使用预排序的前缀列表）
+fn get_middlewares_for_path_usockets_optimized(app &Hono, path string) []ContextMiddleware {
+	// 优化2：只有全局中间件时，直接返回引用（避免克隆）
+	if app.route_middlewares.len == 0 {
+		return app.context_middlewares
+	}
+	
 	mut middlewares := app.context_middlewares.clone()
 
-	mut prefixes := app.route_middlewares.keys()
-	prefixes.sort(a.len < b.len)
-
-	for prefix in prefixes {
+	// 优化3：使用预排序的前缀列表（启动时已排序，不需要每次请求都排序）
+	for prefix in app.sorted_middleware_prefixes {
 		if path.starts_with(prefix) || prefix == '/' {
 			if mws := app.route_middlewares[prefix] {
 				middlewares << mws
@@ -234,6 +254,11 @@ fn get_middlewares_for_path_usockets(app &Hono, path string) []ContextMiddleware
 	return middlewares
 }
 
+// 获取路径对应的所有中间件（保留旧版本兼容）
+fn get_middlewares_for_path_usockets(app &Hono, path string) []ContextMiddleware {
+	return get_middlewares_for_path_usockets_optimized(app, path)
+}
+
 // 执行中间件链
 fn exec_middlewares_usockets(idx int, middlewares []ContextMiddleware, mut ctx Context, handler IHandler) http.Response {
 	if idx < middlewares.len {

v.mod

@@ -1,7 +1,7 @@
 Module {
 	name: 'hono'
 	description: 'A high-performance V language web framework inspired by Hono.js, featuring hybrid routing, LRU cache, middleware support, and more.'
-	version: '0.3.6'
+	version: '0.3.7'
 	license: 'MIT'
 	dependencies: []
 }