修改不要go-morice框架

bootstraps/bootstrap.go

@@ -1,193 +1,169 @@
 package bootstraps
 
 import (
+	"context"
+	"fmt"
 	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
 
 	"git.x2erp.com/qdy/go-base/config"
 	"git.x2erp.com/qdy/go-base/logger"
-	"git.x2erp.com/qdy/go-base/myservice"
-	"git.x2erp.com/qdy/go-db/factory/database"
-	"go-micro.dev/v4/web"
 )
 
-// ServiceBootstrapper 服务启动器
-type ServiceBootstrapper struct {
+// Bootstrapper 服务启动器
+type Bootstrapper struct {
 	serviceName    string
 	serviceVersion string
 	Cfg            config.IConfig
-	DbFactory      *database.DBFactory
-	WebService     web.Service
+	HttpServer     *http.Server
+	Router         *http.ServeMux
+	quit           chan os.Signal
 }
 
-// NewServiceBootstrapper 创建服务启动器
-func NewServiceBootstrapper(name, version string) *ServiceBootstrapper {
-	return &ServiceBootstrapper{
+// New 创建启动器
+func New(name, version string) *Bootstrapper {
+	b := &Bootstrapper{
 		serviceName:    name,
 		serviceVersion: version,
+		quit:           make(chan os.Signal, 1),
+		Router:         http.NewServeMux(), // 直接创建路由器
 	}
-}
-
-// 初始化配置
-func (b *ServiceBootstrapper) InitConfig() {
-	// 1. 初始化启动日志
-	b.initBootLogger()
-
-	// 2. 加载配置
-	b.loadConfig()
-
-	// 3. 初始化数据库
-	//b.initDatabase()
-	//defer b.cleanupDatabase()
-
-	// 4. 初始化运行时日志
-	//b.initRuntimeLogger()
-
-	// 5. 设置优雅关闭
-	b.setupGracefulShutdown()
 
+	return b
 }
 
-// Run 启动服务
-func (b *ServiceBootstrapper) Run(routeRegistrar func(web.Service, *database.DBFactory)) {
-
-	if b.DbFactory == nil {
-		log.Fatal("数据库工厂未初始化，请先调用InitDatabase()")
-	}
-
-	// 6. 启动微服务
-	b.startWebService()
-
-	// 7. 注册路由
-	routeRegistrar(b.WebService, b.DbFactory)
-
-	// 8. 记录服务启动信息
-	b.logServiceInfo()
-
-	// 9. 初始化运行时日志
-	b.initRuntimeLogger()
-	defer b.closeBootLogger()
-	// 10. 运行服务
-	b.runWebService()
-}
-
-// initBootLogger 初始化启动日志
-func (b *ServiceBootstrapper) initBootLogger() {
+// Init 初始化配置和日志
+func (b *Bootstrapper) Init() *Bootstrapper {
+	// 1. 初始化启动日志
 	if err := logger.InitBootLog(b.serviceName); err != nil {
 		log.Fatal("无法初始化启动日志: ", err)
 	}
-}
-
-// closeBootLogger 关闭启动日志
-func (b *ServiceBootstrapper) closeBootLogger() {
-	logger.CloseBootLogger()
-}
-
-// loadConfig 加载配置
-func (b *ServiceBootstrapper) loadConfig() {
-
-	log.Printf("开始加载配置...")
 
+	// 2. 加载配置
+	log.Println("正在加载配置...")
 	cfg, err := config.GetConfig()
 	if err != nil {
-		log.Fatalf("加载配置文件错误: %v", err)
+		log.Fatalf("加载配置失败: %v", err)
 	}
-
-	// 设置版本
 	cfg.SetServiceName(b.serviceName)
 	cfg.SetServiceVersion(b.serviceVersion)
-
 	b.Cfg = cfg
-}
-
-// initDatabase 初始化数据库
-func (b *ServiceBootstrapper) InitDatabase() {
 
-	// 记录配置信息
-	//serviceCfg := cfg.GetService()
-	//microCfg := cfg.GetMicro()
-	dbCfg := b.Cfg.GetDatabase()
+	// 3. 初始化运行时日志
+	logger.InitRuntimeLogger(b.serviceName, b.serviceVersion, b.Cfg.GetLog())
+	log.Println("配置和日志初始化完成")
 
-	//log.Printf("服务名称: %s", serviceCfg.ServiceName)
-	//log.Printf("服务端口: %d", serviceCfg.Port)
-	//log.Printf("注册中心: %s", microCfg.RegistryAddress)
-	log.Printf("数据库: %s:%d/%s", dbCfg.Host, dbCfg.Port, dbCfg.Database)
+	return b
+}
 
-	log.Printf("初始化数据库连接...")
+// StartService 启动HTTP服务
+func (b *Bootstrapper) StartService() *Bootstrapper {
+	serviceCfg := b.Cfg.GetService()
 
-	dbFactory, err := database.GetDBFactory()
-	if err != nil {
-		log.Fatalf("数据库连接失败: %v", err)
+	// 创建HTTP服务器
+	b.HttpServer = &http.Server{
+		Addr:         fmt.Sprintf(":%d", serviceCfg.Port),
+		Handler:      b.Router, // 直接使用Router
+		ReadTimeout:  15 * time.Second,
+		WriteTimeout: 15 * time.Second,
+		IdleTimeout:  60 * time.Second,
 	}
-	b.DbFactory = dbFactory
 
-	log.Printf("数据库连接测试通过!")
+	log.Printf("正在启动服务: %s v%s", b.serviceName, b.serviceVersion)
+	log.Printf("模式: 独立运行 (net/http)")
+	log.Printf("服务端口: :%d", serviceCfg.Port)
 
+	return b
 }
 
-// cleanupDatabase 清理数据库资源
-func (b *ServiceBootstrapper) CleanupDatabase() {
-	if b.DbFactory != nil {
-		if err := b.DbFactory.Close(); err != nil {
-			logger.Error("数据库关闭错误: %v", err)
+// Run 运行服务
+func (b *Bootstrapper) Run() {
+	log.Printf("服务 %s 开始运行...", b.serviceName)
+
+	// 设置信号监听 - 在这里设置，而不是在New中
+	signal.Notify(b.quit, syscall.SIGINT, syscall.SIGTERM)
+
+	// 启动HTTP服务器
+	go func() {
+		log.Printf("服务器启动在 %s", b.HttpServer.Addr)
+		if err := b.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("服务运行失败: %v", err)
 		}
-	}
+	}()
+
+	// 等待中断信号
+	b.waitForShutdown()
 }
 
-// initRuntimeLogger 初始化运行时日志
-func (b *ServiceBootstrapper) initRuntimeLogger() {
-	logger.InitRuntimeLogger(b.serviceName, b.serviceVersion, b.Cfg.GetLog())
-	log.Printf("运行时日志系统初始化完成")
-	log.Printf("开始启动微服务...")
+// RunTLS 运行HTTPS服务
+func (b *Bootstrapper) RunTLS(certFile, keyFile string) {
+	log.Printf("服务 %s 开始运行(HTTPS)...", b.serviceName)
 
-	// 记录服务模式
-	mode := "独立模式"
-	if b.Cfg.GetMicro().RegistryAddress != "" {
-		mode = "使用服务发现 (注册中心)"
-	}
-	log.Printf("服务模式: %s", mode)
-}
+	// 设置信号监听
+	signal.Notify(b.quit, syscall.SIGINT, syscall.SIGTERM)
 
-// setupGracefulShutdown 设置优雅关闭
-func (b *ServiceBootstrapper) setupGracefulShutdown() {
-	setupGracefulShutdown(b.DbFactory, logger.StopESWriter)
+	// 启动HTTPS服务器
+	go func() {
+		log.Printf("HTTPS服务器启动在 %s", b.HttpServer.Addr)
+		if err := b.HttpServer.ListenAndServeTLS(certFile, keyFile); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("服务运行失败: %v", err)
+		}
+	}()
+
+	// 等待中断信号
+	b.waitForShutdown()
 }
 
-// startWebService 启动Web服务
-func (b *ServiceBootstrapper) startWebService() {
-	microCfg := b.Cfg.GetMicro()
-	serviceCfg := b.Cfg.GetService()
+// waitForShutdown 等待关闭信号
+func (b *Bootstrapper) waitForShutdown() {
+	log.Println("按 Ctrl+C 停止服务")
 
-	var svc web.Service
-	if microCfg.RegistryAddress != "" {
-		svc = myservice.Start(b.Cfg)
+	// 等待信号
+	<-b.quit
+	log.Println("接收到终止信号，正在优雅关闭服务...")
+
+	// 创建关闭上下文，给30秒完成当前请求
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	// 停止接收新请求，完成当前请求
+	if err := b.HttpServer.Shutdown(ctx); err != nil {
+		log.Printf("服务关闭失败: %v", err)
 	} else {
-		svc = myservice.StartStandalone(b.Cfg)
+		log.Println("HTTP服务器已关闭")
 	}
 
-	b.WebService = svc
-	log.Printf("Web服务实例创建完成 (端口: %d)", serviceCfg.Port)
-}
+	// 停止日志写入
+	logger.StopESWriter()
+	log.Println("服务优雅关闭完成")
 
-// logServiceInfo 记录服务启动信息
-func (b *ServiceBootstrapper) logServiceInfo() {
-	serviceCfg := b.Cfg.GetService()
+	// 等待一小段时间确保日志写入完成
+	time.Sleep(100 * time.Millisecond)
+	os.Exit(0)
+}
 
-	log.Printf("服务启动成功")
+// GetConfig 获取配置
+func (b *Bootstrapper) GetConfig() config.IConfig {
+	return b.Cfg
+}
 
-	if serviceCfg.TrustedProxies != "" {
-		log.Printf("   • 受信代理: %s", serviceCfg.TrustedProxies)
-	}
+// GetRouter 获取路由器
+func (b *Bootstrapper) GetRouter() *http.ServeMux {
+	return b.Router
 }
 
-// runWebService 运行Web服务
-func (b *ServiceBootstrapper) runWebService() {
-	// 测试日志
-	logger.Debug("测试日志是否写入ES.")
+// 兼容性方法
 
-	log.Printf("服务开始运行...")
-	defer b.CleanupDatabase()
+// GetWebService 获取Web服务（兼容性方法）
+func (b *Bootstrapper) GetWebService() interface{} {
+	return b.Router
+}
 
-	if err := b.WebService.Run(); err != nil {
-		log.Fatal("服务运行失败:", err)
-	}
+// Handle 注册路由处理器（兼容性方法）
+func (b *Bootstrapper) Handle(pattern string, handler http.Handler) {
+	b.Router.Handle(pattern, handler)
 }

bootstraps/shutdown.go

@@ -11,7 +11,7 @@ import (
 )
 
 // setupGracefulShutdown 设置优雅关闭
-func setupGracefulShutdown(dbFactory *database.DBFactory, cleanupFuncs ...func()) {
+func SetupGracefulShutdown(dbFactory *database.DBFactory, cleanupFuncs ...func()) {
 	signalCh := make(chan os.Signal, 1)
 	signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM)
 

ctx/RequestContext.go

@@ -20,20 +20,21 @@ type ctxKey struct{}
 var loggerKey = ctxKey{}
 
 // Save RequestContext
-func SaveContext(r *http.Request, requestContext RequestContext) *http.Request {
+func SaveContext(r *http.Request, requestContext *RequestContext) *http.Request {
 	ctx := context.WithValue(r.Context(), loggerKey, requestContext)
 	return r.WithContext(ctx)
 }
 
-// Get 从请求获取RequestContext
+// GetContext 从请求获取RequestContext
 func GetContext(r *http.Request) *RequestContext {
 	if r == nil {
 		return &RequestContext{}
 	}
 
 	if v := r.Context().Value(loggerKey); v != nil {
-		if loggerCtx, ok := v.(RequestContext); ok {
-			return &loggerCtx
+		// 修正：类型断言为 *RequestContext
+		if loggerCtx, ok := v.(*RequestContext); ok {
+			return loggerCtx
 		}
 	}
 

handlers/routes.go

@@ -1,26 +0,0 @@
-package handlers
-
-import (
-	"git.x2erp.com/qdy/go-base/logger"
-	"git.x2erp.com/qdy/go-db/factory/database"
-	"go-micro.dev/v4/web"
-)
-
-// RouteConfig 路由配置
-type RouteConfig struct {
-	ServiceName    string
-	ServiceVersion string
-	DBFactory      *database.DBFactory
-}
-
-// RegisterBaseRoutes 注册基本路由
-func RegisterBaseRoutes(webService web.Service, cfg *RouteConfig) {
-	// 创建基础处理器
-	baseHandlers := NewBaseHandlers(cfg.ServiceName, cfg.ServiceVersion)
-
-	webService.Handle("/", baseHandlers.RootHandler())
-	webService.Handle("/health", baseHandlers.HealthHandler(cfg.DBFactory))
-	webService.Handle("/info", baseHandlers.InfoHandler())
-
-	logger.Info("HTTP路由注册完成")
-}

logger/runtime_logger.go

@@ -321,3 +321,11 @@ func Sync() error {
 func StopESWriter() {
 	http.StopESWriter()
 }
+
+// IsDebug 判断是否启用Debug级别
+func IsDebug() bool {
+	if runtimeLogger == nil {
+		return false
+	}
+	return runtimeLogger.Core().Enabled(zapcore.DebugLevel)
+}

middleware/authMiddleware.go → middleware/auth_middleware.go

@@ -6,10 +6,15 @@ import (
 	"strings"
 	"time"
 
+	"git.x2erp.com/qdy/go-base/config"
 	"git.x2erp.com/qdy/go-base/ctx"
+	"git.x2erp.com/qdy/go-base/logger"
 	"git.x2erp.com/qdy/go-base/types"
 )
 
+// 全局配置（单例）
+var appConfig config.IConfig
+
 // ResponseFormat 响应格式
 type ResponseFormat int
 
@@ -18,6 +23,11 @@ const (
 	FormatCSV
 )
 
+// JWTAuthMiddlewareInit 初始化中间件配置
+func JWTAuthMiddlewareInit(config config.IConfig) {
+	appConfig = config
+}
+
 // JWT认证中间件（支持指定响应格式）
 func JWTAuthMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -46,15 +56,20 @@ func JWTAuthMiddleware(next http.Handler) http.Handler {
 
 		//保存上下文
 		// 创建LoggerContext（从token解析用户信息）
-		requestContext := ctx.RequestContext{
-			TraceID:  "trace_id-123", // 生成追踪ID
-			TenantID: "tenant-123",   // 从token解析
-			UserID:   "user-456",     // 从token解析
+		requestContext := &ctx.RequestContext{
+			ServiceName:  appConfig.GetService().ServiceName,
+			InstanceName: appConfig.GetService().InstanceName,
+			TraceID:      "trace_id-123", // 生成追踪ID
+			TenantID:     "tenant-123",   // 从token解析
+			UserID:       "user-456",     // 从token解析
+		}
+
+		if logger.IsDebug() {
+			logger.DebugC(requestContext, "Before save requestContext: %+v", requestContext)
 		}
 
 		// 保存到请求
 		r = ctx.SaveContext(r, requestContext)
-
 		// 继续处理请求
 		next.ServeHTTP(w, r)
 	})

webx/web_binder.go

@@ -1,159 +0,0 @@
-package webx
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"reflect"
-	"strconv"
-	"strings"
-)
-
-// invokeHandler 调用处理器函数
-func (rb *routeBuilder) invokeHandler(ctx context.Context, w http.ResponseWriter, req *http.Request) {
-	handlerType := reflect.TypeOf(rb.handler)
-	handlerValue := reflect.ValueOf(rb.handler)
-
-	// 获取参数数量
-	numIn := handlerType.NumIn()
-	args := make([]reflect.Value, numIn)
-
-	// 绑定每个参数
-	for i := 0; i < numIn; i++ {
-		paramType := handlerType.In(i)
-		args[i] = rb.bindParam(i, paramType, ctx, w, req)
-	}
-
-	// 调用处理器函数
-	results := handlerValue.Call(args)
-
-	// 处理返回值
-	rb.handleResults(results, w)
-}
-
-// bindParam 绑定单个参数
-func (rb *routeBuilder) bindParam(index int, paramType reflect.Type, ctx context.Context, w http.ResponseWriter, req *http.Request) reflect.Value {
-	// 特殊类型绑定
-	switch paramType {
-	case reflect.TypeOf((*http.ResponseWriter)(nil)).Elem():
-		return reflect.ValueOf(w)
-	case reflect.TypeOf((*http.Request)(nil)):
-		return reflect.ValueOf(req)
-	case reflect.TypeOf((*context.Context)(nil)).Elem():
-		return reflect.ValueOf(ctx)
-	}
-
-	// 基本类型 - 尝试从路径参数绑定
-	if paramType.Kind() == reflect.String || paramType.Kind() == reflect.Int || paramType.Kind() == reflect.Int64 {
-		// 尝试从路径中提取参数
-		if pathParam := extractPathParam(rb.path, req.URL.Path, index); pathParam != "" {
-			return convertToType(pathParam, paramType)
-		}
-
-		// 尝试从查询参数绑定
-		if queryParam := extractQueryParam(paramType.Name(), req); queryParam != "" {
-			return convertToType(queryParam, paramType)
-		}
-	}
-
-	// 结构体 - 从 JSON 请求体绑定
-	if paramType.Kind() == reflect.Struct || (paramType.Kind() == reflect.Ptr && paramType.Elem().Kind() == reflect.Struct) {
-		return rb.bindFromJSON(paramType, req)
-	}
-
-	// 返回零值
-	return reflect.Zero(paramType)
-}
-
-// extractPathParam 从路径提取参数
-func extractPathParam(pattern, actualPath string, index int) string {
-	patternParts := strings.Split(strings.Trim(pattern, "/"), "/")
-	actualParts := strings.Split(strings.Trim(actualPath, "/"), "/")
-
-	for i, part := range patternParts {
-		if strings.HasPrefix(part, "{") && strings.HasSuffix(part, "}") {
-			if i < len(actualParts) {
-				return actualParts[i]
-			}
-		}
-	}
-
-	// 如果路径中没有参数，尝试最后一个部分
-	if len(actualParts) > 0 {
-		return actualParts[len(actualParts)-1]
-	}
-
-	return ""
-}
-
-// extractQueryParam 从查询参数提取
-func extractQueryParam(paramName string, req *http.Request) string {
-	// 转换为小写查找
-	key := strings.ToLower(paramName)
-	return req.URL.Query().Get(key)
-}
-
-// bindFromJSON 从 JSON 绑定
-func (rb *routeBuilder) bindFromJSON(paramType reflect.Type, req *http.Request) reflect.Value {
-	var val reflect.Value
-
-	if paramType.Kind() == reflect.Ptr {
-		val = reflect.New(paramType.Elem())
-	} else {
-		val = reflect.New(paramType)
-	}
-
-	if req.Body != nil {
-		defer req.Body.Close()
-		json.NewDecoder(req.Body).Decode(val.Interface())
-	}
-
-	if paramType.Kind() == reflect.Ptr {
-		return val
-	}
-	return val.Elem()
-}
-
-// convertToType 字符串转换为指定类型
-func convertToType(str string, targetType reflect.Type) reflect.Value {
-	switch targetType.Kind() {
-	case reflect.String:
-		return reflect.ValueOf(str)
-	case reflect.Int:
-		if i, err := strconv.Atoi(str); err == nil {
-			return reflect.ValueOf(i)
-		}
-	case reflect.Int64:
-		if i, err := strconv.ParseInt(str, 10, 64); err == nil {
-			return reflect.ValueOf(i)
-		}
-	case reflect.Bool:
-		if b, err := strconv.ParseBool(str); err == nil {
-			return reflect.ValueOf(b)
-		}
-	}
-	return reflect.Zero(targetType)
-}
-
-// handleResults 处理返回值
-func (rb *routeBuilder) handleResults(results []reflect.Value, w http.ResponseWriter) {
-	if len(results) == 0 {
-		return
-	}
-
-	// 第一个返回值处理
-	firstResult := results[0].Interface()
-
-	// 如果是错误
-	if err, ok := firstResult.(error); ok {
-		w.WriteHeader(http.StatusInternalServerError)
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"error": err.Error(),
-		})
-		return
-	}
-
-	// 如果是其他类型，返回 JSON
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(firstResult)
-}

webx/web_router.go

@@ -1,128 +0,0 @@
-package webx
-
-import (
-	"net/http"
-)
-
-// HandlerFunc 通用的处理器函数类型
-type HandlerFunc interface{}
-
-// Router 路由器
-type Router struct {
-	mux          *http.ServeMux
-	globalBefore []func(http.Handler) http.Handler
-	globalAfter  []func(http.ResponseWriter, *http.Request)
-}
-
-func NewRouter(mux *http.ServeMux) *Router {
-	return &Router{
-		mux: mux,
-	}
-}
-
-// UseBefore 在处理器前执行的中间件
-func (r *Router) UseBefore(middleware ...func(http.Handler) http.Handler) *Router {
-	r.globalBefore = append(r.globalBefore, middleware...)
-	return r
-}
-
-// UseAfter 在处理器后执行的中间件
-func (r *Router) UseAfter(middleware ...func(http.ResponseWriter, *http.Request)) *Router {
-	r.globalAfter = append(r.globalAfter, middleware...)
-	return r
-}
-
-// GET 注册 GET 请求
-func (r *Router) GET(path string, handler HandlerFunc) *routeBuilder {
-	return r.handle("GET", path, handler)
-}
-
-// POST 注册 POST 请求
-func (r *Router) POST(path string, handler HandlerFunc) *routeBuilder {
-	return r.handle("POST", path, handler)
-}
-
-// handle 内部处理方法
-func (r *Router) handle(method, path string, handler HandlerFunc) *routeBuilder {
-	return &routeBuilder{
-		router:  r,
-		method:  method,
-		path:    path,
-		handler: handler,
-	}
-}
-
-// 路由构建器
-type routeBuilder struct {
-	router      *Router
-	method      string
-	path        string
-	handler     HandlerFunc
-	before      []func(http.Handler) http.Handler
-	after       []func(http.ResponseWriter, *http.Request)
-	description string
-}
-
-// Before 添加路由前中间件
-func (rb *routeBuilder) Before(middleware ...func(http.Handler) http.Handler) *routeBuilder {
-	rb.before = append(rb.before, middleware...)
-	return rb
-}
-
-// After 添加路由后中间件
-func (rb *routeBuilder) After(middleware ...func(http.ResponseWriter, *http.Request)) *routeBuilder {
-	rb.after = append(rb.after, middleware...)
-	return rb
-}
-
-// Desc 添加描述
-func (rb *routeBuilder) Desc(desc string) *routeBuilder {
-	rb.description = desc
-	return rb
-}
-
-// Register 注册路由
-func (rb *routeBuilder) Register() {
-	// 创建最终的 HTTP 处理器
-	finalHandler := rb.createHandler()
-
-	// 应用路由级 before 中间件
-	for i := len(rb.before) - 1; i >= 0; i-- {
-		finalHandler = rb.before[i](finalHandler)
-	}
-
-	// 应用全局 before 中间件
-	for i := len(rb.router.globalBefore) - 1; i >= 0; i-- {
-		finalHandler = rb.router.globalBefore[i](finalHandler)
-	}
-
-	// 注册到 ServeMux
-	rb.router.mux.Handle(rb.path, finalHandler)
-}
-
-// 创建处理器
-func (rb *routeBuilder) createHandler() http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		// 方法检查
-		if rb.method != "" && req.Method != rb.method {
-			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-			return
-		}
-
-		// 创建上下文
-		ctx := req.Context()
-
-		// 执行处理器
-		rb.invokeHandler(ctx, w, req)
-
-		// 执行路由级 after 中间件
-		for _, after := range rb.after {
-			after(w, req)
-		}
-
-		// 执行全局 after 中间件
-		for _, after := range rb.router.globalAfter {
-			after(w, req)
-		}
-	})
-}

webx/web_service.go

@@ -4,28 +4,31 @@ import (
 	"encoding/json"
 	"net/http"
 	"reflect"
+	"strconv"
 	"strings"
+
+	"git.x2erp.com/qdy/go-base/ctx"
 )
 
 // WebService 路由服务
 type WebService struct {
-	router *http.ServeMux
+	router      *http.ServeMux
+	middlewares []func(http.Handler) http.Handler
 }
 
 // NewWebService 创建WebService
 func NewWebService(router *http.ServeMux) *WebService {
-	return &WebService{router: router}
+	ws := &WebService{
+		router: router,
+	}
+
+	return ws
 }
 
-// RouteBuilder 路由构建器
-type RouteBuilder struct {
-	method      string
-	path        string
-	handlerFunc reflect.Value
-	paramNames  []string
-	paramTypes  []reflect.Type
-	middlewares []func(http.Handler) http.Handler
-	router      *http.ServeMux
+// Use 添加全局中间件
+func (ws *WebService) Use(middleware func(http.Handler) http.Handler) *WebService {
+	ws.middlewares = append(ws.middlewares, middleware)
+	return ws
 }
 
 // GET 注册GET请求
@@ -62,60 +65,135 @@ func (ws *WebService) handle(method, path string, handler interface{}) *RouteBui
 		panic("handler must be a function")
 	}
 
-	// 获取参数类型
-	paramTypes := make([]reflect.Type, handlerType.NumIn())
-	for i := 0; i < handlerType.NumIn(); i++ {
-		paramTypes[i] = handlerType.In(i)
-	}
-
 	// 验证返回值
 	if handlerType.NumOut() != 2 {
 		panic("handler must return exactly 2 values: (T, error)")
 	}
 
 	return &RouteBuilder{
+		ws:          ws,
 		method:      method,
 		path:        path,
 		handlerFunc: handlerValue,
 		paramNames:  paramNames,
-		paramTypes:  paramTypes,
-		router:      ws.router,
 	}
 }
 
-// Use 添加中间件
+// // 上下文中间件
+// func (ws *WebService) contextMiddleware() func(http.Handler) http.Handler {
+// 	return func(next http.Handler) http.Handler {
+// 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+// 			// 自动创建 RequestContext
+// 			reqCtx := ws.createRequestContext(r)
+
+// 			// 保存到请求中
+// 			r = ctx.SaveContext(r, *reqCtx)
+// 			next.ServeHTTP(w, r)
+// 		})
+// 	}
+// }
+
+// // 创建 RequestContext
+// func (ws *WebService) createRequestContext(r *http.Request) *ctx.RequestContext {
+// 	return &ctx.RequestContext{
+// 		TraceID:      generateTraceID(),
+// 		ServiceName:  getServiceName(r),
+// 		InstanceName: getInstanceName(),
+// 		TenantID:     r.Header.Get("X-Tenant-ID"),
+// 		UserID:       extractUserID(r),
+// 	}
+// }
+
+// // 辅助函数
+// func generateTraceID() string {
+// 	return "trace-" + strconv.FormatInt(time.Now().UnixNano(), 36)
+// }
+
+// func getServiceName(r *http.Request) string {
+// 	if serviceName := r.Header.Get("X-Service-Name"); serviceName != "" {
+// 		return serviceName
+// 	}
+// 	return "unknown-service"
+// }
+
+// func getInstanceName() string {
+// 	// 获取主机名
+// 	hostname, _ := os.Hostname()
+// 	if hostname != "" {
+// 		return hostname
+// 	}
+// 	return "instance-1"
+// }
+
+// func extractUserID(r *http.Request) string {
+// 	if auth := r.Header.Get("Authorization"); auth != "" {
+// 		// 简单示例：从 Authorization 头提取
+// 		if strings.HasPrefix(auth, "Bearer ") {
+// 			// 这里可以解析 JWT token 获取用户ID
+// 			// 暂时返回示例值
+// 			return "user-from-token"
+// 		}
+// 	}
+// 	return ""
+// }
+
+// RouteBuilder 路由构建器
+type RouteBuilder struct {
+	ws          *WebService
+	method      string
+	path        string
+	handlerFunc reflect.Value
+	paramNames  []string
+	middlewares []func(http.Handler) http.Handler
+	description string
+}
+
+// Use 添加路由级中间件
 func (rb *RouteBuilder) Use(middleware ...func(http.Handler) http.Handler) *RouteBuilder {
 	rb.middlewares = append(rb.middlewares, middleware...)
 	return rb
 }
 
+// Desc 添加描述
+func (rb *RouteBuilder) Desc(description string) *RouteBuilder {
+	rb.description = description
+	return rb
+}
+
 // Register 注册路由
 func (rb *RouteBuilder) Register() {
 	// 创建适配器
 	adapter := &handlerAdapter{
+		ws:          rb.ws,
 		method:      rb.method,
 		pathPattern: rb.path,
 		paramNames:  rb.paramNames,
-		paramTypes:  rb.paramTypes,
 		handlerFunc: rb.handlerFunc,
 	}
 
-	// 应用中间件
+	// 构建处理链：全局中间件 → 路由中间件 → 处理器
 	var handler http.Handler = adapter
+
+	// 1. 应用路由级中间件（从后往前）
 	for i := len(rb.middlewares) - 1; i >= 0; i-- {
 		handler = rb.middlewares[i](handler)
 	}
 
+	// 2. 应用全局中间件（从后往前）
+	for i := len(rb.ws.middlewares) - 1; i >= 0; i-- {
+		handler = rb.ws.middlewares[i](handler)
+	}
+
 	// 注册到路由器
-	rb.router.Handle(rb.path, handler)
+	rb.ws.router.Handle(rb.path, handler)
 }
 
 // handlerAdapter 处理器适配器
 type handlerAdapter struct {
+	ws          *WebService
 	method      string
 	pathPattern string
 	paramNames  []string
-	paramTypes  []reflect.Type
 	handlerFunc reflect.Value
 }
 
@@ -130,7 +208,7 @@ func (ha *handlerAdapter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	pathParams := ha.parsePathParams(r.URL.Path)
 
 	// 2. 构建函数参数
-	args := ha.buildArgs(r, pathParams)
+	args := ha.buildArgs(w, r, pathParams)
 	if args == nil {
 		http.Error(w, "Invalid parameters", http.StatusBadRequest)
 		return
@@ -147,65 +225,263 @@ func (ha *handlerAdapter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 func (ha *handlerAdapter) parsePathParams(requestPath string) map[string]string {
 	params := make(map[string]string)
 
-	// 简单实现：按/分割，然后匹配
-	patternParts := strings.Split(ha.pathPattern, "/")
-	requestParts := strings.Split(requestPath, "/")
+	pattern := strings.Trim(ha.pathPattern, "/")
+	request := strings.Trim(requestPath, "/")
 
-	if len(patternParts) != len(requestParts) {
-		return params
-	}
+	patternParts := strings.Split(pattern, "/")
+	requestParts := strings.Split(request, "/")
 
 	for i, patternPart := range patternParts {
 		if strings.HasPrefix(patternPart, "{") && strings.HasSuffix(patternPart, "}") {
 			paramName := patternPart[1 : len(patternPart)-1]
-			params[paramName] = requestParts[i]
+			if i < len(requestParts) {
+				params[paramName] = requestParts[i]
+			}
 		}
 	}
 
 	return params
 }
+func (ha *handlerAdapter) buildArgs(w http.ResponseWriter, r *http.Request, pathParams map[string]string) []reflect.Value {
+	handlerType := ha.handlerFunc.Type()
+	numIn := handlerType.NumIn()
+	args := make([]reflect.Value, numIn)
+
+	for i := 0; i < numIn; i++ {
+		paramType := handlerType.In(i)
+		paramName := getParamName(i, handlerType, ha.paramNames)
+
+		// 1. 检查是否是特殊类型
+		if arg := ha.bindSpecialType(paramType, w, r); arg.IsValid() {
+			args[i] = arg
+			continue
+		}
 
-// buildArgs 构建函数参数
-func (ha *handlerAdapter) buildArgs(r *http.Request, pathParams map[string]string) []reflect.Value {
-	args := make([]reflect.Value, len(ha.paramTypes))
+		// 2. 检查是否是 *ctx.RequestContext 类型
+		if paramType == reflect.TypeOf((*ctx.RequestContext)(nil)) {
+			reqCtx := ctx.GetContext(r)
+			args[i] = reflect.ValueOf(reqCtx)
+			continue
+		}
 
-	// 参数索引
-	pathParamIndex := 0
+		// 3. 只按名称匹配路径参数
+		if value, ok := pathParams[paramName]; ok {
+			args[i] = convertToType(value, paramType)
+			continue
+		}
 
-	for i, paramType := range ha.paramTypes {
-		// 情况1：路径参数（必须是string类型）
-		if pathParamIndex < len(ha.paramNames) && paramType.Kind() == reflect.String {
-			paramName := ha.paramNames[pathParamIndex]
-			if value, ok := pathParams[paramName]; ok {
-				args[i] = reflect.ValueOf(value)
-				pathParamIndex++
-				continue
-			}
+		// 4. 尝试从查询参数获取
+		if queryValue := r.URL.Query().Get(paramName); queryValue != "" {
+			args[i] = convertToType(queryValue, paramType)
+			continue
 		}
 
-		// 情况2：Body参数（POST/PUT等请求的结构体）
-		if r.Method == "POST" || r.Method == "PUT" || r.Method == "PATCH" {
-			// 检查是否是结构体类型
-			if paramType.Kind() == reflect.Struct ||
-				(paramType.Kind() == reflect.Ptr && paramType.Elem().Kind() == reflect.Struct) {
-				bodyParam, err := ha.parseBody(r, paramType)
-				if err != nil {
-					return nil
-				}
-				args[i] = bodyParam
+		// 5. 尝试从JSON body获取（POST/PUT请求）
+		if (r.Method == "POST" || r.Method == "PUT" || r.Method == "PATCH") &&
+			(paramType.Kind() == reflect.Struct ||
+				(paramType.Kind() == reflect.Ptr && paramType.Elem().Kind() == reflect.Struct)) {
+			if arg := ha.parseBody(r, paramType); arg.IsValid() {
+				args[i] = arg
 				continue
 			}
 		}
 
-		// 无法处理的参数类型
-		return nil
+		// 6. 返回零值
+		args[i] = reflect.Zero(paramType)
 	}
 
 	return args
 }
 
+// func (ha *handlerAdapter) buildArgs(w http.ResponseWriter, r *http.Request, pathParams map[string]string) []reflect.Value {
+// 	handlerType := ha.handlerFunc.Type()
+// 	numIn := handlerType.NumIn()
+// 	args := make([]reflect.Value, numIn)
+
+// 	// 收集所有 string 类型的参数索引
+// 	var stringParamIndices []int
+// 	for i := 0; i < numIn; i++ {
+// 		paramType := handlerType.In(i)
+// 		if paramType.Kind() == reflect.String &&
+// 			paramType != reflect.TypeOf((*ctx.RequestContext)(nil)) {
+// 			stringParamIndices = append(stringParamIndices, i)
+// 		}
+// 	}
+
+// 	// 处理每个参数
+// 	stringParamIndex := 0
+// 	for i := 0; i < numIn; i++ {
+// 		paramType := handlerType.In(i)
+// 		paramName := getParamName(i, handlerType, ha.paramNames)
+
+// 		// 1. 检查是否是特殊类型
+// 		if arg := ha.bindSpecialType(paramType, w, r); arg.IsValid() {
+// 			args[i] = arg
+// 			continue
+// 		}
+
+// 		// 2. 检查是否是 *ctx.RequestContext 类型
+// 		if paramType == reflect.TypeOf((*ctx.RequestContext)(nil)) {
+// 			reqCtx := ctx.GetContext(r)
+// 			args[i] = reflect.ValueOf(reqCtx)
+// 			continue
+// 		}
+
+// 		// 3. 处理路径参数
+// 		matched := false
+
+// 		// 如果有对应的路径参数名，直接匹配
+// 		if value, ok := pathParams[paramName]; ok && paramType.Kind() == reflect.String {
+// 			args[i] = convertToType(value, paramType)
+// 			matched = true
+// 		}
+
+// 		// 如果是 string 类型但没有匹配到名称，按顺序分配路径参数
+// 		if !matched && paramType.Kind() == reflect.String {
+// 			// 使用 stringParamIndices 中的位置来匹配 pathParamNames
+// 			if stringParamIndex < len(ha.paramNames) && stringParamIndex < len(stringParamIndices) {
+// 				paramName := ha.paramNames[stringParamIndex]
+// 				if value, ok := pathParams[paramName]; ok {
+// 					args[i] = convertToType(value, paramType)
+// 					matched = true
+// 					stringParamIndex++
+// 				}
+// 			}
+// 		}
+
+// 		if matched {
+// 			continue
+// 		}
+
+// 		// 4. 其他绑定逻辑...
+// 		// 查询参数、JSON body 等
+// 	}
+
+// 	return args
+// }
+
+// // buildArgs 构建函数参数
+// func (ha *handlerAdapter) buildArgs(w http.ResponseWriter, r *http.Request, pathParams map[string]string) []reflect.Value {
+// 	handlerType := ha.handlerFunc.Type()
+// 	numIn := handlerType.NumIn()
+// 	args := make([]reflect.Value, numIn)
+
+// 	for i := 0; i < numIn; i++ {
+// 		paramType := handlerType.In(i)
+// 		paramName := getParamName(i, handlerType, ha.paramNames)
+
+// 		// 1. 检查是否是特殊类型
+// 		if arg := ha.bindSpecialType(paramType, w, r); arg.IsValid() {
+// 			args[i] = arg
+// 			continue
+// 		}
+
+// 		// 2. 检查是否是 *ctx.RequestContext 类型
+// 		if paramType == reflect.TypeOf((*ctx.RequestContext)(nil)) {
+// 			reqCtx := ctx.GetContext(r)
+// 			if logger.IsDebug() {
+// 				logger.DebugC(reqCtx, "requestContext: %+v", reqCtx)
+// 			}
+// 			args[i] = reflect.ValueOf(reqCtx)
+// 			continue
+// 		}
+
+// 		// 3. 尝试从路径参数获取
+// 		if value, ok := pathParams[paramName]; ok {
+// 			if arg := convertToType(value, paramType); arg.IsValid() {
+// 				args[i] = arg
+// 				continue
+// 			}
+// 		}
+
+// 		// 4. 尝试从查询参数获取
+// 		if queryValue := r.URL.Query().Get(paramName); queryValue != "" {
+// 			if arg := convertToType(queryValue, paramType); arg.IsValid() {
+// 				args[i] = arg
+// 				continue
+// 			}
+// 		}
+
+// 		// 5. 尝试从JSON body获取
+// 		if (r.Method == "POST" || r.Method == "PUT" || r.Method == "PATCH") &&
+// 			(paramType.Kind() == reflect.Struct ||
+// 				(paramType.Kind() == reflect.Ptr && paramType.Elem().Kind() == reflect.Struct)) {
+// 			if arg := ha.parseBody(r, paramType); arg.IsValid() {
+// 				args[i] = arg
+// 				continue
+// 			}
+// 		}
+
+// 		// 6. 返回零值
+// 		args[i] = reflect.Zero(paramType)
+// 	}
+
+// 	return args
+// }
+
+// bindSpecialType 绑定特殊类型
+func (ha *handlerAdapter) bindSpecialType(paramType reflect.Type, w http.ResponseWriter, r *http.Request) reflect.Value {
+	switch paramType {
+	case reflect.TypeOf((*http.ResponseWriter)(nil)).Elem():
+		return reflect.ValueOf(w)
+	case reflect.TypeOf((*http.Request)(nil)):
+		return reflect.ValueOf(r)
+	}
+	return reflect.Value{}
+}
+
+// getParamName 获取参数名
+func getParamName(index int, handlerType reflect.Type, pathParamNames []string) string {
+	// 如果有路径参数名，优先使用
+	if index < len(pathParamNames) {
+		return pathParamNames[index]
+	}
+
+	// 使用类型名的蛇形格式
+	paramType := handlerType.In(index)
+	typeName := paramType.Name()
+	if typeName == "" {
+		return strconv.Itoa(index)
+	}
+
+	// 转换为蛇形格式：MyInterface -> my_interface
+	var result []rune
+	for i, r := range typeName {
+		if i > 0 && 'A' <= r && r <= 'Z' {
+			result = append(result, '_')
+		}
+		result = append(result, r)
+	}
+	return strings.ToLower(string(result))
+}
+
+// convertToType 字符串转换为指定类型
+func convertToType(str string, targetType reflect.Type) reflect.Value {
+	switch targetType.Kind() {
+	case reflect.String:
+		return reflect.ValueOf(str)
+	case reflect.Int:
+		if i, err := strconv.Atoi(str); err == nil {
+			return reflect.ValueOf(i)
+		}
+	case reflect.Int64:
+		if i, err := strconv.ParseInt(str, 10, 64); err == nil {
+			return reflect.ValueOf(i)
+		}
+	case reflect.Bool:
+		if b, err := strconv.ParseBool(str); err == nil {
+			return reflect.ValueOf(b)
+		}
+	case reflect.Float64:
+		if f, err := strconv.ParseFloat(str, 64); err == nil {
+			return reflect.ValueOf(f)
+		}
+	}
+	return reflect.Value{}
+}
+
 // parseBody 解析请求体
-func (ha *handlerAdapter) parseBody(r *http.Request, paramType reflect.Type) (reflect.Value, error) {
+func (ha *handlerAdapter) parseBody(r *http.Request, paramType reflect.Type) reflect.Value {
 	// 创建参数实例
 	var paramValue reflect.Value
 	if paramType.Kind() == reflect.Ptr {
@@ -216,15 +492,16 @@ func (ha *handlerAdapter) parseBody(r *http.Request, paramType reflect.Type) (re
 
 	// 解析JSON
 	if err := json.NewDecoder(r.Body).Decode(paramValue.Interface()); err != nil {
-		return reflect.Value{}, err
+		return reflect.Value{}
 	}
+	defer r.Body.Close()
 
 	// 如果是非指针类型，需要解引用
 	if paramType.Kind() != reflect.Ptr {
 		paramValue = paramValue.Elem()
 	}
 
-	return paramValue, nil
+	return paramValue
 }
 
 // handleResponse 处理响应
@@ -248,7 +525,7 @@ func (ha *handlerAdapter) handleResponse(w http.ResponseWriter, results []reflec
 // extractPathParams 从路径中提取参数名
 func extractPathParams(path string) []string {
 	var params []string
-	parts := strings.Split(path, "/")
+	parts := strings.Split(strings.Trim(path, "/"), "/")
 
 	for _, part := range parts {
 		if strings.HasPrefix(part, "{") && strings.HasSuffix(part, "}") {