Release v0.1.1220

dbstart/db_bootstrapper.go

 	"log"
 
 	"git.x2erp.com/qdy/go-base/config"
+	"git.x2erp.com/qdy/go-base/logger"
 	"git.x2erp.com/qdy/go-db/factory/database"
 )
 
 // DBBootstrapper 数据库启动器
 type DBBootstrapper struct {
-	DBFactory *database.DBFactory
-	cfg       config.IConfig
+	DBFactories map[string]*database.DBFactory // 改为map存储多个数据库实例
+	cfg         config.IConfig
 }
 
 // NewDBBootstrapper 创建数据库启动器
 func NewDBBootstrapper(cfg config.IConfig) *DBBootstrapper {
 	return &DBBootstrapper{
-		cfg: cfg,
+		DBFactories: make(map[string]*database.DBFactory),
+		cfg:         cfg,
 	}
 }
 
-// Init 初始化数据库
+// Init 初始化默认数据库
 func (db *DBBootstrapper) Init() *DBBootstrapper {
 	if db.cfg == nil {
 		log.Fatal("配置未初始化，请先传入配置")
 	}
 
+	// 初始化默认数据库
 	dbCfg := db.cfg.GetDatabase()
+	if dbCfg == nil {
+		log.Fatal("默认数据库配置未找到")
+	}
 
-	log.Printf("正在连接数据库: %s:%d/%s",
+	log.Printf("正在连接默认数据库: %s:%d/%s",
 		dbCfg.Host, dbCfg.Port, dbCfg.Database)
 
-	dbFactory, err := database.GetDBFactory()
+	dbFactory, err := database.GetDefaultDBFactory()
 	if err != nil {
-		log.Fatalf("数据库连接失败: %v", err)
+		log.Fatalf("默认数据库连接失败: %v", err)
 	}
 
-	db.DBFactory = dbFactory
-	log.Println("数据库连接成功")
+	db.DBFactories["default"] = dbFactory
+	log.Println("默认数据库连接成功")
 
 	return db
 }
 
-// Close 关闭数据库连接
+// GetDBFactory 获取数据库工厂
+func (db *DBBootstrapper) GetDBFactory(dbName string) *database.DBFactory {
+	// 如果已经初始化，直接返回
+	if factory, exists := db.DBFactories[dbName]; exists {
+		return factory
+	}
+
+	// 如果还没初始化，按需初始化
+	dbFactory, err := database.GetDBFactory(dbName)
+	if err != nil {
+		log.Printf("❌ 获取数据库 '%s' 失败: %v", dbName, err)
+		return nil
+	}
+
+	db.DBFactories[dbName] = dbFactory
+	return dbFactory
+}
+
+// GetDefaultDBFactory 获取默认数据库工厂
+func (db *DBBootstrapper) GetDefaultDBFactory() *database.DBFactory {
+	return db.GetDBFactory("default")
+}
+
+// Close 关闭所有数据库连接
 func (db *DBBootstrapper) Close() {
-	if db.DBFactory != nil {
-		db.DBFactory.Close()
-		log.Println("数据库连接已关闭")
+
+	for name, factory := range db.DBFactories {
+		logger.Info("正在关闭数据库: %s, factory: %v", name, factory)
+		if factory != nil {
+			factory.Close()
+			logger.Info("数据库 '%s' 连接已关闭", name)
+		} else {
+			logger.Error("⚠️  警告: 数据库 '%s' 的 factory 为 nil", name)
+		}
 	}
+
+	// 清空map
+	db.DBFactories = make(map[string]*database.DBFactory)
+	logger.Info("所有数据库连接已关闭.")
 }
 
-// GetDBFactory 获取数据库工厂
-func (db *DBBootstrapper) GetDBFactory() *database.DBFactory {
-	return db.DBFactory
+// 在 dbstart 包中
+func (db *DBBootstrapper) OnShutdown() {
+	db.Close()
 }

factory/database/db_factory.go

 )
 
 type DBFactory struct {
-	db *sqlx.DB
+	db   *sqlx.DB
+	name string // 记录数据库配置名称
 }
 
 var (
-	instanceDBFactory *DBFactory
-	once              sync.Once
+	// 多实例存储：配置名称 -> DBFactory 实例
+	instances = make(map[string]*DBFactory)
+	// 每个配置名称对应的once，确保线程安全
+	onceMap = make(map[string]*sync.Once)
+	// 保护instances和onceMap的读写锁
+	instancesMutex sync.RWMutex
 )
 
-// GetDBFactory 创建数据库工厂单例
-func GetDBFactory() (*DBFactory, error) {
+// GetDBFactory 获取指定名称的数据库工厂单例
+func GetDBFactory(dbName string) (*DBFactory, error) {
+	// 获取或创建该名称的once对象
+	instancesMutex.Lock()
+	once, exists := onceMap[dbName]
+	if !exists {
+		once = &sync.Once{}
+		onceMap[dbName] = once
+	}
+	instancesMutex.Unlock()
+
 	var initErr error
-	var msg = "DBFactory instance retrieved from memory.\n"
+	var instance *DBFactory
+	var msg = fmt.Sprintf("DBFactory '%s' instance retrieved from memory.\n", dbName)
 
 	once.Do(func() {
 		// 使用配置单例
 		cfg, err := config.GetConfig()
-
-		// 检查配置初始化是否有错误
 		if err != nil {
 			initErr = fmt.Errorf("failed to load config: %v", err)
 			return
 		}
 
-		// 检查数据库配置是否完整
-		if !cfg.IsDatabaseConfigured() {
-			initErr = fmt.Errorf("database configuration is incomplete")
+		// 获取指定名称的数据库配置
+		dbConfig := cfg.GetDatabaseConfig(dbName)
+		if dbConfig == nil {
+			initErr = fmt.Errorf("database configuration '%s' not found", dbName)
 			return
 		}
 
-		// 显示所支持的数据库驱动
-		//driversStr := drivers.GetAllDrivers()
+		// // 检查数据库配置是否完整
+		// if !dbConfig.IsConfigured() {
+		// 	initErr = fmt.Errorf("database configuration '%s' is incomplete", dbName)
+		// 	return
+		// }
 
-		dbConfig := cfg.GetDatabase()
+		// 获取数据库类型
 		dbType := dbConfig.Type
-		log.Printf("Available database drivers: %v\n", dbType)
+		log.Printf("Creating database connection for '%s' with type: %s\n", dbName, dbType)
+
 		// 获取对应的驱动
 		dbDriver, err := drivers.Get(dbType)
 		if err != nil {
 		// 创建数据库连接
 		db, err := dbDriver.Open(driverConfig)
 		if err != nil {
-			initErr = fmt.Errorf("failed to open database connection: %v", err)
+			initErr = fmt.Errorf("failed to open database connection for '%s': %v", dbName, err)
 			return
 		}
 
 		// 测试连接
 		if err := functions.TestConnection(db, dbType); err != nil {
 			db.Close()
-			initErr = fmt.Errorf("database connection test failed: %v", err)
+			initErr = fmt.Errorf("database connection test failed for '%s': %v", dbName, err)
 			return
 		}
 
-		msg = "DBFactory is successfully created.\n"
-		instanceDBFactory = &DBFactory{db: db}
+		msg = fmt.Sprintf("DBFactory '%s' is successfully created.\n", dbName)
+		instance = &DBFactory{
+			db:   db,
+			name: dbName,
+		}
+
+		// 保存实例到map
+		instancesMutex.Lock()
+		instances[dbName] = instance
+		instancesMutex.Unlock()
 	})
 
 	if initErr != nil {
 
 	log.Print(msg)
 
-	return instanceDBFactory, nil
+	// 从map中获取实例
+	instancesMutex.RLock()
+	instance = instances[dbName]
+	instancesMutex.RUnlock()
+
+	return instance, nil
+}
+
+// GetDefaultDBFactory 获取默认数据库工厂（向后兼容）
+func GetDefaultDBFactory() (*DBFactory, error) {
+	return GetDBFactory("default")
+}
+
+// GetAllDBFactories 获取所有已创建的数据库工厂实例
+func GetAllDBFactories() map[string]*DBFactory {
+	instancesMutex.RLock()
+	defer instancesMutex.RUnlock()
+
+	// 创建副本，避免外部修改
+	result := make(map[string]*DBFactory)
+	for k, v := range instances {
+		result[k] = v
+	}
+	return result
 }
 
+// GetDBFactoryNames 获取所有可用的数据库配置名称
+func GetDBFactoryNames() []string {
+	cfg, err := config.GetConfig()
+	if err != nil {
+		return []string{}
+	}
+
+	dbs := cfg.GetDatabases()
+	if dbs == nil {
+		return []string{}
+	}
+
+	return dbs.GetAllDatabaseNames()
+}
+
+// CloseInstance 关闭指定名称的数据库连接
+func CloseInstance(dbName string) error {
+	instancesMutex.Lock()
+	defer instancesMutex.Unlock()
+
+	if instance, exists := instances[dbName]; exists {
+		err := instance.Close()
+		delete(instances, dbName)
+		delete(onceMap, dbName)
+		return err
+	}
+
+	return fmt.Errorf("database instance '%s' not found", dbName)
+}
+
+// CloseAll 关闭所有数据库连接
+func CloseAll() {
+	instancesMutex.Lock()
+	defer instancesMutex.Unlock()
+
+	for name, instance := range instances {
+		if err := instance.Close(); err != nil {
+			log.Printf("Error closing database instance '%s': %v\n", name, err)
+		}
+		delete(instances, name)
+		delete(onceMap, name)
+	}
+
+	// 重新初始化maps
+	instances = make(map[string]*DBFactory)
+	onceMap = make(map[string]*sync.Once)
+
+	log.Println("All database connections closed gracefully")
+}
+
+// ========== DBFactory 实例方法 ==========
+
 // GetDB 获取数据库连接（线程安全）
 func (f *DBFactory) GetDB() interface{} {
 	return f.db
 	if f.db != nil {
 		err := f.db.Close()
 		f.db = nil
-		log.Println("Database connection closed gracefully")
+		log.Printf("Database connection '%s' closed gracefully\n", f.name)
 		return err
 	}
 	return nil
 
 // GetDBType 得到当前使用数据库类型
 func (f *DBFactory) GetDBType() string {
-	dbConfig := config.GetDatabase()
+	// 通过配置获取当前数据库的类型
+	cfg, err := config.GetConfig()
+	if err != nil {
+		return ""
+	}
+
+	dbConfig := cfg.GetDatabaseConfig(f.name)
+	if dbConfig == nil {
+		return ""
+	}
+
 	return dbConfig.Type
 }
 
+// GetDBName 获取数据库配置名称
+func (f *DBFactory) GetDBName() string {
+	return f.name
+}
+
 // QueryToJSON 快捷查询，直接返回 JSON 字节流
 func (f *DBFactory) QueryToJSON(sql string, reqCtx *ctx.RequestContext) *types.QueryResult[[]map[string]interface{}] {
 	return functions.QueryToJSON(f.db, sql, reqCtx)
 
 // QueryParamsToJSON 位置参数查询并返回 JSON 字节数据
 func (f *DBFactory) QueryPositionalToJSON(sql string, params []interface{}, reqCtx *ctx.RequestContext) *types.QueryResult[[]map[string]interface{}] {
-
 	return functions.QueryPositionalToJSON(f.db, sql, params, reqCtx)
 }
 
 // QueryParamsNameToJSON 命名参数查询并返回 JSON 字节数据
 // params 可以是 map[string]interface{} 或结构体
 func (f *DBFactory) QueryParamsNameToJSON(sql string, params map[string]interface{}, reqCtx *ctx.RequestContext) *types.QueryResult[[]map[string]interface{}] {
-
 	return functions.QueryParamsNameToJSON(f.db, sql, params, reqCtx)
 }
 
 
 // QueryParamsToCSV 位置参数查询并返回 CSV 字节数据
 func (f *DBFactory) QueryPositionalToCSV(sql string, writerHeader bool, params []interface{}, reqCtx *ctx.RequestContext) ([]byte, error) {
-
 	return functions.QueryPositionalToCSV(f.db, sql, writerHeader, params, reqCtx)
 }
 
 // QueryParamsNameToCSV 命名参数查询并返回 CSV 字节数据
 // params 可以是 map[string]interface{} 或结构体
 func (f *DBFactory) QueryParamsNameToCSV(sql string, writerHeader bool, params map[string]interface{}, reqCtx *ctx.RequestContext) ([]byte, error) {
-
 	return functions.QueryParamsNameToCSV(f.db, sql, writerHeader, params, reqCtx)
 }
 

test.go

 
 	// 创建数据库工厂
 	fmt.Printf("第1次.\n")
-	dbFactory, err := database.GetDBFactory()
+	dbFactory, err := database.GetDefaultDBFactory()
 
 	if err != nil {
 		log.Fatalf("Failed to create DB factory: %v", err)
 
 	//测试单例是否生效
 	fmt.Printf("第2次.\n")
-	dbFactory1, err1 := database.GetDBFactory()
+	dbFactory1, err1 := database.GetDefaultDBFactory()
 
 	if err1 != nil {
 		log.Fatalf("Failed to create DB factory: %v", err1)