改成支持单数据库和单服务

bootstraps/bootstrap.go

@@ -1,403 +1,403 @@
 package bootstraps
 
-import (
-	"context"
-	"fmt"
-	"log"
-	"net/http"
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
-
-	"git.x2erp.com/qdy/go-base/client"
-	"git.x2erp.com/qdy/go-base/config"
-	"git.x2erp.com/qdy/go-base/consul"
-	"git.x2erp.com/qdy/go-base/logger"
-)
-
-// 定义接口
-type ShutdownHandler interface {
-	OnShutdown()
-}
-
-// WebService Web服务实例
-type WebService struct {
-	serviceName     string
-	HttpServer      *http.Server
-	Router          *http.ServeMux
-	quit            chan os.Signal
-	shutdownHandler ShutdownHandler
-	Port            int
-	Ip              string
-}
-
-// Bootstrapper 服务启动器
-type Bootstrapper struct {
-	appName    string
-	appVersion string
-	Cfg        config.IConfig
-	services   map[string]*WebService // 存储多个服务实例
-	quit       chan os.Signal
-}
-
-// NewBootstrapper 创建启动器
-func NewBootstrapper(name, version string) *Bootstrapper {
-	b := &Bootstrapper{
-		appName:    name,
-		appVersion: version,
-		quit:       make(chan os.Signal, 1),
-		services:   make(map[string]*WebService),
-	}
-
-	b.init()
-
-	return b
-}
-
-// Init 初始化配置和日志
-func (b *Bootstrapper) init() *Bootstrapper {
-	// 1. 初始化启动日志
-	if err := logger.InitBootLog(b.appName); err != nil {
-		log.Fatal("无法初始化启动日志: ", err)
-	}
-
-	// 2. 加载配置
-	log.Println("正在加载配置...")
-	cfg, err := config.GetConfig()
-	if err != nil {
-		log.Fatalf("加载配置失败: %v", err)
-	}
-	cfg.SetAppName(b.appName)
-	cfg.SetAppVersion(b.appVersion)
-	b.Cfg = cfg
-
-	// 3. 初始化运行时日志
-	logger.InitRuntimeLogger(b.appName, b.appVersion, b.Cfg.GetLog())
-	log.Println("配置和日志初始化完成")
-
-	return b
-}
-
-// CreateService 创建Web服务实例
-func (b *Bootstrapper) createService(yamlNode string) *WebService {
-
-	serviceCfg := b.Cfg.GetServiceConfig(yamlNode)
-
-	// 检查是否已存在同名服务
-	if _, exists := b.services[yamlNode]; exists {
-		logger.Debug("服务 %s 已存在，将返回现有实例", yamlNode)
-		return b.services[yamlNode]
-	}
-
-	io := client.GetServiceIP("")
-	// 创建新的服务实例
-	ws := &WebService{
-		serviceName: serviceCfg.ServiceName,
-		Router:      http.NewServeMux(),
-		quit:        make(chan os.Signal, 1),
-		Port:        serviceCfg.Port,
-		Ip:          io,
-	}
-
-	// 创建HTTP服务器
-	ws.HttpServer = &http.Server{
-		Addr:         fmt.Sprintf(":%d", serviceCfg.Port),
-		Handler:      ws.Router,
-		ReadTimeout:  15 * time.Second,
-		WriteTimeout: 15 * time.Second,
-		IdleTimeout:  60 * time.Second,
-	}
-
-	// 存储服务实例
-	b.services[yamlNode] = ws
-
-	logger.Debug("已创建服务实例: %s (端口: %d)", serviceCfg.ServiceName, serviceCfg.Port)
-
-	return ws
-}
-
-// GetAllServices 获取所有服务实例
-func (b *Bootstrapper) GetAllServices() map[string]*WebService {
-	return b.services
-}
-
-// StartService 启动指定服务
-func (b *Bootstrapper) StartService(yamlNode string) *Bootstrapper {
-
-	service := b.createService(yamlNode)
-
-	log.Printf("正在启动服务: %s ", service.serviceName)
-	log.Printf("模式: 独立运行 (net/http)")
-	log.Printf("服务端口: :%d", service.Port)
-
-	return b
-}
-
-// Run 运行所有服务
-func (b *Bootstrapper) Run(shutdownHandler ShutdownHandler) {
-	if len(b.services) == 0 {
-		log.Fatal("没有要运行的服务，请先创建服务实例")
-	}
-
-	log.Printf("开始运行 %d 个服务...", len(b.services))
-
-	// 设置全局信号监听
-	signal.Notify(b.quit, syscall.SIGINT, syscall.SIGTERM)
-
-	// 启动所有服务
-	for serviceName, service := range b.services {
-		go func(name string, ws *WebService) {
-
-			consul.Register(service.serviceName, service.Ip, service.Port, b.Cfg.GetConsulConfig())
-
-			log.Printf("启动服务 %s 在 %s", name, ws.HttpServer.Addr)
-			if err := ws.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-				log.Fatalf("服务 %s 运行失败: %v", name, err)
-			}
-		}(serviceName, service)
-	}
-
-	// 等待中断信号
-	b.waitForShutdown(shutdownHandler)
-}
-
-// RunSingle 运行单个服务
-func (b *Bootstrapper) RunSingle(yamlNode string, shutdownHandler ShutdownHandler) {
-	service := b.createService(yamlNode)
-
-	log.Printf("服务 %s 开始运行...", service.serviceName)
-
-	// 设置服务级别的信号监听
-	signal.Notify(service.quit, syscall.SIGINT, syscall.SIGTERM)
-
-	// 启动服务
-	go func() {
-		log.Printf("服务器启动在 %s", service.HttpServer.Addr)
-		if err := service.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			log.Fatalf("服务运行失败: %v", err)
-		}
-	}()
-
-	consul.Register(service.serviceName, service.Ip, service.Port, b.Cfg.GetConsulConfig())
-
-	// 等待中断信号
-	b.waitForServiceShutdown(service, shutdownHandler)
-}
-
-// RunTLS 运行HTTPS服务
-func (b *Bootstrapper) RunTLS(serviceName, certFile, keyFile string, shutdownHandler ShutdownHandler) {
-	service := b.createService(serviceName)
-
-	log.Printf("服务 %s 开始运行(HTTPS)...", service.serviceName)
-
-	// 设置服务级别的信号监听
-	signal.Notify(service.quit, syscall.SIGINT, syscall.SIGTERM)
-
-	// 启动HTTPS服务器
-	go func() {
-		log.Printf("HTTPS服务器启动在 %s", service.HttpServer.Addr)
-		if err := service.HttpServer.ListenAndServeTLS(certFile, keyFile); err != nil && err != http.ErrServerClosed {
-			log.Fatalf("服务运行失败: %v", err)
-		}
-	}()
-
-	// 等待中断信号
-	b.waitForServiceShutdown(service, shutdownHandler)
-}
-
-// waitForShutdown 等待关闭信号（关闭所有服务）
-func (b *Bootstrapper) waitForShutdown(handler ShutdownHandler) {
-	log.Println("按 Ctrl+C 停止所有服务")
-
-	// 等待信号
-	<-b.quit
-	log.Println("接收到终止信号，正在优雅关闭所有服务...")
-
-	// 创建关闭上下文，给30秒完成当前请求
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// 关闭所有服务
-	shutdownComplete := make(chan bool, len(b.services))
-
-	for serviceName, service := range b.services {
-		go func(name string, ws *WebService) {
-			log.Printf("正在关闭服务: %s", name)
-			//退出注册中心
-			consul.Deregister(service.serviceName, service.Ip, service.Port, b.Cfg.GetConsulConfig())
-
-			if err := ws.HttpServer.Shutdown(ctx); err != nil {
-				log.Printf("服务 %s 关闭失败: %v", name, err)
-			} else {
-				log.Printf("服务 %s 已关闭", name)
-			}
-			shutdownComplete <- true
-		}(serviceName, service)
-	}
-
-	// 等待所有服务关闭完成
-	for i := 0; i < len(b.services); i++ {
-		<-shutdownComplete
-	}
-
-	// 执行关闭处理
-	if handler != nil {
-		handler.OnShutdown()
-	}
-
-	// 停止日志写入
-	logger.StopESWriter()
-	log.Println("所有服务优雅关闭完成")
-
-	// 等待一小段时间确保日志写入完成
-	time.Sleep(100 * time.Millisecond)
-	os.Exit(0)
-}
-
-// waitForServiceShutdown 等待单个服务关闭
-func (b *Bootstrapper) waitForServiceShutdown(service *WebService, handler ShutdownHandler) {
-
-	log.Printf("按 Ctrl+C 停止服务 %s", service.serviceName)
-
-	// 等待信号
-	<-service.quit
-	log.Printf("接收到终止信号，正在优雅关闭服务 %s...", service.serviceName)
-
-	//退出注册中心
-	consul.Deregister(service.serviceName, service.Ip, service.Port, b.Cfg.GetConsulConfig())
-
-	// 创建关闭上下文，给30秒完成当前请求
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// 停止接收新请求，完成当前请求
-	if err := service.HttpServer.Shutdown(ctx); err != nil {
-		log.Printf("服务 %s 关闭失败: %v", service.serviceName, err)
-	} else {
-		log.Printf("服务 %s 已关闭", service.serviceName)
-	}
-
-	// 执行关闭处理
-	if handler != nil {
-		handler.OnShutdown()
-	}
-
-	// 停止日志写入
-	logger.StopESWriter()
-	log.Printf("服务 %s 优雅关闭完成", service.serviceName)
-
-	// 等待一小段时间确保日志写入完成
-	time.Sleep(100 * time.Millisecond)
-	os.Exit(0)
-}
-
-// GetConfig 获取配置
-func (b *Bootstrapper) GetConfig() config.IConfig {
-	return b.Cfg
-}
-
-// GetWebService 获取指定服务的路由器
-func (b *Bootstrapper) GetRouter(yamlNode string) *http.ServeMux {
-	service := b.createService(yamlNode)
-	return service.Router
-}
-
-// GetRouterDefault 获取第一个服务的路由器（兼容性方法）
-func (b *Bootstrapper) GetRouterDefault() *http.ServeMux {
-	for _, service := range b.services {
-		return service.Router
-	}
-	// 如果没有服务，创建默认路由器（向后兼容）
-	return http.NewServeMux()
-}
-
-// // Handle 注册路由处理器到指定服务
-// func (b *Bootstrapper) Handle(serviceName, pattern string, handler http.Handler) bool {
-// 	if service, exists := b.services[serviceName]; exists {
-// 		service.Router.Handle(pattern, handler)
-// 		return true
+// import (
+// 	"context"
+// 	"fmt"
+// 	"log"
+// 	"net/http"
+// 	"os"
+// 	"os/signal"
+// 	"syscall"
+// 	"time"
+
+// 	"git.x2erp.com/qdy/go-base/client"
+// 	"git.x2erp.com/qdy/go-base/config"
+// 	"git.x2erp.com/qdy/go-base/consul"
+// 	"git.x2erp.com/qdy/go-base/logger"
+// )
+
+// // 定义接口
+// type ShutdownHandler interface {
+// 	OnShutdown()
+// }
+
+// // WebService Web服务实例
+// type WebService struct {
+// 	serviceName     string
+// 	HttpServer      *http.Server
+// 	Router          *http.ServeMux
+// 	quit            chan os.Signal
+// 	shutdownHandler ShutdownHandler
+// 	Port            int
+// 	Ip              string
+// }
+
+// // Bootstrapper 服务启动器
+// type Bootstrapper struct {
+// 	appName    string
+// 	appVersion string
+// 	Cfg        config.IConfig
+// 	services   map[string]*WebService // 存储多个服务实例
+// 	quit       chan os.Signal
+// }
+
+// // NewBootstrapper 创建启动器
+// func NewBootstrapper(name, version string) *Bootstrapper {
+// 	b := &Bootstrapper{
+// 		appName:    name,
+// 		appVersion: version,
+// 		quit:       make(chan os.Signal, 1),
+// 		services:   make(map[string]*WebService),
 // 	}
-// 	log.Printf("错误: 服务 %s 不存在", serviceName)
-// 	return false
+
+// 	b.init()
+
+// 	return b
+// }
+
+// // Init 初始化配置和日志
+// func (b *Bootstrapper) init() *Bootstrapper {
+// 	// 1. 初始化启动日志
+// 	if err := logger.InitBootLog(b.appName); err != nil {
+// 		log.Fatal("无法初始化启动日志: ", err)
+// 	}
+
+// 	// 2. 加载配置
+// 	log.Println("正在加载配置...")
+// 	cfg, err := config.GetConfig()
+// 	if err != nil {
+// 		log.Fatalf("加载配置失败: %v", err)
+// 	}
+// 	cfg.SetAppName(b.appName)
+// 	cfg.SetAppVersion(b.appVersion)
+// 	b.Cfg = cfg
+
+// 	// 3. 初始化运行时日志
+// 	logger.InitRuntimeLogger(b.appName, b.appVersion, b.Cfg.GetLog())
+// 	log.Println("配置和日志初始化完成")
+
+// 	return b
+// }
+
+// // CreateService 创建Web服务实例
+// func (b *Bootstrapper) createService() *WebService {
+
+// 	serviceCfg := b.Cfg.GetServiceConfig()
+
+// 	// 检查是否已存在同名服务
+// 	if _, exists := b.services[yamlNode]; exists {
+// 		logger.Debug("服务 %s 已存在，将返回现有实例", yamlNode)
+// 		return b.services[yamlNode]
+// 	}
+
+// 	io := client.GetServiceIP("")
+// 	// 创建新的服务实例
+// 	ws := &WebService{
+// 		serviceName: serviceCfg.ServiceName,
+// 		Router:      http.NewServeMux(),
+// 		quit:        make(chan os.Signal, 1),
+// 		Port:        serviceCfg.Port,
+// 		Ip:          io,
+// 	}
+
+// 	// 创建HTTP服务器
+// 	ws.HttpServer = &http.Server{
+// 		Addr:         fmt.Sprintf(":%d", serviceCfg.Port),
+// 		Handler:      ws.Router,
+// 		ReadTimeout:  15 * time.Second,
+// 		WriteTimeout: 15 * time.Second,
+// 		IdleTimeout:  60 * time.Second,
+// 	}
+
+// 	// 存储服务实例
+// 	b.services[yamlNode] = ws
+
+// 	logger.Debug("已创建服务实例: %s (端口: %d)", serviceCfg.ServiceName, serviceCfg.Port)
+
+// 	return ws
+// }
+
+// // GetAllServices 获取所有服务实例
+// func (b *Bootstrapper) GetAllServices() map[string]*WebService {
+// 	return b.services
+// }
+
+// // StartService 启动指定服务
+// func (b *Bootstrapper) StartService(yamlNode string) *Bootstrapper {
+
+// 	service := b.createService(yamlNode)
+
+// 	log.Printf("正在启动服务: %s ", service.serviceName)
+// 	log.Printf("模式: 独立运行 (net/http)")
+// 	log.Printf("服务端口: :%d", service.Port)
+
+// 	return b
+// }
+
+// // Run 运行所有服务
+// func (b *Bootstrapper) Run(shutdownHandler ShutdownHandler) {
+// 	if len(b.services) == 0 {
+// 		log.Fatal("没有要运行的服务，请先创建服务实例")
+// 	}
+
+// 	log.Printf("开始运行 %d 个服务...", len(b.services))
+
+// 	// 设置全局信号监听
+// 	signal.Notify(b.quit, syscall.SIGINT, syscall.SIGTERM)
+
+// 	// 启动所有服务
+// 	for serviceName, service := range b.services {
+// 		go func(name string, ws *WebService) {
+
+// 			consul.Register(service.serviceName, service.Ip, service.Port, b.Cfg.GetConsulConfig())
+
+// 			log.Printf("启动服务 %s 在 %s", name, ws.HttpServer.Addr)
+// 			if err := ws.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+// 				log.Fatalf("服务 %s 运行失败: %v", name, err)
+// 			}
+// 		}(serviceName, service)
+// 	}
+
+// 	// 等待中断信号
+// 	b.waitForShutdown(shutdownHandler)
+// }
+
+// // RunSingle 运行单个服务
+// func (b *Bootstrapper) RunSingle(yamlNode string, shutdownHandler ShutdownHandler) {
+// 	service := b.createService(yamlNode)
+
+// 	log.Printf("服务 %s 开始运行...", service.serviceName)
+
+// 	// 设置服务级别的信号监听
+// 	signal.Notify(service.quit, syscall.SIGINT, syscall.SIGTERM)
+
+// 	// 启动服务
+// 	go func() {
+// 		log.Printf("服务器启动在 %s", service.HttpServer.Addr)
+// 		if err := service.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+// 			log.Fatalf("服务运行失败: %v", err)
+// 		}
+// 	}()
+
+// 	consul.Register(service.serviceName, service.Ip, service.Port, b.Cfg.GetConsulConfig())
+
+// 	// 等待中断信号
+// 	b.waitForServiceShutdown(service, shutdownHandler)
 // }
 
-// SetShutdownHandler 为服务设置关闭处理器
-func (b *Bootstrapper) SetShutdownHandler(serviceName string, handler ShutdownHandler) bool {
-	if service, exists := b.services[serviceName]; exists {
-		service.shutdownHandler = handler
-		return true
-	}
-	return false
-}
+// // RunTLS 运行HTTPS服务
+// func (b *Bootstrapper) RunTLS(serviceName, certFile, keyFile string, shutdownHandler ShutdownHandler) {
+// 	service := b.createService(serviceName)
+
+// 	log.Printf("服务 %s 开始运行(HTTPS)...", service.serviceName)
+
+// 	// 设置服务级别的信号监听
+// 	signal.Notify(service.quit, syscall.SIGINT, syscall.SIGTERM)
+
+// 	// 启动HTTPS服务器
+// 	go func() {
+// 		log.Printf("HTTPS服务器启动在 %s", service.HttpServer.Addr)
+// 		if err := service.HttpServer.ListenAndServeTLS(certFile, keyFile); err != nil && err != http.ErrServerClosed {
+// 			log.Fatalf("服务运行失败: %v", err)
+// 		}
+// 	}()
+
+// 	// 等待中断信号
+// 	b.waitForServiceShutdown(service, shutdownHandler)
+// }
+
+// // waitForShutdown 等待关闭信号（关闭所有服务）
+// func (b *Bootstrapper) waitForShutdown(handler ShutdownHandler) {
+// 	log.Println("按 Ctrl+C 停止所有服务")
+
+// 	// 等待信号
+// 	<-b.quit
+// 	log.Println("接收到终止信号，正在优雅关闭所有服务...")
+
+// 	// 创建关闭上下文，给30秒完成当前请求
+// 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+// 	defer cancel()
+
+// 	// 关闭所有服务
+// 	shutdownComplete := make(chan bool, len(b.services))
+
+// 	for serviceName, service := range b.services {
+// 		go func(name string, ws *WebService) {
+// 			log.Printf("正在关闭服务: %s", name)
+// 			//退出注册中心
+// 			consul.Deregister(service.serviceName, service.Ip, service.Port, b.Cfg.GetConsulConfig())
+
+// 			if err := ws.HttpServer.Shutdown(ctx); err != nil {
+// 				log.Printf("服务 %s 关闭失败: %v", name, err)
+// 			} else {
+// 				log.Printf("服务 %s 已关闭", name)
+// 			}
+// 			shutdownComplete <- true
+// 		}(serviceName, service)
+// 	}
+
+// 	// 等待所有服务关闭完成
+// 	for i := 0; i < len(b.services); i++ {
+// 		<-shutdownComplete
+// 	}
+
+// 	// 执行关闭处理
+// 	if handler != nil {
+// 		handler.OnShutdown()
+// 	}
 
-// ========== WebService 的方法 ==========
+// 	// 停止日志写入
+// 	logger.StopESWriter()
+// 	log.Println("所有服务优雅关闭完成")
 
-// GetServiceName 获取服务名称
-// func (ws *WebService) GetServiceName() string {
-// 	return ws.serviceName
+// 	// 等待一小段时间确保日志写入完成
+// 	time.Sleep(100 * time.Millisecond)
+// 	os.Exit(0)
 // }
 
-// // GetServiceConfig 获取服务配置
-// func (ws *WebService) GetServiceConfig() *subconfigs.ServiceConfig {
-// 	return ws.serviceConfig
+// // waitForServiceShutdown 等待单个服务关闭
+// func (b *Bootstrapper) waitForServiceShutdown(service *WebService, handler ShutdownHandler) {
+
+// 	log.Printf("按 Ctrl+C 停止服务 %s", service.serviceName)
+
+// 	// 等待信号
+// 	<-service.quit
+// 	log.Printf("接收到终止信号，正在优雅关闭服务 %s...", service.serviceName)
+
+// 	//退出注册中心
+// 	consul.Deregister(service.serviceName, service.Ip, service.Port, b.Cfg.GetConsulConfig())
+
+// 	// 创建关闭上下文，给30秒完成当前请求
+// 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+// 	defer cancel()
+
+// 	// 停止接收新请求，完成当前请求
+// 	if err := service.HttpServer.Shutdown(ctx); err != nil {
+// 		log.Printf("服务 %s 关闭失败: %v", service.serviceName, err)
+// 	} else {
+// 		log.Printf("服务 %s 已关闭", service.serviceName)
+// 	}
+
+// 	// 执行关闭处理
+// 	if handler != nil {
+// 		handler.OnShutdown()
+// 	}
+
+// 	// 停止日志写入
+// 	logger.StopESWriter()
+// 	log.Printf("服务 %s 优雅关闭完成", service.serviceName)
+
+// 	// 等待一小段时间确保日志写入完成
+// 	time.Sleep(100 * time.Millisecond)
+// 	os.Exit(0)
 // }
 
-// GetRouter 获取服务的路由器
-// func (ws *WebService) GetRouter() *http.ServeMux {
-// 	return ws.Router
+// // GetConfig 获取配置
+// func (b *Bootstrapper) GetConfig() config.IConfig {
+// 	return b.Cfg
 // }
 
-// Handle 注册路由处理器
-// func (ws *WebService) Handle(pattern string, handler http.Handler) {
-// 	ws.Router.Handle(pattern, handler)
+// // GetWebService 获取指定服务的路由器
+// func (b *Bootstrapper) GetRouter(yamlNode string) *http.ServeMux {
+// 	service := b.createService(yamlNode)
+// 	return service.Router
 // }
 
-// SetShutdownHandler 设置关闭处理器
-func (ws *WebService) SetShutdownHandler(handler ShutdownHandler) {
-	ws.shutdownHandler = handler
-}
-
-// Run 运行单个服务
-func (ws *WebService) Run(shutdownHandler ShutdownHandler) {
-	log.Printf("服务 %s 开始运行...", ws.serviceName)
-
-	// 设置信号监听
-	signal.Notify(ws.quit, syscall.SIGINT, syscall.SIGTERM)
-
-	// 启动服务
-	go func() {
-		log.Printf("服务器启动在 %s", ws.HttpServer.Addr)
-		if err := ws.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			log.Fatalf("服务 %s 运行失败: %v", ws.serviceName, err)
-		}
-	}()
-
-	// 等待中断信号
-	log.Printf("按 Ctrl+C 停止服务 %s", ws.serviceName)
-	<-ws.quit
-
-	log.Printf("接收到终止信号，正在优雅关闭服务 %s...", ws.serviceName)
-
-	// 创建关闭上下文
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// 关闭服务
-	if err := ws.HttpServer.Shutdown(ctx); err != nil {
-		log.Printf("服务 %s 关闭失败: %v", ws.serviceName, err)
-	} else {
-		log.Printf("服务 %s 已关闭", ws.serviceName)
-	}
-
-	// 执行关闭处理
-	if shutdownHandler != nil {
-		shutdownHandler.OnShutdown()
-	} else if ws.shutdownHandler != nil {
-		ws.shutdownHandler.OnShutdown()
-	}
-
-	log.Printf("服务 %s 优雅关闭完成", ws.serviceName)
-	time.Sleep(100 * time.Millisecond)
-	os.Exit(0)
-}
+// // GetRouterDefault 获取第一个服务的路由器（兼容性方法）
+// func (b *Bootstrapper) GetRouterDefault() *http.ServeMux {
+// 	for _, service := range b.services {
+// 		return service.Router
+// 	}
+// 	// 如果没有服务，创建默认路由器（向后兼容）
+// 	return http.NewServeMux()
+// }
+
+// // // Handle 注册路由处理器到指定服务
+// // func (b *Bootstrapper) Handle(serviceName, pattern string, handler http.Handler) bool {
+// // 	if service, exists := b.services[serviceName]; exists {
+// // 		service.Router.Handle(pattern, handler)
+// // 		return true
+// // 	}
+// // 	log.Printf("错误: 服务 %s 不存在", serviceName)
+// // 	return false
+// // }
+
+// // SetShutdownHandler 为服务设置关闭处理器
+// func (b *Bootstrapper) SetShutdownHandler(serviceName string, handler ShutdownHandler) bool {
+// 	if service, exists := b.services[serviceName]; exists {
+// 		service.shutdownHandler = handler
+// 		return true
+// 	}
+// 	return false
+// }
+
+// // ========== WebService 的方法 ==========
+
+// // GetServiceName 获取服务名称
+// // func (ws *WebService) GetServiceName() string {
+// // 	return ws.serviceName
+// // }
+
+// // // GetServiceConfig 获取服务配置
+// // func (ws *WebService) GetServiceConfig() *subconfigs.ServiceConfig {
+// // 	return ws.serviceConfig
+// // }
+
+// // GetRouter 获取服务的路由器
+// // func (ws *WebService) GetRouter() *http.ServeMux {
+// // 	return ws.Router
+// // }
+
+// // Handle 注册路由处理器
+// // func (ws *WebService) Handle(pattern string, handler http.Handler) {
+// // 	ws.Router.Handle(pattern, handler)
+// // }
+
+// // SetShutdownHandler 设置关闭处理器
+// func (ws *WebService) SetShutdownHandler(handler ShutdownHandler) {
+// 	ws.shutdownHandler = handler
+// }
+
+// // Run 运行单个服务
+// func (ws *WebService) Run(shutdownHandler ShutdownHandler) {
+// 	log.Printf("服务 %s 开始运行...", ws.serviceName)
+
+// 	// 设置信号监听
+// 	signal.Notify(ws.quit, syscall.SIGINT, syscall.SIGTERM)
+
+// 	// 启动服务
+// 	go func() {
+// 		log.Printf("服务器启动在 %s", ws.HttpServer.Addr)
+// 		if err := ws.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+// 			log.Fatalf("服务 %s 运行失败: %v", ws.serviceName, err)
+// 		}
+// 	}()
+
+// 	// 等待中断信号
+// 	log.Printf("按 Ctrl+C 停止服务 %s", ws.serviceName)
+// 	<-ws.quit
+
+// 	log.Printf("接收到终止信号，正在优雅关闭服务 %s...", ws.serviceName)
+
+// 	// 创建关闭上下文
+// 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+// 	defer cancel()
+
+// 	// 关闭服务
+// 	if err := ws.HttpServer.Shutdown(ctx); err != nil {
+// 		log.Printf("服务 %s 关闭失败: %v", ws.serviceName, err)
+// 	} else {
+// 		log.Printf("服务 %s 已关闭", ws.serviceName)
+// 	}
+
+// 	// 执行关闭处理
+// 	if shutdownHandler != nil {
+// 		shutdownHandler.OnShutdown()
+// 	} else if ws.shutdownHandler != nil {
+// 		ws.shutdownHandler.OnShutdown()
+// 	}
+
+// 	log.Printf("服务 %s 优雅关闭完成", ws.serviceName)
+// 	time.Sleep(100 * time.Millisecond)
+// 	os.Exit(0)
+// }

bootstraps/shutdown.go

@@ -1,39 +1,39 @@
 package bootstraps
 
-import (
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
+// import (
+// 	"os"
+// 	"os/signal"
+// 	"syscall"
+// 	"time"
 
-	"git.x2erp.com/qdy/go-base/logger"
-	"git.x2erp.com/qdy/go-db/factory/database"
-)
+// 	"git.x2erp.com/qdy/go-base/logger"
+// 	"git.x2erp.com/qdy/go-db/factory/database"
+// )
 
-// setupGracefulShutdown 设置优雅关闭
-func SetupGracefulShutdown(dbFactory *database.DBFactory, cleanupFuncs ...func()) {
-	signalCh := make(chan os.Signal, 1)
-	signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM)
+// // setupGracefulShutdown 设置优雅关闭
+// func SetupGracefulShutdown(dbFactory *database.DBFactory, cleanupFuncs ...func()) {
+// 	signalCh := make(chan os.Signal, 1)
+// 	signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM)
 
-	go func() {
-		<-signalCh
-		logger.Info("\n接收到关闭信号，正在优雅关闭...")
+// 	go func() {
+// 		<-signalCh
+// 		logger.Info("\n接收到关闭信号，正在优雅关闭...")
 
-		// 关闭数据库连接
-		if dbFactory != nil {
-			if err := dbFactory.Close(); err != nil {
-				logger.Error("关闭数据库错误: %v", err)
-			}
-			logger.Info("数据库连接已关闭")
-		}
+// 		// 关闭数据库连接
+// 		if dbFactory != nil {
+// 			if err := dbFactory.Close(); err != nil {
+// 				logger.Error("关闭数据库错误: %v", err)
+// 			}
+// 			logger.Info("数据库连接已关闭")
+// 		}
 
-		// 执行其他清理函数
-		for _, cleanup := range cleanupFuncs {
-			cleanup()
-		}
+// 		// 执行其他清理函数
+// 		for _, cleanup := range cleanupFuncs {
+// 			cleanup()
+// 		}
 
-		// 等待日志写入完成
-		time.Sleep(100 * time.Millisecond)
-		os.Exit(0)
-	}()
-}
+// 		// 等待日志写入完成
+// 		time.Sleep(100 * time.Millisecond)
+// 		os.Exit(0)
+// 	}()
+// }

config/config.go

@@ -4,20 +4,15 @@ import (
 	"sync"
 
 	"git.x2erp.com/qdy/go-base/config/subconfigs"
-	"git.x2erp.com/qdy/go-base/logger"
 )
 
 // IConfig 主配置接口（更新支持多数据库）
 type IConfig interface {
 	// 多数据库支持
-	GetDatabase() *subconfigs.DatabaseConfig                  // 获取默认数据库（向后兼容）
-	GetDatabases() *subconfigs.DatabasesConfig                // 获取所有数据库配置
-	GetDatabaseConfig(name string) *subconfigs.DatabaseConfig // 按名称获取数据库配置
+	GetDatabaseConfig() *subconfigs.DatabaseConfig // 获取默认数据库（向后兼容）
 
-	//多服务支持
-	GetService() *subconfigs.ServiceConfig                  //获取默认微服务配置
-	GetServices() *subconfigs.ServicesConfig                //获所有定义的微服务配置
-	GetServiceConfig(name string) *subconfigs.ServiceConfig //获取微服务配置
+	//服务支持
+	GetServiceConfig() *subconfigs.ServiceConfig //获取默认微服务配置
 
 	// 其他配置（保持不变）
 	GetRedisConfig() *subconfigs.RedisConfig
@@ -25,15 +20,14 @@ type IConfig interface {
 	GetRabbitMQConfig() *subconfigs.RabbitMQConfig
 
 	GetConsulConfig() *subconfigs.ConsulConfig
+	GetMongoDBConfig() *subconfigs.MongoDBConfig
 
-	GetHTTP() *subconfigs.HTTPConfig
-	GetMicro() *subconfigs.MicroConfig
-	GetLog() *subconfigs.LogConfig
-	GetInitError() error
+	GetHTTPConfig() *subconfigs.HTTPConfig
+	GetMicroConfig() *subconfigs.MicroConfig
+	GetLogConfig() *subconfigs.LogConfig
 
 	// 配置检查（更新）
 	IsDatabaseConfigured() bool
-	IsDatabaseConfiguredByName(name string) bool
 	IsDorisConfigured() bool
 	IsRedisConfigured() bool
 
@@ -49,60 +43,19 @@ type IConfig interface {
 
 // Config 主配置结构体 - 访问门面
 type Config struct {
-	initError error // 初始化错误
-}
-
-// ========== 数据库相关方法（更新） ==========
-
-// GetDatabases 获取所有数据库配置
-func (c *Config) GetDatabases() *subconfigs.DatabasesConfig {
-	if config := subconfigs.GetRegisteredConfig("databases"); config != nil {
-		if dbs, ok := config.(*subconfigs.DatabasesConfig); ok {
-			return dbs
-		}
-	}
-	return nil
-}
-
-// GetDatabase 获取默认数据库配置（向后兼容）
-func (c *Config) GetDatabase() *subconfigs.DatabaseConfig {
-	dbs := c.GetDatabases()
-	if dbs == nil {
-		logger.Errorf("获取默认数据库连接配置发生错误：配置为空！")
-		return nil
-	}
-	return dbs.GetDefaultDatabase()
+	loaded    bool            // 配置是否已加载
+	loadTime  string          // 配置加载时间（可选）
+	configMap map[string]bool // 已加载的配置类型映射
 }
 
 // GetDatabaseConfig 按名称获取数据库配置
-func (c *Config) GetDatabaseConfig(name string) *subconfigs.DatabaseConfig {
-	dbs := c.GetDatabases()
-	if dbs == nil {
-		return nil
-	}
-	return dbs.GetDatabase(name)
-}
-
-// IsDatabaseConfigured 检查默认数据库是否配置
-func (c *Config) IsDatabaseConfigured() bool {
-	dbs := c.GetDatabases()
-	if dbs == nil {
-		return false
+func (c *Config) GetDatabaseConfig() *subconfigs.DatabaseConfig {
+	if config := subconfigs.GetRegisteredConfig("database"); config != nil {
+		return config.(*subconfigs.DatabaseConfig)
 	}
-	return dbs.IsConfigured()
-}
-
-// IsDatabaseConfiguredByName 检查指定名称的数据库是否配置
-func (c *Config) IsDatabaseConfiguredByName(name string) bool {
-	dbs := c.GetDatabases()
-	if dbs == nil {
-		return false
-	}
-	return dbs.IsConfigured()
+	return nil
 }
 
-// ========== 其他配置方法（保持不变） ==========
-
 func (c *Config) GetRedisConfig() *subconfigs.RedisConfig {
 	if config := subconfigs.GetRegisteredConfig("redis"); config != nil {
 		return config.(*subconfigs.RedisConfig)
@@ -117,6 +70,13 @@ func (c *Config) GetConsulConfig() *subconfigs.ConsulConfig {
 	return nil
 }
 
+func (c *Config) GetMongoDBConfig() *subconfigs.MongoDBConfig {
+	if config := subconfigs.GetRegisteredConfig("mongodb"); config != nil {
+		return config.(*subconfigs.MongoDBConfig)
+	}
+	return nil
+}
+
 func (c *Config) GetDorisConfig() *subconfigs.DorisConfig {
 	if config := subconfigs.GetRegisteredConfig("doris"); config != nil {
 		return config.(*subconfigs.DorisConfig)
@@ -131,60 +91,37 @@ func (c *Config) GetRabbitMQConfig() *subconfigs.RabbitMQConfig {
 	return nil
 }
 
-// ========== 微服务相关方法（更新） ==========
-
-// GetServices 获取所有微服务配置
-func (c *Config) GetServices() *subconfigs.ServicesConfig {
-	if config := subconfigs.GetRegisteredConfig("services"); config != nil {
-		if dbs, ok := config.(*subconfigs.ServicesConfig); ok {
-			return dbs
-		}
+func (c *Config) GetServiceConfig() *subconfigs.ServiceConfig {
+	if config := subconfigs.GetRegisteredConfig("service"); config != nil {
+		return config.(*subconfigs.ServiceConfig)
 	}
 	return nil
 }
 
-// GetService 获取默认微服务配置（向后兼容）
-func (c *Config) GetService() *subconfigs.ServiceConfig {
-	dbs := c.GetServices()
-	if dbs == nil {
-		logger.Errorf("获取默认微服务配置发生错误：配置为空！")
-		return nil
-	}
-	return dbs.GetDefaultService()
-}
-
-// GetServiceConfig 按名称获取微服务配置
-func (c *Config) GetServiceConfig(name string) *subconfigs.ServiceConfig {
-	dbs := c.GetServices()
-	if dbs == nil {
-		return nil
-	}
-	return dbs.GetService(name)
-}
-
-func (c *Config) GetHTTP() *subconfigs.HTTPConfig {
+func (c *Config) GetHTTPConfig() *subconfigs.HTTPConfig {
 	if config := subconfigs.GetRegisteredConfig("http"); config != nil {
 		return config.(*subconfigs.HTTPConfig)
 	}
 	return nil
 }
 
-func (c *Config) GetMicro() *subconfigs.MicroConfig {
+func (c *Config) GetMicroConfig() *subconfigs.MicroConfig {
 	if config := subconfigs.GetRegisteredConfig("micro"); config != nil {
 		return config.(*subconfigs.MicroConfig)
 	}
 	return nil
 }
 
-func (c *Config) GetLog() *subconfigs.LogConfig {
+func (c *Config) GetLogConfig() *subconfigs.LogConfig {
 	if config := subconfigs.GetRegisteredConfig("log"); config != nil {
 		return config.(*subconfigs.LogConfig)
 	}
 	return nil
 }
 
-func (c *Config) GetInitError() error {
-	return c.initError
+func (c *Config) IsDatabaseConfigured() bool {
+	db := c.GetDatabaseConfig()
+	return db != nil && db.IsConfigured()
 }
 
 // 实现 IConfig 接口的其他方法
@@ -201,57 +138,39 @@ func (c *Config) IsRedisConfigured() bool {
 // 设置方法
 func (c *Config) SetAppEnv(name string) {
 	if c.GetAppEnv() == "" {
-		c.GetServices().AppEnv = name
+		c.GetServiceConfig().AppEnv = name
 	}
 }
 
 func (c *Config) SetAppName(name string) {
 	if c.GetAppName() == "" {
-		c.GetServices().AppName = name
+		c.GetServiceConfig().AppName = name
 	}
 }
 func (c *Config) SetAppVersion(name string) {
 	if c.GetAppVersion() == "" {
-		c.GetServices().AppVersion = name
+		c.GetServiceConfig().AppVersion = name
 	}
 }
 
 // GetAppVersion 获取服务版本
 func (c *Config) GetAppVersion() string {
-	return c.GetServices().AppVersion
+	return c.GetServiceConfig().AppVersion
 }
 
 // GetAppEnv 获取环境
 func (c *Config) GetAppEnv() string {
-	return c.GetServices().AppEnv
+	return c.GetServiceConfig().AppEnv
 }
 
 // GetAppName 获取当前应用名称
 func (c *Config) GetAppName() string {
-	return c.GetServices().AppName
+	return c.GetServiceConfig().AppName
 }
 
 // GetAppAuthToken 得到当前配置文件里的token
 func (c *Config) GetAppAuthToken() string {
-	return c.GetServices().AppAuthToken
-}
-
-// ========== 包级便捷函数（更新） ==========
-
-// GetDatabases 包级便捷函数 - 获取所有数据库配置
-func GetDatabases() *subconfigs.DatabasesConfig {
-	if cfgInstance == nil {
-		return nil
-	}
-	return cfgInstance.GetDatabases()
-}
-
-// GetDatabase 包级便捷函数 - 获取默认数据库配置（向后兼容）
-func GetDatabase() *subconfigs.DatabaseConfig {
-	if cfgInstance == nil {
-		return &subconfigs.DatabaseConfig{}
-	}
-	return cfgInstance.GetDatabase()
+	return c.GetServiceConfig().AppAuthToken
 }
 
 // GetDatabaseConfig 包级便捷函数 - 按名称获取数据库配置
@@ -259,11 +178,11 @@ func GetDatabaseConfig(name string) *subconfigs.DatabaseConfig {
 	if cfgInstance == nil {
 		return nil
 	}
-	return cfgInstance.GetDatabaseConfig(name)
+	return cfgInstance.GetDatabaseConfig()
 }
 
 // GetRedis 包级便捷函数 - 获取Redis配置
-func GetRedis() *subconfigs.RedisConfig {
+func GetRedisConfig() *subconfigs.RedisConfig {
 	if cfgInstance == nil {
 		return &subconfigs.RedisConfig{}
 	}
@@ -271,7 +190,7 @@ func GetRedis() *subconfigs.RedisConfig {
 }
 
 // GetRedis 包级便捷函数 - 获取Redis配置
-func GetConsul() *subconfigs.ConsulConfig {
+func GetConsulConfig() *subconfigs.ConsulConfig {
 	if cfgInstance == nil {
 		return &subconfigs.ConsulConfig{}
 	}
@@ -279,66 +198,79 @@ func GetConsul() *subconfigs.ConsulConfig {
 }
 
 // GetHTTP 包级便捷函数 - 获取HTTP配置
-func GetHTTP() *subconfigs.HTTPConfig {
+func GetHTTPConfig() *subconfigs.HTTPConfig {
 	if cfgInstance == nil {
 		return &subconfigs.HTTPConfig{}
 	}
-	return cfgInstance.GetHTTP()
+	return cfgInstance.GetHTTPConfig()
 }
 
-// GetLog 包级便捷函数 - 获取日志配置
-func GetLog() *subconfigs.LogConfig {
+// GetMongoDB 包级便捷函数 - 获取MongoDB配置
+func GetMongoDBConfig() *subconfigs.MongoDBConfig {
 	if cfgInstance == nil {
-		return &subconfigs.LogConfig{}
+		return &subconfigs.MongoDBConfig{}
 	}
-	return cfgInstance.GetLog()
+	return cfgInstance.GetMongoDBConfig()
 }
 
-func GetMicro() *subconfigs.MicroConfig {
+// GetLog 包级便捷函数 - 获取日志配置
+func GetLogConfig() *subconfigs.LogConfig {
 	if cfgInstance == nil {
-		return &subconfigs.MicroConfig{}
+		return &subconfigs.LogConfig{}
 	}
-	return cfgInstance.GetMicro()
+	return cfgInstance.GetLogConfig()
 }
 
-func GetService() *subconfigs.ServiceConfig {
+func GetMicroConfig() *subconfigs.MicroConfig {
 	if cfgInstance == nil {
-		return &subconfigs.ServiceConfig{}
+		return &subconfigs.MicroConfig{}
 	}
-	return cfgInstance.GetService()
+	return cfgInstance.GetMicroConfig()
 }
 
-// GetServiceConfig 包级便捷函数 - 按名称获取数微服务配置
-func GetServiceConfig(name string) *subconfigs.ServiceConfig {
+func GetServiceConfig() *subconfigs.ServiceConfig {
 	if cfgInstance == nil {
-		return nil
+		return &subconfigs.ServiceConfig{}
 	}
-	return cfgInstance.GetServiceConfig(name)
+	return cfgInstance.GetServiceConfig()
 }
 
-// ========== 单例管理 ==========
-
 var (
 	cfgInstance *Config
 	once        sync.Once
 )
 
 // GetConfig 获取主配置（单例模式）
-func GetConfig() (IConfig, error) {
+func GetConfig() IConfig {
 	once.Do(func() {
-		cfgInstance = &Config{}
-		cfgInstance.initError = LoadConfig() // 加载配置到注册表
+		cfgInstance = &Config{
+			loaded:    false,
+			configMap: make(map[string]bool),
+		}
+		LoadConfig() // 加载配置到注册表
+		cfgInstance.loaded = true
+		// 可以在这里记录配置加载成功的日志
 	})
-	return cfgInstance, cfgInstance.initError
+	return cfgInstance
 }
 
-// GetInitError 包级函数 - 兼容现有代码调用
-func GetInitError() error {
-	return cfgInstance.GetInitError()
+// IsConfigLoaded 检查配置是否已加载
+func (c *Config) IsConfigLoaded() bool {
+	return c.loaded
 }
 
-// GetConfigWithError 新方法 - 同时获取配置和错误
-func GetConfigWithError() (IConfig, error) {
-	cfg, err := GetConfig()
-	return cfg, err
+// MarkConfigLoaded 标记配置已加载
+func (c *Config) MarkConfigLoaded(configType string) {
+	if c.configMap == nil {
+		c.configMap = make(map[string]bool)
+	}
+	c.configMap[configType] = true
+}
+
+// IsConfigTypeLoaded 检查特定类型的配置是否已加载
+func (c *Config) IsConfigTypeLoaded(configType string) bool {
+	if c.configMap == nil {
+		return false
+	}
+	return c.configMap[configType]
 }

config/loader.go

@@ -11,32 +11,34 @@ import (
 )
 
 // LoadConfig 从文件加载配置到注册表（保持原有接口不变）
-func LoadConfig() error {
+func LoadConfig() {
 	// 1. 查找配置文件
 	configFile, err := findConfigFile()
 	if err != nil {
-		return err
+		log.Fatalf("查找配置文件错误:%v", err)
+
 	}
 
 	// 2. 读取并解析文件
 	data, err := os.ReadFile(configFile)
 	if err != nil {
-		return fmt.Errorf("read config file error: %v", err)
+		log.Fatalf("read config file error: %v", err)
 	}
 
 	var rawConfig map[string]interface{}
 	err = yaml.Unmarshal(data, &rawConfig)
 	if err != nil {
-		return fmt.Errorf("parse yaml error: %v", err)
+		log.Fatalf("parse yaml error: %v", err)
+
 	}
 
 	// 3. 从map加载配置
-	return LoadConfigFromMap(rawConfig)
+	LoadConfigFromMap(rawConfig)
 }
 
 // LoadConfigFromMap 从map[string]interface{}加载配置到注册表
 // 新增方法，供外部调用（比如从数据库加载后使用）
-func LoadConfigFromMap(rawConfig map[string]interface{}) error {
+func LoadConfigFromMap(rawConfig map[string]interface{}) {
 	// 1. 设置所有注册配置的默认值
 	for _, config := range subconfigs.GetAllConfigs() {
 		config.SetDefaults()
@@ -48,12 +50,10 @@ func LoadConfigFromMap(rawConfig map[string]interface{}) error {
 			// 转换为 map[string]interface{}
 			strMap := convertMap(configData)
 			if err := config.Load(strMap); err != nil {
-				return fmt.Errorf("load config %s error: %v", name, err)
+				log.Fatalf("load config %s error: %v", name, err)
 			}
 		}
 	}
-
-	return nil
 }
 
 // convertMap 转换map类型（内部函数保持不变）

config/subconfigs/consul_config.go

@@ -15,7 +15,7 @@ func NewConsulConfig() *ConsulConfig {
 }
 
 func (c *ConsulConfig) SetDefaults() {
-	c.Address = "localhost:8500"
+	//c.Address = "localhost:8500"
 	c.Scheme = "http"
 }
 

config/subconfigs/database_config.go

@@ -5,11 +5,6 @@ import (
 	"log"
 )
 
-type DatabasesConfig struct {
-	BaseConfig
-	Databases map[string]*DatabaseConfig `yaml:"databases"`
-}
-
 // DatabaseConfig 数据库配置
 type DatabaseConfig struct {
 	BaseConfig
@@ -24,61 +19,6 @@ type DatabaseConfig struct {
 	ConnMaxLifetime int    `yaml:"conn_max_lifetime"`
 }
 
-// ========== DatabasesConfig 实现 ConfigLoader 接口 ==========
-
-// SetDefaults 设置默认值 - 实现 ConfigLoader 接口
-func (c *DatabasesConfig) SetDefaults() {
-	//因为是多集合，外层调这里赋默认值，这个时候对象还没有建立。赋默认值的地方移到其他地方去
-	// if c.Databases == nil {
-	// 	c.Databases = make(map[string]*DatabaseConfig)
-	// 	log.Println("⚠️  数据库配置为空，已初始化空的数据库配置")
-	// 	return
-	// }
-
-	// // 为每个数据库配置设置默认值
-	// for _, db := range c.Databases {
-	// 	if db != nil {
-	// 		db.SetDefaults()
-	// 	}
-	// }
-}
-
-func (c *DatabasesConfig) Load(data map[string]interface{}) error {
-	// 初始化
-	c.Databases = make(map[string]*DatabaseConfig)
-
-	// 遍历所有数据库配置
-	for dbName, dbData := range data {
-		dbDataMap, ok := dbData.(map[interface{}]interface{})
-		if !ok {
-			return fmt.Errorf("database '%s' config is not a map", dbName)
-		}
-
-		// 转换为 map[string]interface{}
-		stringMap := make(map[string]interface{})
-		for k, v := range dbDataMap {
-			if key, ok := k.(string); ok {
-				stringMap[key] = v
-			}
-		}
-
-		dbConfig := &DatabaseConfig{}
-		dbConfig.SetDefaults() // 先设置默认值
-		// 加载单个数据库配置
-		if err := dbConfig.Load(stringMap); err != nil {
-			return fmt.Errorf("failed to load database '%s' config: %v", dbName, err)
-		}
-
-		c.Databases[dbName] = dbConfig
-	}
-
-	// 设置默认值和验证
-	c.SetDefaults()
-	return c.Validate()
-}
-
-// ========== DatabaseConfig 实现 ConfigLoader 接口 ==========
-
 // SetDefaults 设置默认值 - 实现 ConfigLoader 接口
 func (c *DatabaseConfig) SetDefaults() {
 	if c.Type == "" {
@@ -100,12 +40,10 @@ func (c *DatabaseConfig) SetDefaults() {
 
 // Load 从yaml数据加载 - 实现 ConfigLoader 接口
 func (c *DatabaseConfig) Load(data map[string]interface{}) error {
-	// 虽然可能不会被直接调用，但为了接口完整性还是要实现
+
 	return c.LoadFromYAML(data, c)
 }
 
-// ========== 业务方法 ==========
-
 // Validate 验证配置（数据库配置）
 func (c *DatabaseConfig) Validate() error {
 	if c.Type == "" {
@@ -123,37 +61,6 @@ func (c *DatabaseConfig) Validate() error {
 	return nil
 }
 
-// Validate 验证配置（多数据库配置）
-func (c *DatabasesConfig) Validate() error {
-	if c.Databases == nil {
-		log.Println("❌ 错误: 未找到任何数据库配置，请检查配置文件中的 'databases' 配置")
-		return fmt.Errorf("no databases configurations found")
-	}
-
-	// 必须要有默认数据库
-	if _, exists := c.Databases["default"]; !exists {
-		availableDBs := c.GetAllDatabaseNames()
-		log.Printf("❌ 错误: 默认数据库未找到。可用的数据库: %v。请在配置文件中添加 'default' 数据库", availableDBs)
-		return fmt.Errorf("default database not found")
-	}
-
-	// 验证每个数据库配置
-	for name, db := range c.Databases {
-		if db == nil {
-			log.Printf("❌ 错误: 数据库 '%s' 配置为空", name)
-			return fmt.Errorf("database '%s' configuration is nil", name)
-		}
-
-		if err := db.Validate(); err != nil {
-			log.Printf("❌ 错误: 数据库 '%s' 验证失败: %v", name, err)
-			return fmt.Errorf("database '%s' validation failed: %v", name, err)
-		}
-	}
-
-	log.Printf("✅ 数据库配置验证通过，找到 %d 个数据库配置", len(c.Databases))
-	return nil
-}
-
 // IsConfigured 判断是否已配置（数据库配置）
 func (c *DatabaseConfig) IsConfigured() bool {
 	if c.Host == "" {
@@ -175,89 +82,7 @@ func (c *DatabaseConfig) IsConfigured() bool {
 	return true
 }
 
-// IsConfigured 判断是否已配置（多数据库配置）
-func (c *DatabasesConfig) IsConfigured() bool {
-	defaultDB := c.GetDefaultDatabase()
-	if defaultDB == nil {
-		log.Println("❌ 错误: 默认数据库不存在")
-		return false
-	}
-
-	if !defaultDB.IsConfigured() {
-		log.Println("❌ 错误: 默认数据库配置不完整")
-		return false
-	}
-
-	return true
-}
-
-// GetDefaultDatabase 获取默认数据库（必须存在）
-func (c *DatabasesConfig) GetDefaultDatabase() *DatabaseConfig {
-	if c.Databases == nil {
-		log.Println("❌ 错误: 尝试获取默认数据库时，数据库配置为空")
-		return nil
-	}
-
-	if db, exists := c.Databases["default"]; exists {
-		return db
-	}
-
-	// 如果没有名为default的，尝试返回第一个（但会记录警告）
-	for name, db := range c.Databases {
-		log.Printf("⚠️  警告: 未找到名为 'default' 的数据库，使用第一个数据库 '%s' 作为默认", name)
-		return db
-	}
-
-	log.Println("❌ 错误: 数据库中没有任何配置")
-	return nil
-}
-
-// GetDatabase 按名称获取数据库（为空时记录错误）
-func (c *DatabasesConfig) GetDatabase(name string) *DatabaseConfig {
-	if c.Databases == nil {
-		log.Printf("❌ 错误: 尝试获取数据库 '%s' 时，数据库配置为空", name)
-		return nil
-	}
-
-	db := c.Databases[name]
-	if db == nil {
-		availableDBs := c.GetAllDatabaseNames()
-		log.Printf("❌ 错误: 数据库 '%s' 不存在。可用的数据库: %v", name, availableDBs)
-	}
-
-	return db
-}
-
-// GetAllDatabaseNames 获取所有数据库名称
-func (c *DatabasesConfig) GetAllDatabaseNames() []string {
-	if c.Databases == nil {
-		log.Println("⚠️  警告: 尝试获取数据库名称时，数据库配置为空")
-		return []string{}
-	}
-
-	names := make([]string, 0, len(c.Databases))
-	for name := range c.Databases {
-		names = append(names, name)
-	}
-	return names
-}
-
-// GetDatabaseNamesWithoutDefault 获取除default外的所有数据库名称
-func (c *DatabasesConfig) GetDatabaseNamesWithoutDefault() []string {
-	if c.Databases == nil {
-		return []string{}
-	}
-
-	names := make([]string, 0, len(c.Databases)-1)
-	for name := range c.Databases {
-		if name != "default" {
-			names = append(names, name)
-		}
-	}
-	return names
-}
-
 // 自动注册
 func init() {
-	Register("databases", &DatabasesConfig{})
+	Register("database", &DatabaseConfig{})
 }

config/subconfigs/mongodb_config.go

@@ -0,0 +1,68 @@
+package subconfigs
+
+import (
+	"fmt"
+	"time"
+)
+
+// MongoDBConfig MongoDB客户端配置
+type MongoDBConfig struct {
+	BaseConfig
+	URI         string        `yaml:"uri"`         // MongoDB连接URI，如："mongodb://localhost:27017"
+	Database    string        `yaml:"database"`    // 默认数据库名
+	Username    string        `yaml:"username"`    // 用户名（可选）
+	Password    string        `yaml:"password"`    // 密码（可选）
+	AuthSource  string        `yaml:"authSource"`  // 认证数据库，默认："admin"
+	MaxPoolSize uint64        `yaml:"maxPoolSize"` // 最大连接池大小
+	MinPoolSize uint64        `yaml:"minPoolSize"` // 最小连接池大小
+	SSL         bool          `yaml:"ssl"`         // 是否使用SSL连接
+	Timeout     time.Duration `yaml:"timeout"`     // 连接超时时间（毫秒）
+}
+
+// NewMongoDBConfig 创建MongoDB配置实例
+func NewMongoDBConfig() *MongoDBConfig {
+	return &MongoDBConfig{}
+}
+
+// SetDefaults 设置默认值
+func (c *MongoDBConfig) SetDefaults() {
+	c.Username = ""
+	c.Password = ""
+	c.MaxPoolSize = 100
+	c.MinPoolSize = 10
+	c.SSL = false
+	c.Timeout = 30
+}
+
+// Load 从YAML数据加载配置
+func (c *MongoDBConfig) Load(data map[string]interface{}) error {
+	return c.LoadFromYAML(data, c)
+}
+
+// Validate 验证配置
+func (c *MongoDBConfig) Validate() error {
+	if c.URI == "" {
+		return fmt.Errorf("mongodb URI must be configured")
+	}
+	if c.Database == "" {
+		return fmt.Errorf("mongodb database name must be configured")
+	}
+	if c.MaxPoolSize < c.MinPoolSize {
+		return fmt.Errorf("maxPoolSize must be greater than or equal to minPoolSize")
+	}
+	if c.Timeout <= 0 {
+		return fmt.Errorf("timeout must be a positive integer")
+	}
+
+	return nil
+}
+
+// IsConfigured 检查是否已配置
+func (c *MongoDBConfig) IsConfigured() bool {
+	return c.URI != "" && c.Database != ""
+}
+
+// 自动注册
+func init() {
+	Register("mongodb", &MongoDBConfig{})
+}

config/subconfigs/service_config.go

@@ -6,18 +6,14 @@ import (
 	"log"
 )
 
-type ServicesConfig struct {
-	BaseConfig
-	AppName      string                    `yaml:"app_name"`       //当前应用名称
-	AppVersion   string                    `yaml:"app_version"`    //当前应用版本
-	AppEnv       string                    `yaml:"app_env"`        //环境参数 dev test prod
-	AppAuthToken string                    `yaml:"app_auth_token"` //使用静态认证的时候使用的token
-	Services     map[string]*ServiceConfig `yaml:"services"`       //多个服务配置项
-}
-
-// DatabaseConfig 数据库配置
+// ServiceConfig 数据库配置
 type ServiceConfig struct {
 	BaseConfig
+	AppName      string `yaml:"app_name"`       //当前应用名称
+	AppVersion   string `yaml:"app_version"`    //当前应用版本
+	AppEnv       string `yaml:"app_env"`        //环境参数 dev test prod
+	AppAuthToken string `yaml:"app_auth_token"` //使用静态认证的时候使用的token
+
 	Port         int    `yaml:"port"`
 	ServiceName  string `yaml:"service_name"`
 	InstanceName string `yaml:"instance_name"`
@@ -27,51 +23,11 @@ type ServiceConfig struct {
 }
 
 // SetDefaults 设置默认值 - 实现 ConfigLoader 接口
-func (c *ServicesConfig) SetDefaults() {
+func (c *ServiceConfig) SetDefaults() {
+
 	if c.AppEnv == "" {
 		c.AppEnv = "dev"
 	}
-	//因为是多集合，外层调这里赋默认值，这个时候对象还没有建立。赋默认值的地方移到其他地方去
-}
-
-func (c *ServicesConfig) Load(data map[string]interface{}) error {
-	// 初始化
-	c.Services = make(map[string]*ServiceConfig)
-
-	// 遍历所有配置
-	for dbName, dbData := range data {
-		dbDataMap, ok := dbData.(map[interface{}]interface{})
-		if !ok {
-			return fmt.Errorf("service '%s' config is not a map", dbName)
-		}
-
-		// 转换为 map[string]interface{}
-		stringMap := make(map[string]interface{})
-		for k, v := range dbDataMap {
-			if key, ok := k.(string); ok {
-				stringMap[key] = v
-			}
-		}
-
-		// 创建 ServiceConfig 对象并设置默认值
-		dbConfig := &ServiceConfig{}
-		dbConfig.SetDefaults() // 先设置默认值
-
-		// 加载单个服务配置
-		if err := dbConfig.Load(stringMap); err != nil {
-			return fmt.Errorf("failed to load servuce '%s' config: %v", dbName, err)
-		}
-
-		c.Services[dbName] = dbConfig
-	}
-
-	// 设置默认值和验证
-	//c.SetDefaults()
-	return c.Validate()
-}
-
-// SetDefaults 设置默认值 - 实现 ConfigLoader 接口
-func (c *ServiceConfig) SetDefaults() {
 
 	if c.Port == 0 {
 		c.Port = 8080
@@ -105,37 +61,6 @@ func (c *ServiceConfig) Validate() error {
 	return nil
 }
 
-// Validate 验证配置（多数据库配置）
-func (c *ServicesConfig) Validate() error {
-	if c.Services == nil {
-		log.Println("❌ 错误: 未找到任何微服务配置，请检查配置文件中的 'services' 配置")
-		return fmt.Errorf("no services configurations found")
-	}
-
-	// 必须要有默认数据库
-	if _, exists := c.Services["default"]; !exists {
-		availableDBs := c.GetAllServiceNames()
-		log.Printf("❌ 错误: 默认微服务配置未找到。可用的微服务配置: %v。请在配置文件中添加 'default' 微服务", availableDBs)
-		return fmt.Errorf("default service not found")
-	}
-
-	// 验证每个数据库配置
-	for name, db := range c.Services {
-		if db == nil {
-			log.Printf("❌ 错误: 微服务 '%s' 配置为空", name)
-			return fmt.Errorf("service '%s' configuration is nil", name)
-		}
-
-		if err := db.Validate(); err != nil {
-			log.Printf("❌ 错误: 微服务 '%s' 验证失败: %v", name, err)
-			return fmt.Errorf("service '%s' validation failed: %v", name, err)
-		}
-	}
-
-	log.Printf("✅ 微服务配置验证通过，找到 %d 个微服务配置", len(c.Services))
-	return nil
-}
-
 // IsConfigured 判断是否已配置（数据库配置）
 func (c *ServiceConfig) IsConfigured() bool {
 
@@ -147,89 +72,7 @@ func (c *ServiceConfig) IsConfigured() bool {
 	return true
 }
 
-// IsConfigured 判断是否已配置（多数据库配置）
-func (c *ServicesConfig) IsConfigured() bool {
-	defaultDB := c.GetDefaultService()
-	if defaultDB == nil {
-		log.Println("❌ 错误: 默认微服务不存在")
-		return false
-	}
-
-	if !defaultDB.IsConfigured() {
-		log.Println("❌ 错误: 默认微服务配置不完整")
-		return false
-	}
-
-	return true
-}
-
-// GetDefaultService 获取默认微服务（必须存在）
-func (c *ServicesConfig) GetDefaultService() *ServiceConfig {
-	if c.Services == nil {
-		log.Println("❌ 错误: 尝试获取默认微服务时，微服务配置为空")
-		return nil
-	}
-
-	if db, exists := c.Services["default"]; exists {
-		return db
-	}
-
-	// 如果没有名为default的，尝试返回第一个（但会记录警告）
-	for name, db := range c.Services {
-		log.Printf("⚠️  警告: 未找到名为 'default' 的微服务，使用第一个微服务 '%s' 作为默认", name)
-		return db
-	}
-
-	log.Println("❌ 错误: 服务模块配置中没有任何配置")
-	return nil
-}
-
-// GetService 按名称获取微服务（为空时记录错误）
-func (c *ServicesConfig) GetService(name string) *ServiceConfig {
-	if c.Services == nil {
-		log.Printf("❌ 错误: 尝试获取微服务 '%s' 时，微服务配置为空", name)
-		return nil
-	}
-
-	db := c.Services[name]
-	if db == nil {
-		availableDBs := c.GetAllServiceNames()
-		log.Printf("❌ 错误: 微服务 '%s' 不存在。可用的微服务: %v", name, availableDBs)
-	}
-
-	return db
-}
-
-// GetAllServiceNames 获取所有数据库名称
-func (c *ServicesConfig) GetAllServiceNames() []string {
-	if c.Services == nil {
-		log.Println("⚠️  警告: 尝试获取微服务配置节点名称时，微服务配置为空")
-		return []string{}
-	}
-
-	names := make([]string, 0, len(c.Services))
-	for name := range c.Services {
-		names = append(names, name)
-	}
-	return names
-}
-
-// GetServiceNamesWithoutDefault 获取除default外的所有微服务配置节点名称
-func (c *ServicesConfig) GetServiceNamesWithoutDefault() []string {
-	if c.Services == nil {
-		return []string{}
-	}
-
-	names := make([]string, 0, len(c.Services)-1)
-	for name := range c.Services {
-		if name != "default" {
-			names = append(names, name)
-		}
-	}
-	return names
-}
-
 // 自动注册
 func init() {
-	Register("services", &ServicesConfig{})
+	Register("service", &ServiceConfig{})
 }

consul/register_consul.go

@@ -7,12 +7,33 @@ import (
 	"time"
 
 	"git.x2erp.com/qdy/go-base/client"
+	"git.x2erp.com/qdy/go-base/config"
 	"git.x2erp.com/qdy/go-base/config/subconfigs"
+
 	"github.com/hashicorp/consul/api"
 )
 
+type ConsulFactory struct {
+	config config.IConfig
+	ip     string
+}
+
 // Register 注册服务到Consul
-func Register(serviceName, configHostname string, port int, consulConfig *subconfigs.ConsulConfig) error {
+func Register(cfg config.IConfig) *ConsulFactory {
+
+	serviceName := cfg.GetServiceConfig().ServiceName
+	port := cfg.GetServiceConfig().Port
+	consulConfig := cfg.GetConsulConfig()
+	configHostname := client.GetServiceIP("")
+
+	if consulConfig == nil || !consulConfig.IsConfigured() {
+		log.Println("未配置consul注册发现中心，微服务按单体服务运行.")
+		return &ConsulFactory{
+			config: cfg,
+			ip:     configHostname,
+		}
+	}
+
 	// 1. 获取IP
 	ip := client.GetServiceIP(configHostname)
 	log.Printf("注册服务 %s -> %s:%d 到 %s", serviceName, ip, port, consulConfig.Address)
@@ -36,13 +57,13 @@ func Register(serviceName, configHostname string, port int, consulConfig *subcon
 	// 3. 创建客户端
 	client, err := api.NewClient(apiConfig)
 	if err != nil {
-		return fmt.Errorf("创建Consul客户端失败: %v", err)
+		log.Fatalf("创建Consul客户端失败: %v", err)
 	}
 
 	// 4. 测试连接
 	_, err = client.Agent().Self()
 	if err != nil {
-		return fmt.Errorf("无法连接到Consul服务器 %s: %v", apiConfig.Address, err)
+		log.Fatalf("无法连接到Consul服务器 %s: %v", apiConfig.Address, err)
 	}
 	log.Printf("✅ 成功连接到Consul服务器: %s", apiConfig.Address)
 
@@ -69,25 +90,32 @@ func Register(serviceName, configHostname string, port int, consulConfig *subcon
 
 	err = client.Agent().ServiceRegister(registration)
 	if err != nil {
-		return fmt.Errorf("consul注册失败: %v", err)
+		log.Fatalf("consul注册失败: %v", err)
 	}
 
 	// 打印详细注册信息
-	log.Printf("✅ 服务已注册到Consul服务器: %s", consulConfig.Address)
-	log.Printf("📋 注册详情:")
-	log.Printf("   服务名称: %s", serviceName)
-	log.Printf("   服务地址: %s:%d", ip, port)
-	log.Printf("   服务ID: %s", registration.ID)
-	log.Printf("   健康检查: %s", registration.Check.HTTP)
-	log.Printf("   检查间隔: %s", registration.Check.Interval)
-	log.Printf("   检查超时: %s", registration.Check.Timeout)
-	log.Printf("   失败注销: %s", registration.Check.DeregisterCriticalServiceAfter)
-
-	return nil
+	//log.Printf("✅ 服务已注册到Consul服务器: %s", consulConfig.Address)
+	log.Printf("📋注册详情:")
+	log.Printf("-服务名称: %s", serviceName)
+	log.Printf("-服务地址: %s:%d", ip, port)
+	log.Printf("-服务ID: %s", registration.ID)
+	log.Printf("-健康检查: %s", registration.Check.HTTP)
+	log.Printf("-检查间隔: %s", registration.Check.Interval)
+	log.Printf("-检查超时: %s", registration.Check.Timeout)
+	log.Printf("-失败注销: %s", registration.Check.DeregisterCriticalServiceAfter)
+
+	return &ConsulFactory{
+		config: cfg,
+		ip:     configHostname,
+	}
 }
 
 // CheckRegistration 检查服务是否已注册
 func CheckRegistration(serviceName, configHostname string, port int, consulConfig *subconfigs.ConsulConfig) error {
+	if consulConfig == nil || !consulConfig.IsConfigured() {
+		log.Println("未配置consul注册发现中心，微服务按单体服务运行.")
+		return nil
+	}
 	ip := client.GetServiceIP(configHostname)
 	serviceID := fmt.Sprintf("%s-%s-%d", serviceName, ip, port)
 
@@ -128,9 +156,23 @@ func CheckRegistration(serviceName, configHostname string, port int, consulConfi
 	return fmt.Errorf("服务未注册: %s", serviceID)
 }
 
-// Deregister 注销服务
-func Deregister(serviceName, ip string, port int, consulConfig *subconfigs.ConsulConfig) error {
-	serviceID := fmt.Sprintf("%s-%s-%d", serviceName, ip, port)
+func (c *ConsulFactory) GetName() string {
+	return "ConsulFactory"
+}
+
+// Close 注销服务
+func (c *ConsulFactory) Close() {
+
+	serviceName := c.config.GetServiceConfig().ServiceName
+	port := c.config.GetServiceConfig().Port
+	consulConfig := c.config.GetConsulConfig()
+
+	if consulConfig == nil || !consulConfig.IsConfigured() {
+		log.Println("未配置consul注册发现中心,服务不用到注册中心进行注销.")
+
+	}
+
+	serviceID := fmt.Sprintf("%s-%s-%d", serviceName, c.ip, port)
 
 	// 创建客户端
 	apiConfig := api.DefaultConfig()
@@ -139,15 +181,18 @@ func Deregister(serviceName, ip string, port int, consulConfig *subconfigs.Consu
 	}
 	client, err := api.NewClient(apiConfig)
 	if err != nil {
-		return fmt.Errorf("创建consul客户端失败: %v", err)
+		log.Printf("创建consul客户端失败: %v", err)
+		return
 	}
 
 	// 注销服务
 	err = client.Agent().ServiceDeregister(serviceID)
 	if err != nil {
-		return fmt.Errorf("从consul注销服务失败 (ID: %s): %v", serviceID, err)
+
+		log.Printf("从consul注销服务失败 (ID: %s): %v", serviceID, err)
+		return
 	}
 
 	log.Printf("✅ 已从consul注销服务: %s", serviceID)
-	return nil
+	return
 }

container/container_factory.go

@@ -0,0 +1,103 @@
+// container_factory.go
+package container
+
+import (
+	"log"
+	"sync"
+
+	"git.x2erp.com/qdy/go-base/config"
+)
+
+type Resource interface {
+	GetName() string
+	Close()
+}
+
+type CreateFunc[T Resource] func(cfg config.IConfig) T
+
+type ContainerFactory struct {
+	config    config.IConfig
+	resources map[string]Resource // 用map按名称存储
+	order     []string            // 保持添加顺序
+	mu        sync.RWMutex
+}
+
+func NewContainer(cfg config.IConfig) *ContainerFactory {
+	return &ContainerFactory{
+		config:    cfg,
+		resources: make(map[string]Resource),
+		order:     make([]string, 0),
+	}
+}
+
+// 泛型方法：如果不存在则创建并注册
+func Create[T Resource](c *ContainerFactory, createFunc CreateFunc[T]) T {
+	//c.mu.Lock()
+	//defer c.mu.Unlock()
+
+	// 先创建对象获取名称
+	resource := createFunc(c.config)
+	return Reg(c, resource)
+	// name := resource.GetName()
+
+	// log.Printf("创建 %s 对象", name)
+
+	// // 如果已存在，返回已注册的对象
+	// if existing, ok := c.resources[name]; ok {
+	// 	log.Printf("对象 %s 已经存在.", name)
+	// 	return existing.(T) // 安全，因为同名的类型肯定相同
+	// }
+
+	// log.Printf("缓存 %s 对象", name)
+
+	// // 添加到order（保持顺序）
+	// c.order = append(c.order, name)
+
+	// // 存储到map
+	// c.resources[name] = resource
+	// return resource
+}
+
+// / Reg 直接注册已创建的对象
+func Reg[T Resource](c *ContainerFactory, resource T) T {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	name := resource.GetName()
+	log.Printf("直接注册 %s 对象", name)
+
+	// 如果已存在，返回已注册的对象（或报错）
+	if existing, ok := c.resources[name]; ok {
+		log.Printf("对象 %s 已经存在，跳过注册", name)
+		// 可以选择返回已有的对象或什么都不做
+		return existing.(T) // 安全，因为同名的类型肯定相同
+	}
+
+	log.Printf("缓存 %s 对象", name)
+
+	// 添加到order（保持顺序）
+	c.order = append(c.order, name)
+
+	// 存储到map
+	c.resources[name] = resource
+	log.Printf("已注册 %s 对象", name)
+	return resource
+}
+
+// 按添加顺序关闭（先进先出，最先添加的最先关闭）
+func (c *ContainerFactory) CloseAll() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	// 按添加顺序关闭
+	for _, name := range c.order {
+		if res, ok := c.resources[name]; ok {
+			res.Close()
+			log.Printf("关闭 %s 对象", name)
+		}
+	}
+
+	// 清空容器
+	c.resources = make(map[string]Resource)
+	c.order = make([]string, 0)
+}

go.mod

@@ -55,6 +55,7 @@ require (
 	github.com/go-git/go-git/v5 v5.16.4 // indirect
 	github.com/golang/protobuf v1.5.4 // indirect
 	github.com/google/uuid v1.6.0 // indirect
+	github.com/iancoleman/strcase v0.3.0
 	github.com/imdario/mergo v0.3.16 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
 	github.com/kevinburke/ssh_config v1.4.0 // indirect

go.sum

@@ -105,6 +105,8 @@ github.com/hashicorp/memberlist v0.2.2 h1:5+RffWKwqJ71YPu9mWsF7ZOscZmwfasdA8kbdC
 github.com/hashicorp/memberlist v0.2.2/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE=
 github.com/hashicorp/serf v0.9.5 h1:EBWvyu9tcRszt3Bxp3KNssBMP1KuHWyO51lz9+786iM=
 github.com/hashicorp/serf v0.9.5/go.mod h1:UWDWwZeL5cuWDJdl0C6wrvrUwEqtQ4ZKBKKENpqIUyk=
+github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI=
+github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho=
 github.com/imdario/mergo v0.3.16 h1:wwQJbIsHYGMUyLSPrEq1CT16AhnhNJQ51+4fdHUnCl4=
 github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=

logger/boot_logger.go

@@ -10,22 +10,25 @@ import (
 	"time"
 )
 
+type BootLoggerFactory struct {
+}
+
 var (
 	bootLogFile *os.File
 	bootLogger  *log.Logger
 )
 
 // InitBootLogger 初始化启动日志（只在启动阶段使用）
-func InitBootLog(serviceName string) error {
+func InitBootLog() *BootLoggerFactory {
 
 	if logToFile := os.Getenv("LOG_TO_FILE"); logToFile == "false" {
-		return nil
+		return &BootLoggerFactory{}
 	}
 
 	// 1. 确保日志目录存在
 	logDir := "logs"
 	if err := os.MkdirAll(logDir, 0755); err != nil {
-		return fmt.Errorf("创建日志目录失败: %v", err)
+		log.Fatalf("创建日志目录失败: %v", err)
 	}
 
 	// 2. 创建启动日志文件
@@ -35,7 +38,7 @@ func InitBootLog(serviceName string) error {
 
 	file, err := os.Create(filePath)
 	if err != nil {
-		return fmt.Errorf("创建启动日志文件失败: %v", err)
+		log.Fatalf("创建启动日志文件失败: %v", err)
 	}
 
 	bootLogFile = file
@@ -54,7 +57,7 @@ func InitBootLog(serviceName string) error {
 	BootLog("启动时间: %s", time.Now().Format("2006-01-02 15:04:05"))
 	BootLog("启动日志文件: %s", filePath)
 
-	return nil
+	return &BootLoggerFactory{}
 }
 
 // BootLog 启动阶段专用日志函数
@@ -68,8 +71,12 @@ func BootLog(format string, v ...interface{}) {
 	}
 }
 
+func (f *BootLoggerFactory) GetName() string {
+	return "BootLoggerFactory"
+}
+
 // CloseBootLogger 关闭启动日志，切换到运行日志
-func CloseBootLogger() {
+func (f *BootLoggerFactory) Close() {
 	if bootLogger != nil {
 		BootLog("=== 启动阶段结束，切换到运行时日志 ===")
 	}

logger/runtime_logger.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	"git.x2erp.com/qdy/go-base/config"
 	"git.x2erp.com/qdy/go-base/config/subconfigs"
 	"git.x2erp.com/qdy/go-base/ctx"
 	"git.x2erp.com/qdy/go-base/logger/http"
@@ -18,6 +19,9 @@ import (
 	"gopkg.in/natefinch/lumberjack.v2"
 )
 
+type RunTimeLoggerFactory struct {
+}
+
 var (
 	runtimeLogger  *zap.Logger
 	runtimeSugared *zap.SugaredLogger
@@ -35,8 +39,14 @@ var (
 // }
 
 // InitRuntimeLogger 初始化
-func InitRuntimeLogger(svcName, svcVersion string, logConfig *subconfigs.LogConfig) {
+func InitRuntimeLogger(cfg config.IConfig) *RunTimeLoggerFactory {
+
+	svcName := cfg.GetAppName()
+	svcVersion := cfg.GetAppVersion()
+	logConfig := cfg.GetLogConfig()
+
 	initOnce.Do(func() {
+
 		if logConfig == nil {
 			log.Fatal("错误: 日志配置不能为空")
 		}
@@ -54,6 +64,7 @@ func InitRuntimeLogger(svcName, svcVersion string, logConfig *subconfigs.LogConf
 		log.Printf("日志级别: %s", logConfig.Level)
 
 	})
+	return &RunTimeLoggerFactory{}
 }
 
 func createRuntimeLogger(svcName, svcVersion string, cfg *subconfigs.LogConfig) error {
@@ -115,7 +126,7 @@ func createRuntimeLogger(svcName, svcVersion string, cfg *subconfigs.LogConfig)
 				level,
 			)
 			cores = append(cores, consoleCore)
-			log.Printf("[RUNTIME-LOGGER] 初始化控制台日志输出（文本格式）")
+			log.Printf("[RUNTIME-LOGGER] 初始化控制台日志输出（文本格式）%s", svcVersion)
 
 		case "file":
 			// 文件输出（JSON格式）
@@ -155,7 +166,7 @@ func createRuntimeLogger(svcName, svcVersion string, cfg *subconfigs.LogConfig)
 			err := http.InitESWriter(
 				svcName,
 				cfg.ESPath,
-				cfg.ESUsername, // 假设LogConfig已有这些字段
+				cfg.ESUsername,
 				cfg.ESPassword,
 				containsConsole,
 			)
@@ -192,7 +203,7 @@ func createRuntimeLogger(svcName, svcVersion string, cfg *subconfigs.LogConfig)
 	// 7. 创建logger
 	runtimeLogger = zap.New(core,
 		zap.AddCaller(),
-		zap.AddCallerSkip(2),
+		zap.AddCallerSkip(1),
 		zap.AddStacktrace(zap.ErrorLevel),
 		//zap.Fields(
 		//	zap.String("service", svcName),
@@ -329,3 +340,30 @@ func IsDebug() bool {
 	}
 	return runtimeLogger.Core().Enabled(zapcore.DebugLevel)
 }
+
+func (f *RunTimeLoggerFactory) GetName() string {
+	return "RunTimeLoggerFactory"
+}
+
+// RunTimeLoggerFactory 关闭启动日志，切换到运行日志
+func (f *RunTimeLoggerFactory) Close() {
+
+	// 1. 同步日志缓冲区
+	if runtimeLogger != nil {
+		_ = runtimeLogger.Sync() // 忽略错误，因为sync可能失败
+	}
+
+	// 2. 关闭ES写入器（如果有）
+	StopESWriter()
+
+	// 3. 清理资源
+	// 注意：zap.Logger 不需要显式关闭，Sync() 已足够
+
+	// 5. 使用标准库日志记录关闭信息
+	if serviceName != "" {
+		log.Printf("[RUNTIME-LOGGER] 服务 %s 日志系统已关闭", serviceName)
+	} else {
+		log.Printf("[RUNTIME-LOGGER] 日志系统已关闭")
+	}
+
+}

middleware/auth_middleware.go

@@ -57,8 +57,8 @@ func JWTAuthMiddleware(next http.Handler) http.Handler {
 		//保存上下文
 		// 创建LoggerContext（从token解析用户信息）
 		requestContext := &ctx.RequestContext{
-			ServiceName:  appConfig.GetService().ServiceName,
-			InstanceName: appConfig.GetService().InstanceName,
+			ServiceName:  appConfig.GetServiceConfig().ServiceName,
+			InstanceName: appConfig.GetServiceConfig().InstanceName,
 			TraceID:      "trace_id-123", // 生成追踪ID
 			TenantID:     "tenant-123",   // 从token解析
 			UserID:       "user-456",     // 从token解析

models/bson_model.go

@@ -0,0 +1,71 @@
+package models
+
+import (
+	"time"
+
+	"git.x2erp.com/qdy/go-base/ctx"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+// IDType 泛型类型约束
+type IDType interface {
+	string | primitive.ObjectID
+}
+
+// 泛型内部模型
+type bsonModel[T IDType] struct {
+	ID        T         `bson:"_id,omitempty" json:"id,omitempty"`
+	TenantId  string    `bson:"tenant_id,omitempty"`
+	CreatedBy string    `bson:"created_by,omitempty" json:"created_by,omitempty"`
+	CreatedAt time.Time `bson:"created_at" json:"created_at"`
+	UpdatedBy string    `bson:"updated_by,omitempty" json:"updated_by,omitempty"`
+	UpdatedAt time.Time `bson:"updated_at" json:"updated_at"`
+}
+
+// 保持原有的外部类型
+type BsonStringModel = bsonModel[string]
+type BsonObjectModel = bsonModel[primitive.ObjectID]
+
+// 创建新的 String 模型（自动生成ID）
+func NewStringIDModel(ctx ctx.RequestContext) BsonStringModel {
+	return BsonStringModel{
+		ID:        primitive.NewObjectID().Hex(),
+		TenantId:  ctx.TenantID,
+		CreatedAt: time.Now(),
+		CreatedBy: ctx.UserID,
+		UpdatedAt: time.Now(),
+		UpdatedBy: ctx.UserID,
+	}
+}
+
+// 创建新的 String 模型（自定义ID）
+func NewStringIDModelWithID(ctx ctx.RequestContext, id string) BsonStringModel {
+	return BsonStringModel{
+		ID:        id,
+		TenantId:  ctx.TenantID,
+		CreatedAt: time.Now(),
+		CreatedBy: ctx.UserID,
+		UpdatedAt: time.Now(),
+		UpdatedBy: ctx.UserID,
+	}
+}
+
+// 创建新的 ObjectID 模型（自动生成ID）
+func NewObjectIDModel(ctx ctx.RequestContext) BsonObjectModel {
+	return BsonObjectModel{
+		ID:        primitive.NewObjectID(),
+		TenantId:  ctx.TenantID,
+		CreatedAt: time.Now(),
+		CreatedBy: ctx.UserID,
+		UpdatedAt: time.Now(),
+		UpdatedBy: ctx.UserID,
+	}
+}
+
+// 用于更新操作的模型（只设置更新信息）
+func ModelForUpdate(ctx ctx.RequestContext) BsonStringModel {
+	return BsonStringModel{
+		UpdatedAt: time.Now(),
+		UpdatedBy: ctx.UserID,
+	}
+}

test.go

@@ -8,17 +8,11 @@ import (
 
 func main() {
 	// 获取配置实例
-	cfg, err := config.GetConfig()
-
-	// 检查初始化是否有错误
-	if err != nil {
-		fmt.Printf("配置加载失败: %v\n", err)
-		return
-	}
+	cfg := config.GetConfig()
 
 	// 使用配置
 	if cfg.IsDatabaseConfigured() {
-		dbConfig := cfg.GetDatabase()
+		dbConfig := cfg.GetDatabaseConfig()
 		fmt.Printf("Host: %s\n", dbConfig.Host)
 		fmt.Printf("Port: %d\n", dbConfig.Port)
 		fmt.Printf("Database: %s\n", dbConfig.Database)
@@ -27,7 +21,7 @@ func main() {
 	//authConfig := cfg.GetAuth()
 	//fmt.Printf("token: %s\n", authConfig.Token)
 
-	serviceConfig := cfg.GetService()
+	serviceConfig := cfg.GetServiceConfig()
 	fmt.Printf("ReadTimeout: %d秒\n", serviceConfig.ReadTimeout)
 	fmt.Printf("WriteTimeout: %d秒\n", serviceConfig.WriteTimeout)
 	fmt.Printf("IdleTimeout: %d秒\n", serviceConfig.IdleTimeout)

types/types.go

@@ -74,8 +74,8 @@ type BytesMessageRequest struct {
 
 // QueueInfoRequest 获取队列信息的请求
 type QueueInfoRequest struct {
-	ChannelName string `json:"channel_name"`
-	QueueName   string `json:"queue_name"`
+	ChannelName string `json:"channel_name,omitempty"`
+	QueueName   string `json:"queue_name,omitempty"`
 }
 
 // RabbitMQResult RabbitMQ操作结果

utils/modle_util.go

@@ -0,0 +1,90 @@
+package utils
+
+import (
+	"reflect"
+	"strings"
+
+	"github.com/iancoleman/strcase"
+)
+
+// GetStructName 获取结构体名称
+func GetStructName(v interface{}) string {
+	if v == nil {
+		return ""
+	}
+
+	t := reflect.TypeOf(v)
+
+	// 处理指针
+	for t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+
+	// 返回结构体名称
+	return t.Name()
+}
+
+// GetSnakeName 获取结构体的蛇形命名（snake_case）
+func GetSnakeName(v interface{}) string {
+	structName := GetStructName(v)
+	return strcase.ToSnake(structName)
+}
+
+// GetCamelName 获取结构体的驼峰命名（camelCase）
+func GetCamelName(v interface{}) string {
+	structName := GetStructName(v)
+	return strcase.ToLowerCamel(structName)
+}
+
+// GetKebabName 获取结构体的烤肉串命名（kebab-case）
+func GetKebabName(v interface{}) string {
+	structName := GetStructName(v)
+	return strcase.ToKebab(structName)
+}
+
+// ToSnake 驼峰转蛇形
+func ToSnake(s string) string {
+	return strcase.ToSnake(s)
+}
+
+// ToCamel 蛇形转驼峰
+func ToCamel(s string) string {
+	return strcase.ToLowerCamel(s)
+}
+
+// ToLowerCamel 下划线转小驼峰
+func ToLowerCamel(s string) string {
+	return strcase.ToLowerCamel(s)
+}
+
+// ToKebab 转烤肉串命名
+func ToKebab(s string) string {
+	return strcase.ToKebab(s)
+}
+
+// GetCollectionName 获取MongoDB集合名称
+// 可以自定义规则，例如去除特定后缀
+func GetCollectionName(v interface{}) string {
+	structName := GetStructName(v)
+
+	// 移除常见后缀
+	suffixes := []string{"Model", "Entity", "Record", "Document"}
+	for _, suffix := range suffixes {
+		if strings.HasSuffix(structName, suffix) {
+			structName = strings.TrimSuffix(structName, suffix)
+			break
+		}
+	}
+
+	// 转换为复数形式（简单规则）
+	if !strings.HasSuffix(structName, "s") {
+		// 简单的复数化规则
+		if strings.HasSuffix(structName, "y") {
+			structName = strings.TrimSuffix(structName, "y") + "ies"
+		} else {
+			structName = structName + "s"
+		}
+	}
+
+	return strcase.ToSnake(structName)
+}

webx/health_handle.go → webx/health/health_handle.go

@@ -1,11 +1,13 @@
-// webx/health_util.go
-package webx
+// webx/health_handle.go
+package health
 
 import (
+	"log"
 	"time"
 
 	"git.x2erp.com/qdy/go-base/config"
 	"git.x2erp.com/qdy/go-base/logger"
+	"git.x2erp.com/qdy/go-base/webx/router"
 )
 
 // HealthResponse 健康检查响应
@@ -20,22 +22,22 @@ type HealthResponse struct {
 }
 
 // RegisterDefaultHealthCheck 注册默认健康检查路由（带详细日志）
-func RegisterDefaultHealthCheck(ws *WebService, serviceName string) {
+func RegisterDefaultHealthCheck(ws *router.RouterService, serviceName string) {
 	if serviceName == "" {
-		cfg, _ := config.GetConfig()
+		cfg := config.GetConfig()
 		serviceName = cfg.GetAppName()
 		if serviceName == "" {
 			serviceName = "unknown-service"
 		}
 	}
 
-	logger.Debug("注册健康检查路由，服务名: %s", serviceName)
+	log.Printf("注册健康检查路由，服务名: %s", serviceName)
 
 	// 健康检查（带详细日志）
 	ws.GET("/health", func() (HealthResponse, error) {
-		logger.Debug("健康检查被调用: /health")
+		log.Printf("健康检查被调用: /health")
 
-		cfg, _ := config.GetConfig()
+		cfg := config.GetConfig()
 		response := HealthResponse{
 			Status:    "ok",
 			Service:   serviceName,
@@ -44,13 +46,13 @@ func RegisterDefaultHealthCheck(ws *WebService, serviceName string) {
 			Timestamp: time.Now().Format(time.RFC3339),
 		}
 
-		logger.Debug("健康检查响应: %+v", response)
+		log.Printf("健康检查响应: %+v", response)
 		return response, nil
 	}).Desc("健康检查").Register()
 
 	// 就绪检查
 	ws.GET("/health/ready", func() (HealthResponse, error) {
-		logger.Debug("就绪检查被调用: /health/ready")
+		log.Printf("就绪检查被调用: /health/ready")
 
 		return HealthResponse{
 			Status:    "ready",
@@ -61,7 +63,7 @@ func RegisterDefaultHealthCheck(ws *WebService, serviceName string) {
 
 	// 存活检查
 	ws.GET("/health/live", func() (HealthResponse, error) {
-		logger.Debug("存活检查被调用: /health/live")
+		log.Printf("存活检查被调用: /health/live")
 
 		return HealthResponse{
 			Status:    "alive",
@@ -72,9 +74,9 @@ func RegisterDefaultHealthCheck(ws *WebService, serviceName string) {
 
 	// 服务信息
 	ws.GET("/health/info", func() (map[string]interface{}, error) {
-		logger.Debug("服务信息被调用: /health/info")
+		log.Printf("服务信息被调用: /health/info")
 
-		cfg, _ := config.GetConfig()
+		cfg := config.GetConfig()
 		response := map[string]interface{}{
 			"service":     serviceName,
 			"version":     cfg.GetAppVersion(),
@@ -97,25 +99,24 @@ func RegisterDefaultHealthCheck(ws *WebService, serviceName string) {
 		return response, nil
 	}).Desc("服务信息").Register()
 
-	logger.Debug("健康检查路由注册完成，路径: /health, /health/ready, /health/live, /health/info")
 }
 
 // RegisterConsulHealthCheck 注册Consul兼容的健康检查
-func RegisterConsulHealthCheck(ws *WebService) {
-	logger.Debug("注册Consul兼容健康检查路由")
+func RegisterConsulHealthCheck(ws *router.RouterService) {
+	log.Printf("注册Consul兼容健康检查路由")
 
 	// Consul需要的健康检查端点（返回text/plain）
 	ws.GET("/health", func() ([]byte, error) {
-		logger.Info("Consul健康检查被调用: /health")
-		logger.Info("返回 'OK' 给Consul")
+		//log.Printf("Consul健康检查被调用: /health")
+		//log.Printf("返回 'OK' 给Consul")
 		return []byte("OK"), nil
 	}).Desc("Consul健康检查").Register()
 
 	// Consul详细状态检查
 	ws.GET("/health/consul", func() (map[string]interface{}, error) {
-		logger.Debug("Consul状态检查被调用: /health/consul")
+		//log.Printf("Consul状态检查被调用: /health/consul")
 
-		cfg, _ := config.GetConfig()
+		cfg := config.GetConfig()
 		response := map[string]interface{}{
 			"status":  "passing",
 			"service": cfg.GetAppName(),
@@ -127,14 +128,14 @@ func RegisterConsulHealthCheck(ws *WebService) {
 			},
 		}
 
-		logger.Debug("Consul健康状态响应: %+v", response)
+		//log.Printf("Consul健康状态响应: %+v", response)
 		return response, nil
 	}).Desc("Consul健康状态").Register()
 }
 
 // RegisterAllHealthChecks 注册所有健康检查（推荐使用）
-func RegisterAllHealthChecks(ws *WebService, serviceName string) {
-	logger.Debug("开始注册所有健康检查路由...")
+func RegisterAllHealthChecks(ws *router.RouterService, serviceName string) {
+	log.Printf("开始注册所有健康检查路由...")
 
 	// 注册默认健康检查
 	RegisterDefaultHealthCheck(ws, serviceName)
@@ -152,5 +153,5 @@ func RegisterAllHealthChecks(ws *WebService, serviceName string) {
 		}, nil
 	}).Desc("简单Ping检查").Register()
 
-	logger.Debug("所有健康检查路由注册完成")
+	log.Printf("所有健康检查路由注册完成")
 }

webx/web_service.go → webx/router/router_service.go

@@ -1,4 +1,4 @@
-package webx
+package router
 
 import (
 	"encoding/json"
@@ -11,14 +11,14 @@ import (
 )
 
 // WebService 路由服务
-type WebService struct {
+type RouterService struct {
 	router      *http.ServeMux
 	middlewares []func(http.Handler) http.Handler
 }
 
 // NewWebService 创建WebService
-func NewWebService(router *http.ServeMux) *WebService {
-	ws := &WebService{
+func NewWebService(router *http.ServeMux) *RouterService {
+	ws := &RouterService{
 		router: router,
 	}
 
@@ -26,33 +26,33 @@ func NewWebService(router *http.ServeMux) *WebService {
 }
 
 // Use 添加全局中间件
-func (ws *WebService) Use(middleware func(http.Handler) http.Handler) *WebService {
+func (ws *RouterService) Use(middleware func(http.Handler) http.Handler) *RouterService {
 	ws.middlewares = append(ws.middlewares, middleware)
 	return ws
 }
 
 // GET 注册GET请求
-func (ws *WebService) GET(path string, handler interface{}) *RouteBuilder {
+func (ws *RouterService) GET(path string, handler interface{}) *RouteBuilder {
 	return ws.handle("GET", path, handler)
 }
 
 // POST 注册POST请求
-func (ws *WebService) POST(path string, handler interface{}) *RouteBuilder {
+func (ws *RouterService) POST(path string, handler interface{}) *RouteBuilder {
 	return ws.handle("POST", path, handler)
 }
 
 // PUT 注册PUT请求
-func (ws *WebService) PUT(path string, handler interface{}) *RouteBuilder {
+func (ws *RouterService) PUT(path string, handler interface{}) *RouteBuilder {
 	return ws.handle("PUT", path, handler)
 }
 
 // DELETE 注册DELETE请求
-func (ws *WebService) DELETE(path string, handler interface{}) *RouteBuilder {
+func (ws *RouterService) DELETE(path string, handler interface{}) *RouteBuilder {
 	return ws.handle("DELETE", path, handler)
 }
 
 // handle 统一处理方法
-func (ws *WebService) handle(method, path string, handler interface{}) *RouteBuilder {
+func (ws *RouterService) handle(method, path string, handler interface{}) *RouteBuilder {
 	// 解析路径参数名
 	paramNames := extractPathParams(path)
 
@@ -79,67 +79,9 @@ func (ws *WebService) handle(method, path string, handler interface{}) *RouteBui
 	}
 }
 
-// // 上下文中间件
-// 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
+	ws          *RouterService
 	method      string
 	path        string
 	handlerFunc reflect.Value
@@ -190,7 +132,7 @@ func (rb *RouteBuilder) Register() {
 
 // handlerAdapter 处理器适配器
 type handlerAdapter struct {
-	ws          *WebService
+	ws          *RouterService
 	method      string
 	pathPattern string
 	paramNames  []string
@@ -293,132 +235,6 @@ func (ha *handlerAdapter) buildArgs(w http.ResponseWriter, r *http.Request, path
 	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 {

webx/webx_factory.go

@@ -0,0 +1,325 @@
+package webx
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"time"
+
+	"git.x2erp.com/qdy/go-base/client"
+	"git.x2erp.com/qdy/go-base/config/subconfigs"
+	"git.x2erp.com/qdy/go-base/container"
+	"git.x2erp.com/qdy/go-base/logger"
+)
+
+// WebService Web服务实例
+type WebService struct {
+	serviceName string
+	httpServer  *http.Server
+	router      *http.ServeMux
+	//RouterService *router.RouterService // 暴露RouterService
+	quit   chan os.Signal
+	config *subconfigs.ServiceConfig
+	ip     string
+	port   int
+}
+
+// WebServiceFactory Web服务工厂（全局单例模式）
+type WebServiceFactory struct {
+	mu         sync.RWMutex
+	webService *WebService
+}
+
+var (
+	instanceWebService     *WebServiceFactory
+	instanceWebServiceOnce sync.Once
+)
+
+// GetWebServiceFactory 获取Web服务工厂单例
+func GetWebServiceFactory() *WebServiceFactory {
+	instanceWebServiceOnce.Do(func() {
+		log.Printf("Creating WebServiceFactory...")
+
+		instanceWebService = &WebServiceFactory{}
+
+		log.Printf("WebServiceFactory is successfully created.")
+	})
+
+	return instanceWebService
+}
+
+// CreateService 创建Web服务实例
+func (f *WebServiceFactory) CreateService(config *subconfigs.ServiceConfig) (*WebService, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	// 检查是否已存在服务
+	if f.webService != nil {
+		log.Printf("服务已存在，返回现有实例: %s", f.webService.serviceName)
+		return f.webService, nil
+	}
+
+	// 验证配置
+	if config == nil {
+		return nil, fmt.Errorf("服务配置不能为空")
+	}
+
+	// 设置默认值
+	if config.Port == 0 {
+		config.Port = 8080
+	}
+	if config.ServiceName == "" {
+		config.ServiceName = "default-service"
+	}
+	if config.ReadTimeout == 0 {
+		config.ReadTimeout = 15
+	}
+	if config.WriteTimeout == 0 {
+		config.WriteTimeout = 15
+	}
+	if config.IdleTimeout == 0 {
+		config.IdleTimeout = 60
+	}
+
+	// 获取IP
+	ip := client.GetServiceIP("")
+
+	// 创建服务实例
+	service := &WebService{
+		serviceName: config.ServiceName,
+		router:      http.NewServeMux(),
+		quit:        make(chan os.Signal, 1),
+		config:      config,
+		ip:          ip,
+		port:        config.Port,
+	}
+
+	// 创建HTTP服务器
+	service.httpServer = &http.Server{
+		Addr:         fmt.Sprintf(":%d", config.Port),
+		Handler:      service.router,
+		ReadTimeout:  time.Duration(config.ReadTimeout) * time.Second,
+		WriteTimeout: time.Duration(config.WriteTimeout) * time.Second,
+		IdleTimeout:  time.Duration(config.IdleTimeout) * time.Second,
+	}
+
+	// 保存实例
+	f.webService = service
+
+	log.Printf("已创建服务实例: %s (端口: %d)", config.ServiceName, config.Port)
+	return service, nil
+}
+
+// IsCreated 检查服务是否已创建
+func (f *WebServiceFactory) IsCreated() bool {
+	f.mu.RLock()
+	defer f.mu.RUnlock()
+	return f.webService != nil
+}
+
+// ========== WebService 实例方法 ==========
+
+// GetRouter 获取路由器
+func (s *WebService) GetRouter() *http.ServeMux {
+	return s.router
+}
+
+// GetServer 获取HTTP服务器
+func (s *WebService) GetServer() *http.Server {
+	return s.httpServer
+}
+
+// GetServiceName 获取服务名称
+func (s *WebService) GetServiceName() string {
+	return s.serviceName
+}
+
+// GetIP 获取服务IP
+func (s *WebService) GetIP() string {
+	return s.ip
+}
+
+// GetPort 获取服务端口
+func (s *WebService) GetPort() int {
+	return s.port
+}
+
+// GetConfig 获取服务配置
+func (s *WebService) GetConfig() *subconfigs.ServiceConfig {
+	return s.config
+}
+
+// RegisterRoute 注册路由
+func (s *WebService) RegisterRoute(pattern string, handler http.Handler) {
+	s.router.Handle(pattern, handler)
+}
+
+// RegisterRouteFunc 注册路由处理函数
+func (s *WebService) RegisterRouteFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
+	s.router.HandleFunc(pattern, handler)
+}
+
+// Run 运行所有服务
+func (s *WebService) Run() {
+	// 设置全局信号监听
+	signal.Notify(s.quit, syscall.SIGINT, syscall.SIGTERM)
+
+	log.Printf("启动服务 %s 在 %s", s.serviceName, s.httpServer.Addr)
+
+	// 在goroutine中启动服务，避免阻塞
+	go func() {
+		if err := s.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("服务 %s 运行失败: %v", s.serviceName, err)
+		}
+	}()
+
+	// 等待中断信号，传递指针
+	//s.waitForServiceShutdown(containerFactory)
+}
+
+// RunTLS 运行HTTPS服务
+func (s *WebService) RunTLS(serviceName, certFile, keyFile string) {
+
+	log.Printf("服务 %s 开始运行(HTTPS)...", s.serviceName)
+
+	// 设置服务级别的信号监听
+	signal.Notify(s.quit, syscall.SIGINT, syscall.SIGTERM)
+
+	// 启动HTTPS服务器
+	go func() {
+		log.Printf("HTTPS服务器启动在 %s", s.httpServer.Addr)
+		if err := s.httpServer.ListenAndServeTLS(certFile, keyFile); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("服务运行失败: %v", err)
+		}
+	}()
+
+	// 等待中断信号
+	//s.waitForServiceShutdown(containerFactory)
+}
+
+// waitForServiceShutdown 等待单个服务关闭
+func (s *WebService) WaitForServiceShutdown(containerFactory *container.ContainerFactory) {
+
+	log.Printf("按 Ctrl+C 停止服务 %s", s.serviceName)
+
+	// 等待信号
+	<-s.quit
+	log.Printf("接收到终止信号，正在优雅关闭服务 %s...", s.serviceName)
+
+	//退出注册中心
+	//consul.Deregister(s.serviceName, s.Ip, s.Port, b.Cfg.GetConsulConfig())
+
+	// 创建关闭上下文，给30秒完成当前请求
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	// 停止接收新请求，完成当前请求
+	if err := s.httpServer.Shutdown(ctx); err != nil {
+		log.Printf("服务 %s 关闭失败: %v", s.serviceName, err)
+	} else {
+		log.Printf("服务 %s 已关闭", s.serviceName)
+	}
+
+	// 执行关闭处理
+	if containerFactory != nil {
+		containerFactory.CloseAll()
+	}
+
+	// 停止日志写入
+	logger.StopESWriter()
+	log.Printf("服务 %s 优雅关闭完成", s.serviceName)
+
+	// 等待一小段时间确保日志写入完成
+	time.Sleep(100 * time.Millisecond)
+	os.Exit(0)
+}
+
+// AddMiddleware 添加中间件
+func (s *WebService) AddMiddleware(middleware func(http.Handler) http.Handler) {
+	s.httpServer.Handler = middleware(s.httpServer.Handler)
+}
+
+// EnableCORS 启用CORS支持
+func (s *WebService) EnableCORS() {
+	s.AddMiddleware(func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Access-Control-Allow-Origin", "*")
+			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+			w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
+
+			if r.Method == "OPTIONS" {
+				w.WriteHeader(http.StatusOK)
+				return
+			}
+
+			next.ServeHTTP(w, r)
+		})
+	})
+}
+
+// EnableRequestLogging 启用请求日志记录
+func (s *WebService) EnableRequestLogging() {
+	s.AddMiddleware(func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			start := time.Now()
+
+			// 使用包装器记录响应状态码
+			rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
+
+			next.ServeHTTP(rw, r)
+
+			// 记录日志
+			duration := time.Since(start)
+			log.Printf("%s %s %d %v", r.Method, r.URL.Path, rw.statusCode, duration)
+			logger.Info("%s %s %d %v", r.Method, r.URL.Path, rw.statusCode, duration)
+		})
+	})
+}
+
+// 辅助类型，用于记录响应状态码
+type responseWriter struct {
+	http.ResponseWriter
+	statusCode int
+}
+
+func (rw *responseWriter) WriteHeader(code int) {
+	rw.statusCode = code
+	rw.ResponseWriter.WriteHeader(code)
+}
+
+// HealthCheck 添加健康检查端点
+func (s *WebService) HealthCheck(pattern string) {
+	s.RegisterRouteFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("OK"))
+	})
+}
+
+// Metrics 添加指标端点
+func (s *WebService) Metrics(pattern string) {
+	s.RegisterRouteFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/plain")
+		w.WriteHeader(http.StatusOK)
+		// 这里可以添加应用的指标数据
+		w.Write([]byte("# HELP go_info Information about the Go environment.\n"))
+		w.Write([]byte("# TYPE go_info gauge\n"))
+		w.Write([]byte("go_info{version=\"1.19\"} 1\n"))
+	})
+}
+
+// StaticFile 添加静态文件服务
+func (s *WebService) StaticFile(pattern, filepath string) {
+	s.RegisterRouteFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
+		http.ServeFile(w, r, filepath)
+	})
+}
+
+// StaticDirectory 添加静态目录服务
+func (s *WebService) StaticDirectory(pattern, directory string) {
+	s.RegisterRoute(pattern, http.StripPrefix(pattern, http.FileServer(http.Dir(directory))))
+}