多数据库测试通过

bootstraps/bootstrap.go

@@ -1,403 +0,0 @@
-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() *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)
-// }
-
-// // 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
-// // 	}
-// // 	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 +0,0 @@
-package bootstraps
-
-// import (
-// 	"os"
-// 	"os/signal"
-// 	"syscall"
-// 	"time"
-
-// 	"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)
-
-// 	go func() {
-// 		<-signalCh
-// 		logger.Info("\n接收到关闭信号，正在优雅关闭...")
-
-// 		// 关闭数据库连接
-// 		if dbFactory != nil {
-// 			if err := dbFactory.Close(); err != nil {
-// 				logger.Error("关闭数据库错误: %v", err)
-// 			}
-// 			logger.Info("数据库连接已关闭")
-// 		}
-
-// 		// 执行其他清理函数
-// 		for _, cleanup := range cleanupFuncs {
-// 			cleanup()
-// 		}
-
-// 		// 等待日志写入完成
-// 		time.Sleep(100 * time.Millisecond)
-// 		os.Exit(0)
-// 	}()
-// }

config/config.go

@@ -20,7 +20,8 @@ const (
 // IConfig 主配置接口（更新支持多数据库）
 type IConfig interface {
 	// 多数据库支持
-	GetDatabaseConfig() *subconfigs.DatabaseConfig // 获取默认数据库（向后兼容）
+	GetDatabaseConfig() *subconfigs.DatabaseConfig               // 获取默认数据库（向后兼容）
+	GetDbsConfig(name string) (*subconfigs.DatabaseConfig, bool) // 获取指定数据库连接
 
 	//服务支持
 	GetServiceConfig() *subconfigs.ServiceConfig //获取默认微服务配置
@@ -67,6 +68,33 @@ func (c *Config) GetDatabaseConfig() *subconfigs.DatabaseConfig {
 	return nil
 }
 
+// GetDbsConfig 按名称获取数据库配置
+func (c *Config) GetDbsConfig(name string) (*subconfigs.DatabaseConfig, bool) {
+	// 获取 dbs 配置
+	dbsConfig := subconfigs.GetRegisteredConfig("dbs")
+	if dbsConfig == nil {
+		return nil, false
+	}
+
+	// 类型断言为 DbsConfig
+	dbs, ok := dbsConfig.(*subconfigs.DbsConfig)
+	if !ok {
+		return nil, false
+	}
+
+	// 按名称获取 DbConfig
+	dbConfig, exists := dbs.GetDbConfig(name)
+	if !exists || dbConfig == nil {
+		return nil, exists
+	}
+
+	// 将 DbConfig 转换为 DatabaseConfig
+	return &subconfigs.DatabaseConfig{
+		BaseConfig: subconfigs.BaseConfig{},
+		DbConfig:   *dbConfig,
+	}, true
+}
+
 func (c *Config) GetRedisConfig() *subconfigs.RedisConfig {
 	if config := subconfigs.GetRegisteredConfig("redis"); config != nil {
 		return config.(*subconfigs.RedisConfig)
@@ -185,13 +213,21 @@ func (c *Config) GetAppAuthToken() string {
 }
 
 // GetDatabaseConfig 包级便捷函数 - 按名称获取数据库配置
-func GetDatabaseConfig(name string) *subconfigs.DatabaseConfig {
+func GetDatabaseConfig() *subconfigs.DatabaseConfig {
 	if cfgInstance == nil {
 		return nil
 	}
 	return cfgInstance.GetDatabaseConfig()
 }
 
+// GetDbsConfig 包级便捷函数 - 按名称获取数据库配置
+func GetDbsConfig(name string) (*subconfigs.DatabaseConfig, bool) {
+	if cfgInstance == nil {
+		return nil, false
+	}
+	return cfgInstance.GetDbsConfig(name)
+}
+
 // GetRedis 包级便捷函数 - 获取Redis配置
 func GetRedisConfig() *subconfigs.RedisConfig {
 	if cfgInstance == nil {

config/subconfigs/database_common.go

@@ -0,0 +1,92 @@
+package subconfigs
+
+import (
+	"fmt"
+	"log"
+)
+
+// DbConfig 单个数据库配置（共享结构）
+type DbConfig struct {
+	Type            string `yaml:"type"`
+	Host            string `yaml:"host"`
+	Port            int    `yaml:"port"`
+	Username        string `yaml:"username"`
+	Password        string `yaml:"password"`
+	Database        string `yaml:"database"`
+	MaxOpenConns    int    `yaml:"max_open_conns"`
+	MaxIdleConns    int    `yaml:"max_idle_conns"`
+	ConnMaxLifetime int    `yaml:"conn_max_lifetime"`
+}
+
+// SetDbDefaults 设置数据库配置默认值
+func SetDbDefaults(c *DbConfig) {
+	if c.Type == "" {
+		c.Type = "mysql"
+	}
+	if c.Port == 0 {
+		c.Port = 3306
+	}
+	if c.MaxOpenConns == 0 {
+		c.MaxOpenConns = 100
+	}
+	if c.MaxIdleConns == 0 {
+		c.MaxIdleConns = 20
+	}
+	if c.ConnMaxLifetime == 0 {
+		c.ConnMaxLifetime = 3600
+	}
+}
+
+// ValidateDbConfig 验证数据库配置
+func ValidateDbConfig(c *DbConfig) error {
+	if c.Type == "" {
+		return fmt.Errorf("database type is required")
+	}
+	if c.Host == "" {
+		return fmt.Errorf("database host is required")
+	}
+	if c.Port <= 0 || c.Port > 65535 {
+		return fmt.Errorf("invalid database port: %d", c.Port)
+	}
+	if c.Database == "" {
+		return fmt.Errorf("database name is required")
+	}
+	return nil
+}
+
+// IsDbConfigured 判断数据库是否已配置
+func IsDbConfigured(c *DbConfig, name string) bool {
+	if c.Host == "" {
+		if name != "" {
+			log.Printf("⚠️  警告: 数据库 '%s' Host 未配置", name)
+		} else {
+			log.Println("⚠️  警告: 数据库 Host 未配置")
+		}
+		return false
+	}
+	if c.Port <= 0 {
+		if name != "" {
+			log.Printf("⚠️  警告: 数据库 '%s' Port 未配置或无效", name)
+		} else {
+			log.Println("⚠️  警告: 数据库 Port 未配置或无效")
+		}
+		return false
+	}
+	if c.Username == "" {
+		if name != "" {
+			log.Printf("⚠️  警告: 数据库 '%s' Username 未配置", name)
+		} else {
+			log.Println("⚠️  警告: 数据库 Username 未配置")
+		}
+		return false
+	}
+	if c.Database == "" {
+		if name != "" {
+			log.Printf("⚠️  警告: 数据库 '%s' 名称未配置", name)
+		} else {
+			log.Println("⚠️  警告: 数据库名称未配置")
+		}
+		return false
+	}
+	return true
+}

config/subconfigs/database_config.go

@@ -1,88 +1,27 @@
 package subconfigs
 
-import (
-	"fmt"
-	"log"
-)
-
-// DatabaseConfig 数据库配置
+// DatabaseConfig 单个数据库配置
 type DatabaseConfig struct {
 	BaseConfig
-	Type            string `yaml:"type"`
-	Host            string `yaml:"host"`
-	Port            int    `yaml:"port"`
-	Username        string `yaml:"username"`
-	Password        string `yaml:"password"`
-	Database        string `yaml:"database"`
-	MaxOpenConns    int    `yaml:"max_open_conns"`
-	MaxIdleConns    int    `yaml:"max_idle_conns"`
-	ConnMaxLifetime int    `yaml:"conn_max_lifetime"`
+	DbConfig `yaml:",inline"` // 嵌入共享的 DbConfig
 }
 
-// SetDefaults 设置默认值 - 实现 ConfigLoader 接口
 func (c *DatabaseConfig) SetDefaults() {
-	if c.Type == "" {
-		c.Type = "mysql"
-	}
-	if c.Port == 0 {
-		c.Port = 3306
-	}
-	if c.MaxOpenConns == 0 {
-		c.MaxOpenConns = 100
-	}
-	if c.MaxIdleConns == 0 {
-		c.MaxIdleConns = 20
-	}
-	if c.ConnMaxLifetime == 0 {
-		c.ConnMaxLifetime = 3600
-	}
+	SetDbDefaults(&c.DbConfig)
 }
 
-// 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 == "" {
-		return fmt.Errorf("database type is required")
-	}
-	if c.Host == "" {
-		return fmt.Errorf("database host is required")
-	}
-	if c.Port <= 0 || c.Port > 65535 {
-		return fmt.Errorf("invalid database port: %d", c.Port)
-	}
-	if c.Database == "" {
-		return fmt.Errorf("database name is required")
-	}
-	return nil
+	return ValidateDbConfig(&c.DbConfig)
 }
 
-// IsConfigured 判断是否已配置（数据库配置）
 func (c *DatabaseConfig) IsConfigured() bool {
-	if c.Host == "" {
-		log.Println("⚠️  警告: 数据库 Host 未配置")
-		return false
-	}
-	if c.Port <= 0 {
-		log.Println("⚠️  警告: 数据库 Port 未配置或无效")
-		return false
-	}
-	if c.Username == "" {
-		log.Println("⚠️  警告: 数据库 Username 未配置")
-		return false
-	}
-	if c.Database == "" {
-		log.Println("⚠️  警告: 数据库名称未配置")
-		return false
-	}
-	return true
+	return IsDbConfigured(&c.DbConfig, "")
 }
 
-// 自动注册
 func init() {
 	Register("database", &DatabaseConfig{})
 }

config/subconfigs/dbs_config.go

@@ -0,0 +1,69 @@
+package subconfigs
+
+import (
+	"fmt"
+	"log"
+)
+
+// DbsConfig 多数据库配置
+type DbsConfig struct {
+	BaseConfig
+	Databases map[string]*DbConfig `yaml:",inline"`
+}
+
+func (c *DbsConfig) SetDefaults() {
+	for _, db := range c.Databases {
+		SetDbDefaults(db)
+	}
+}
+
+func (c *DbsConfig) Load(data map[string]interface{}) error {
+	// 直接使用 LoadFromYAML，会自动处理嵌套的 map[string]*DbConfig
+	return c.LoadFromYAML(data, c)
+}
+
+func (c *DbsConfig) Validate() error {
+	if len(c.Databases) == 0 {
+		return fmt.Errorf("未配置任何数据库")
+	}
+
+	for name, db := range c.Databases {
+		if err := ValidateDbConfig(db); err != nil {
+			return fmt.Errorf("数据库 '%s' 配置错误: %v", name, err)
+		}
+	}
+	return nil
+}
+
+func (c *DbsConfig) IsConfigured() bool {
+	if len(c.Databases) == 0 {
+		log.Println("⚠️  警告: 未配置任何数据库")
+		return false
+	}
+
+	allConfigured := true
+	for name, db := range c.Databases {
+		if !IsDbConfigured(db, name) {
+			allConfigured = false
+		}
+	}
+	return allConfigured
+}
+
+// Get 获取指定名称的数据库配置
+func (c *DbsConfig) GetDbConfig(name string) (*DbConfig, bool) {
+	db, exists := c.Databases[name]
+	return db, exists
+}
+
+// Default 获取第一个数据库配置
+func (c *DbsConfig) Default() *DbConfig {
+	for _, db := range c.Databases {
+		return db
+	}
+	return nil
+}
+
+func init() {
+	Register("dbs", &DbsConfig{})
+}

ctx/RequestContext.go

@@ -40,3 +40,14 @@ func GetContext(r *http.Request) *RequestContext {
 
 	return &RequestContext{}
 }
+
+func GetContextTest() *RequestContext {
+
+	return &RequestContext{
+		TraceID:      "test-TTraceID",
+		TenantID:     "test-TenantID",
+		ServiceName:  "test-ServiceName",
+		InstanceName: "test-InstanceName",
+		UserID:       "test-UserID",
+	}
+}

model/bson/bson_model.go

@@ -27,7 +27,7 @@ type BsonStringModel = bsonModel[string]
 type BsonObjectModel = bsonModel[primitive.ObjectID]
 
 // 创建新的 String 模型（自动生成ID）
-func NewStringIDModel(ctx ctx.RequestContext) BsonStringModel {
+func NewStringIDModel(ctx *ctx.RequestContext) BsonStringModel {
 	return BsonStringModel{
 		ID:        primitive.NewObjectID().Hex(),
 		TenantId:  ctx.TenantID,
@@ -39,7 +39,7 @@ func NewStringIDModel(ctx ctx.RequestContext) BsonStringModel {
 }
 
 // 创建新的 String 模型（自定义ID）
-func NewStringIDModelWithID(ctx ctx.RequestContext, id string) BsonStringModel {
+func NewStringIDModelWithID(ctx *ctx.RequestContext, id string) BsonStringModel {
 	return BsonStringModel{
 		ID:        id,
 		TenantId:  ctx.TenantID,
@@ -51,7 +51,7 @@ func NewStringIDModelWithID(ctx ctx.RequestContext, id string) BsonStringModel {
 }
 
 // 创建新的 ObjectID 模型（自动生成ID）
-func NewObjectIDModel(ctx ctx.RequestContext) BsonObjectModel {
+func NewObjectIDModel(ctx *ctx.RequestContext) BsonObjectModel {
 	return BsonObjectModel{
 		ID:        primitive.NewObjectID(),
 		TenantId:  ctx.TenantID,
@@ -63,7 +63,7 @@ func NewObjectIDModel(ctx ctx.RequestContext) BsonObjectModel {
 }
 
 // 用于更新操作的模型（只设置更新信息）
-func ModelForUpdate(ctx ctx.RequestContext) BsonStringModel {
+func ModelForUpdate(ctx *ctx.RequestContext) BsonStringModel {
 	return BsonStringModel{
 		UpdatedAt: time.Now(),
 		UpdatedBy: ctx.UserID,

util/create_error_result.go

@@ -11,25 +11,25 @@ import (
 //	CreateErrorResult 创建错误结果的泛型辅助函数
 //
 // T 是 QueryResult 中 Data 字段的类型
-func CreateErrorResult[T any](errorMsg string, startTime time.Time, reqCtx *ctx.RequestContext) *response.QueryResult[T] {
+func CreateErrorResult[T any](errorMsg string, reqCtx *ctx.RequestContext) *response.QueryResult[T] {
 	// 使用 *new(T) 获取 T 类型的零值指针
 	var zeroValue T
-	return createResult(zeroValue, false, errorMsg, startTime, reqCtx)
+	return createResult(zeroValue, false, errorMsg, reqCtx)
 }
 
 // CreateSuccessResult 建立返回成功对象
 //
 //	T 是 QueryResult 中 Data 字段的类型
-func CreateSuccessResultData[T any](data T, startTime time.Time, reqCtx *ctx.RequestContext) *response.QueryResult[T] {
-	return createResult(data, true, "", startTime, reqCtx)
+func CreateSuccessResultData[T any](data T, reqCtx *ctx.RequestContext) *response.QueryResult[T] {
+	return createResult(data, true, "", reqCtx)
 }
 
-func CreateSuccessResult[T any](startTime time.Time, reqCtx *ctx.RequestContext) *response.QueryResult[T] {
+func CreateSuccessResult[T any](reqCtx *ctx.RequestContext) *response.QueryResult[T] {
 	var zeroValue T
-	return createResult(zeroValue, true, "", startTime, reqCtx)
+	return createResult(zeroValue, true, "", reqCtx)
 }
 
-func createResult[T any](data T, success bool, msg string, startTime time.Time, reqCtx *ctx.RequestContext) *response.QueryResult[T] {
+func createResult[T any](data T, success bool, msg string, reqCtx *ctx.RequestContext) *response.QueryResult[T] {
 	if success {
 		logger.DebugC(reqCtx, msg)
 	} else {
@@ -39,7 +39,7 @@ func createResult[T any](data T, success bool, msg string, startTime time.Time,
 	return &response.QueryResult[T]{
 		Success:  success,
 		Error:    msg,
-		Time:     time.Since(startTime).String(),
+		Time:     time.Now().String(),
 		Metadata: reqCtx,
 		Data:     data,
 	}

webx/router/router_service.go

@@ -333,6 +333,13 @@ func (ha *handlerAdapter) handleResponse(w http.ResponseWriter, results []reflec
 		return
 	}
 
+	// 检查是否是 []byte 类型
+	if bytes, ok := data.([]byte); ok {
+		// 如果是 []byte，直接写入响应，不进行 JSON 编码
+		w.Write(bytes)
+		return
+	}
+
 	// 返回JSON响应
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(data)