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

dbstart/db_bootstrapper.go

@@ -1,95 +1,95 @@
 package dbstart
 
-import (
-	"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 {
-	DBFactories map[string]*database.DBFactory // 改为map存储多个数据库实例
-	cfg         config.IConfig
-}
-
-// NewDBBootstrapper 创建数据库启动器
-func NewDBBootstrapper(cfg config.IConfig) *DBBootstrapper {
-	return &DBBootstrapper{
-		DBFactories: make(map[string]*database.DBFactory),
-		cfg:         cfg,
-	}
-}
-
-// 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",
-		dbCfg.Host, dbCfg.Port, dbCfg.Database)
-
-	dbFactory, err := database.GetDefaultDBFactory()
-	if err != nil {
-		log.Fatalf("默认数据库连接失败: %v", err)
-	}
-
-	db.DBFactories["default"] = dbFactory
-	log.Println("默认数据库连接成功")
-
-	return db
-}
-
-// 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() {
-
-	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("所有数据库连接已关闭.")
-}
-
-// 在 dbstart 包中
-func (db *DBBootstrapper) OnShutdown() {
-	db.Close()
-}
+// import (
+// 	"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 {
+// 	DBFactories map[string]*database.DBFactory // 改为map存储多个数据库实例
+// 	cfg         config.IConfig
+// }
+
+// // NewDBBootstrapper 创建数据库启动器
+// func NewDBBootstrapper(cfg config.IConfig) *DBBootstrapper {
+// 	return &DBBootstrapper{
+// 		DBFactories: make(map[string]*database.DBFactory),
+// 		cfg:         cfg,
+// 	}
+// }
+
+// // Init 初始化默认数据库
+// func (db *DBBootstrapper) Init() *DBBootstrapper {
+// 	if db.cfg == nil {
+// 		log.Fatal("配置未初始化，请先传入配置")
+// 	}
+
+// 	// // 初始化默认数据库
+// 	// dbCfg := db.cfg.GetDatabaseConfig()
+// 	// if dbCfg == nil {
+// 	// 	log.Fatal("默认数据库配置未找到")
+// 	// }
+
+// 	// log.Printf("正在连接默认数据库: %s:%d/%s",
+// 	// 	dbCfg.Host, dbCfg.Port, dbCfg.Database)
+
+// 	dbFactory, err := database.GetDefaultDBFactory()
+// 	if err != nil {
+// 		log.Fatalf("默认数据库连接失败: %v", err)
+// 	}
+
+// 	db.DBFactories["default"] = dbFactory
+// 	log.Println("默认数据库连接成功")
+
+// 	return db
+// }
+
+// // 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() {
+
+// 	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("所有数据库连接已关闭.")
+// }
+
+// // 在 dbstart 包中
+// func (db *DBBootstrapper) OnShutdown() {
+// 	db.Close()
+// }

factory/database/db_factory.go

@@ -6,7 +6,9 @@ import (
 	"sync"
 
 	"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"
 	"git.x2erp.com/qdy/go-base/types"
 	"git.x2erp.com/qdy/go-db/drivers"
 	"git.x2erp.com/qdy/go-db/functions"
@@ -14,239 +16,149 @@ import (
 	"github.com/jmoiron/sqlx"
 )
 
+// DBFactory 数据库工厂（全局单例模式）
 type DBFactory struct {
-	db   *sqlx.DB
-	name string // 记录数据库配置名称
+	db     *sqlx.DB
+	config *subconfigs.DatabaseConfig
 }
 
 var (
-	// 多实例存储：配置名称 -> DBFactory 实例
-	instances = make(map[string]*DBFactory)
-	// 每个配置名称对应的once，确保线程安全
-	onceMap = make(map[string]*sync.Once)
-	// 保护instances和onceMap的读写锁
-	instancesMutex sync.RWMutex
+	instanceDB     *DBFactory
+	instanceDBOnce sync.Once
+	initErrDB      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()
+// CreateDBFactory 获取数据库工厂单例
+func CreateDBFactory(cfg config.IConfig) *DBFactory {
+	config := cfg.GetDatabaseConfig()
+	instanceDBOnce.Do(func() {
 
-	var initErr error
-	var instance *DBFactory
-	var msg = fmt.Sprintf("DBFactory '%s' instance retrieved from memory.\n", dbName)
+		if config == nil {
+			log.Fatal("配置未初始化，请先在yaml进行配置")
+		}
 
-	once.Do(func() {
-		// 使用配置单例
-		cfg, err := config.GetConfig()
-		if err != nil {
-			initErr = fmt.Errorf("failed to load config: %v", err)
-			return
+		// 设置默认值
+		if config.MaxOpenConns == 0 {
+			config.MaxOpenConns = 100
+		}
+		if config.MaxIdleConns == 0 {
+			config.MaxIdleConns = 10
+		}
+		if config.ConnMaxLifetime == 0 {
+			config.ConnMaxLifetime = 5 * 60 // 5分钟，单位秒
 		}
 
-		// 获取指定名称的数据库配置
-		dbConfig := cfg.GetDatabaseConfig(dbName)
-		if dbConfig == nil {
-			initErr = fmt.Errorf("database configuration '%s' not found", dbName)
+		// 验证配置
+		if config.Type == "" {
+			initErrDB = fmt.Errorf("database type must be configured")
+			return
+		}
+		if config.Host == "" {
+			initErrDB = fmt.Errorf("database host must be configured")
+			return
+		}
+		if config.Database == "" {
+			initErrDB = fmt.Errorf("database name must be configured")
 			return
 		}
 
-		// // 检查数据库配置是否完整
-		// if !dbConfig.IsConfigured() {
-		// 	initErr = fmt.Errorf("database configuration '%s' is incomplete", dbName)
-		// 	return
-		// }
-
-		// 获取数据库类型
-		dbType := dbConfig.Type
-		log.Printf("Creating database connection for '%s' with type: %s\n", dbName, dbType)
+		log.Printf("Creating database connection...")
 
 		// 获取对应的驱动
-		dbDriver, err := drivers.Get(dbType)
+		dbDriver, err := drivers.Get(config.Type)
 		if err != nil {
-			initErr = fmt.Errorf("failed to get database driver: %v", err)
+			initErrDB = fmt.Errorf("failed to get database driver: %v", err)
 			return
 		}
 
 		// 将内部 DBConfig 转换为 drivers.DBConfig
 		driverConfig := drivers.DBConfig{
-			Type:            dbConfig.Type,
-			Host:            dbConfig.Host,
-			Port:            dbConfig.Port,
-			Username:        dbConfig.Username,
-			Password:        dbConfig.Password,
-			Database:        dbConfig.Database,
-			MaxOpenConns:    dbConfig.MaxOpenConns,
-			MaxIdleConns:    dbConfig.MaxIdleConns,
-			ConnMaxLifetime: dbConfig.ConnMaxLifetime,
+			Type:            config.Type,
+			Host:            config.Host,
+			Port:            config.Port,
+			Username:        config.Username,
+			Password:        config.Password,
+			Database:        config.Database,
+			MaxOpenConns:    config.MaxOpenConns,
+			MaxIdleConns:    config.MaxIdleConns,
+			ConnMaxLifetime: config.ConnMaxLifetime,
 		}
 
 		// 创建数据库连接
 		db, err := dbDriver.Open(driverConfig)
 		if err != nil {
-			initErr = fmt.Errorf("failed to open database connection for '%s': %v", dbName, err)
+			initErrDB = fmt.Errorf("failed to open database connection: %v", err)
 			return
 		}
 
 		// 测试连接
-		if err := functions.TestConnection(db, dbType); err != nil {
+		if err := functions.TestConnection(db, config.Type); err != nil {
 			db.Close()
-			initErr = fmt.Errorf("database connection test failed for '%s': %v", dbName, err)
+			initErrDB = fmt.Errorf("database connection test failed: %v", err)
 			return
 		}
 
-		msg = fmt.Sprintf("DBFactory '%s' is successfully created.\n", dbName)
-		instance = &DBFactory{
-			db:   db,
-			name: dbName,
-		}
+		log.Printf("DBFactory is successfully created.\n")
 
-		// 保存实例到map
-		instancesMutex.Lock()
-		instances[dbName] = instance
-		instancesMutex.Unlock()
+		instanceDB = &DBFactory{
+			db:     db,
+			config: config,
+		}
 	})
 
-	if initErr != nil {
-		return nil, initErr
+	if initErrDB != nil {
+		log.Fatalf("DBFactory is error: '%v'", initErrDB)
 	}
 
-	log.Print(msg)
-
-	// 从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")
+	return instanceDB
 }
 
 // ========== DBFactory 实例方法 ==========
 
-// GetDB 获取数据库连接（线程安全）
-func (f *DBFactory) GetDB() interface{} {
+// GetDB 获取数据库连接
+func (f *DBFactory) GetDB() *sqlx.DB {
 	return f.db
 }
 
+func (f *DBFactory) GetName() string {
+	return "DBFactory"
+}
+
 // Close 关闭数据库连接
-func (f *DBFactory) Close() error {
+func (f *DBFactory) Close() {
 	if f.db != nil {
 		err := f.db.Close()
+		if err != nil {
+			logger.Errorf("failed to close database connection: %v", err)
+		}
+		log.Printf("Database connection closed gracefully\n")
 		f.db = nil
-		log.Printf("Database connection '%s' closed gracefully\n", f.name)
-		return err
 	}
-	return nil
 }
 
-// GetDBType 得到当前使用数据库类型
-func (f *DBFactory) GetDBType() string {
-	// 通过配置获取当前数据库的类型
-	cfg, err := config.GetConfig()
-	if err != nil {
-		return ""
-	}
-
-	dbConfig := cfg.GetDatabaseConfig(f.name)
-	if dbConfig == nil {
-		return ""
-	}
-
-	return dbConfig.Type
+// GetConfig 获取配置信息
+func (f *DBFactory) GetConfig() subconfigs.DatabaseConfig {
+	return *f.config
 }
 
-// GetDBName 获取数据库配置名称
-func (f *DBFactory) GetDBName() string {
-	return f.name
+// TestConnection 测试连接
+func (f *DBFactory) TestConnection() error {
+	return functions.TestConnection(f.db, f.config.Type)
 }
 
+// ========== 快捷操作方法 ==========
+
 // 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 字节数据
+// QueryPositionalToJSON 位置参数查询并返回 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)
 }
@@ -256,13 +168,12 @@ func (f *DBFactory) QueryToCSV(sql string, writerHeader bool, reqCtx *ctx.Reques
 	return functions.QueryToCSV(f.db, sql, writerHeader, reqCtx)
 }
 
-// QueryParamsToCSV 位置参数查询并返回 CSV 字节数据
+// QueryPositionalToCSV 位置参数查询并返回 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)
 }
@@ -282,11 +193,134 @@ func (f *DBFactory) ExecuteMultipleDDL(ddlSQLs []string) error {
 	return functions.ExecuteMultipleDDL(f.db, ddlSQLs)
 }
 
+// GetDBType 得到当前使用数据库类型
+func (f *DBFactory) GetDBType() string {
+	return f.config.Type
+}
+
+// GetDatabaseName 获取数据库名称
+func (f *DBFactory) GetDatabaseName() string {
+	return f.config.Database
+}
+
+// GetHost 获取数据库主机
+func (f *DBFactory) GetHost() string {
+	return f.config.Host
+}
+
+// GetPort 获取数据库端口
+func (f *DBFactory) GetPort() int {
+	return f.config.Port
+}
+
+// BeginTx 开始事务
+func (f *DBFactory) BeginTx() (*sqlx.Tx, error) {
+	return f.db.Beginx()
+}
+
+// GetStats 获取数据库连接统计信息
+func (f *DBFactory) GetStats() interface{} {
+	return f.db.Stats()
+}
+
+// Ping 测试数据库连接是否正常
+func (f *DBFactory) Ping() error {
+	return f.db.Ping()
+}
+
 // GetAvailableDrivers 获取可用的数据库驱动
 func (f *DBFactory) GetAvailableDrivers() []string {
 	return drivers.GetAllDrivers()
 }
 
-func (f *DBFactory) TestConnection(dbType string) error {
-	return functions.TestConnection(f.db, dbType)
+// ========== 新增的简化操作方法 ==========
+
+// QueryOne 查询单条记录
+func (f *DBFactory) QueryOne(sql string, dest interface{}) error {
+	return f.db.Get(dest, sql)
+}
+
+// QueryOneWithParams 带参数查询单条记录
+func (f *DBFactory) QueryOneWithParams(sql string, dest interface{}, params ...interface{}) error {
+	return f.db.Get(dest, sql, params...)
+}
+
+// QueryMany 查询多条记录
+func (f *DBFactory) QueryMany(sql string, dest interface{}) error {
+	return f.db.Select(dest, sql)
+}
+
+// QueryManyWithParams 带参数查询多条记录
+func (f *DBFactory) QueryManyWithParams(sql string, dest interface{}, params ...interface{}) error {
+	return f.db.Select(dest, sql, params...)
+}
+
+// Execute 执行更新操作
+func (f *DBFactory) Execute(sql string) (int64, error) {
+	result, err := f.db.Exec(sql)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected()
+}
+
+// ExecuteWithParams 带参数执行更新操作
+func (f *DBFactory) ExecuteWithParams(sql string, params ...interface{}) (int64, error) {
+	result, err := f.db.Exec(sql, params...)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected()
+}
+
+// QueryMap 查询单条记录到map
+func (f *DBFactory) QueryMap(sql string) (map[string]interface{}, error) {
+	result := make(map[string]interface{})
+	err := f.db.QueryRowx(sql).MapScan(result)
+	return result, err
+}
+
+// QueryMapWithParams 带参数查询单条记录到map
+func (f *DBFactory) QueryMapWithParams(sql string, params ...interface{}) (map[string]interface{}, error) {
+	result := make(map[string]interface{})
+	err := f.db.QueryRowx(sql, params...).MapScan(result)
+	return result, err
+}
+
+// QuerySliceMap 查询多条记录到map切片
+func (f *DBFactory) QuerySliceMap(sql string) ([]map[string]interface{}, error) {
+	rows, err := f.db.Queryx(sql)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var results []map[string]interface{}
+	for rows.Next() {
+		result := make(map[string]interface{})
+		if err := rows.MapScan(result); err != nil {
+			return nil, err
+		}
+		results = append(results, result)
+	}
+	return results, nil
+}
+
+// QuerySliceMapWithParams 带参数查询多条记录到map切片
+func (f *DBFactory) QuerySliceMapWithParams(sql string, params ...interface{}) ([]map[string]interface{}, error) {
+	rows, err := f.db.Queryx(sql, params...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var results []map[string]interface{}
+	for rows.Next() {
+		result := make(map[string]interface{})
+		if err := rows.MapScan(result); err != nil {
+			return nil, err
+		}
+		results = append(results, result)
+	}
+	return results, nil
 }

factory/doris/doris_factory.go

@@ -25,20 +25,15 @@ type DorisFactory struct {
 }
 
 var (
-	instance     *DorisFactory
-	instanceOnce sync.Once
+	instanceDoris     *DorisFactory
+	instanceDorisOnce sync.Once
 )
 
 // GetDorisFactory 获取Doris工厂单例
 func GetDorisFactory(httpFactory *http.HTTPFactory) (*DorisFactory, error) {
 	var initErr error
-	instanceOnce.Do(func() {
-		cfg, err := config.GetConfig()
-
-		if err != nil {
-			initErr = fmt.Errorf("failed to load config: %v", err)
-			return
-		}
+	instanceDorisOnce.Do(func() {
+		cfg := config.GetConfig()
 
 		if !cfg.IsDorisConfigured() {
 			initErr = fmt.Errorf("doris configuration is incomplete")
@@ -46,7 +41,7 @@ func GetDorisFactory(httpFactory *http.HTTPFactory) (*DorisFactory, error) {
 		}
 
 		dorisConfig := cfg.GetDorisConfig()
-		instance = &DorisFactory{
+		instanceDoris = &DorisFactory{
 			client:   httpFactory.GetUnderlyingClient(),
 			FEHost:   dorisConfig.FEHost,
 			FEPort:   dorisConfig.FEPort,
@@ -61,7 +56,7 @@ func GetDorisFactory(httpFactory *http.HTTPFactory) (*DorisFactory, error) {
 		return nil, initErr
 	}
 
-	return instance, nil
+	return instanceDoris, nil
 }
 
 // InsertCSV 插入CSV数据到Doris

factory/http/http_factory.go

@@ -2,7 +2,6 @@ package http
 
 import (
 	"encoding/base64"
-	"fmt"
 	"net/http"
 	"sync"
 	"time"
@@ -31,14 +30,9 @@ var (
 // GetHTTPFactory 获取HTTP工厂单例实例
 func GetHTTPFactory() (*HTTPFactory, error) {
 	httpFactoryOnce.Do(func() {
-		cfg, err := config.GetConfig()
+		cfg := config.GetConfig()
 
-		if err != nil {
-			httpFactoryInitErr = fmt.Errorf("failed to load config: %v", err)
-			return
-		}
-
-		httpConfig := cfg.GetHTTP()
+		httpConfig := cfg.GetHTTPConfig()
 
 		// 创建共享的resty客户端（线程安全）
 		client := resty.New()

factory/mongodb/mongodb_factory.go

@@ -0,0 +1,591 @@
+package mongodb
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"log"
+	"sync"
+	"time"
+
+	"git.x2erp.com/qdy/go-base/config/subconfigs"
+	"git.x2erp.com/qdy/go-base/logger"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"go.mongodb.org/mongo-driver/mongo/readpref"
+)
+
+// MongoDBFactory MongoDB工厂（全局单例模式）
+type MongoDBFactory struct {
+	client *mongo.Client
+	db     *mongo.Database
+	config *subconfigs.MongoDBConfig
+	//mu     sync.RWMutex // 添加读写锁保护
+}
+
+var (
+	instanceMongodb     *MongoDBFactory
+	instanceMongodbOnce sync.Once
+	initErr             error
+)
+
+// GetMongoDBFactory 获取MongoDB工厂单例
+func GetMongoDBFactory(config *subconfigs.MongoDBConfig) *MongoDBFactory {
+
+	instanceMongodbOnce.Do(func() {
+		if config == nil {
+			log.Fatal("配置未初始化，请先在yaml进行配置")
+		}
+
+		// 设置默认值
+		if config.Timeout == 0 {
+			config.Timeout = 20 * time.Second
+		}
+		if config.MaxPoolSize == 0 {
+			config.MaxPoolSize = 100
+		}
+		if config.MinPoolSize == 0 {
+			config.MinPoolSize = 10
+		}
+		if config.AuthSource == "" {
+			config.AuthSource = "admin"
+		}
+
+		// 验证配置
+		if config.URI == "" {
+			initErr = fmt.Errorf("mongodb URI must be configured")
+			return
+		}
+		if config.Database == "" {
+			initErr = fmt.Errorf("mongodb database name must be configured")
+			return
+		}
+
+		log.Printf("Creating MongoDB connection...")
+
+		// 创建客户端选项
+		clientOptions := options.Client().
+			ApplyURI(config.URI).
+			SetConnectTimeout(config.Timeout).
+			SetSocketTimeout(config.Timeout).
+			SetServerSelectionTimeout(config.Timeout).
+			SetMaxPoolSize(config.MaxPoolSize).
+			SetMinPoolSize(config.MinPoolSize).
+			SetMaxConnIdleTime(5 * time.Minute).
+			SetHeartbeatInterval(10 * time.Second)
+
+		// 设置认证
+		if config.Username != "" && config.Password != "" {
+			clientOptions.SetAuth(options.Credential{
+				Username:   config.Username,
+				Password:   config.Password,
+				AuthSource: config.AuthSource,
+			})
+		}
+
+		// 设置SSL
+		if config.SSL {
+			clientOptions.SetTLSConfig(&tls.Config{
+				InsecureSkipVerify: false,
+			})
+		}
+
+		// 创建上下文
+		ctx, cancel := context.WithTimeout(context.Background(), config.Timeout)
+		defer cancel()
+
+		log.Printf(" context.WithTimeout ... successfully.")
+
+		// 连接MongoDB
+		client, err := mongo.Connect(ctx, clientOptions)
+		if err != nil {
+			initErr = fmt.Errorf("failed to connect to MongoDB: %v", err)
+			return
+		}
+
+		log.Printf(" mongo.connect ... successfully.")
+
+		// // 测试连接
+		// if err := client.Ping(ctx, nil); err != nil {
+		// 	initErr = fmt.Errorf("failed to ping MongoDB: %v", err)
+		// 	return
+		// }
+
+		// 获取数据库
+		database := client.Database(config.Database)
+
+		log.Printf("MongoDBFactory is successfully created.\n")
+
+		instanceMongodb = &MongoDBFactory{
+			client: client,
+			db:     database,
+			config: config,
+		}
+	})
+
+	if initErr != nil {
+		//logger.Errorf("MongoDBFactory is error:'%v'", initErr)
+		log.Fatalf("MongoDBFactory is error:'%v'", initErr)
+		//return nil
+	}
+
+	return instanceMongodb
+}
+
+// ========== MongoDBFactory 实例方法 ==========
+
+// GetClient 获取MongoDB客户端
+func (f *MongoDBFactory) GetClient() *mongo.Client {
+	return f.client
+}
+
+// GetDatabase 获取数据库
+func (f *MongoDBFactory) GetDatabase() *mongo.Database {
+	return f.db
+}
+
+// GetCollection 获取集合（类似获取数据库连接）
+func (f *MongoDBFactory) GetCollection(collectionName string) *mongo.Collection {
+	return f.db.Collection(collectionName)
+}
+
+// Close 关闭MongoDB连接
+func (f *MongoDBFactory) Close() {
+	if f.client != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+
+		err := f.client.Disconnect(ctx)
+		if err != nil {
+			logger.Errorf("failed to disconnect MongoDB: %v", err)
+			//return fmt.Errorf("failed to disconnect MongoDB: %v", err)
+		}
+
+		log.Printf("MongoDB connection closed gracefully\n")
+		f.client = nil
+		f.db = nil
+	}
+
+}
+
+// GetConfig 获取配置信息
+func (f *MongoDBFactory) GetConfig() subconfigs.MongoDBConfig {
+	return *f.config
+}
+
+// TestConnection 测试连接
+func (f *MongoDBFactory) TestConnection() error {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	return f.client.Ping(ctx, readpref.Primary())
+}
+
+// ========== 快捷操作方法（增强版） ==========
+
+// InsertOne 插入单个文档，返回是否成功
+func (f *MongoDBFactory) InsertOne(collectionName string, document interface{}) bool {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	_, err := collection.InsertOne(ctx, document)
+	if err != nil {
+		logger.Errorf("插入文档失败，集合：%s，错误：%v", collectionName, err)
+		return false
+	}
+	return true
+}
+
+// InsertOneWithResult 插入单个文档并返回结果
+func (f *MongoDBFactory) InsertOneWithResult(collectionName string, document interface{}) (*mongo.InsertOneResult, bool) {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	result, err := collection.InsertOne(ctx, document)
+	if err != nil {
+		logger.Errorf("插入文档失败，集合：%s，错误：%v", collectionName, err)
+		return nil, false
+	}
+	return result, true
+}
+
+// InsertMany 插入多个文档，返回是否成功
+func (f *MongoDBFactory) InsertMany(collectionName string, documents []interface{}) bool {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	_, err := collection.InsertMany(ctx, documents)
+	if err != nil {
+		logger.Errorf("批量插入文档失败，集合：%s，错误：%v", collectionName, err)
+		return false
+	}
+	return true
+}
+
+// InsertManyWithResult 插入多个文档并返回结果
+func (f *MongoDBFactory) InsertManyWithResult(collectionName string, documents []interface{}) (*mongo.InsertManyResult, bool) {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	result, err := collection.InsertMany(ctx, documents)
+	if err != nil {
+		logger.Errorf("批量插入文档失败，集合：%s，错误：%v", collectionName, err)
+		return nil, false
+	}
+	return result, true
+}
+
+// FindOne 查询单个文档，返回解码后的对象
+func (f *MongoDBFactory) FindOne(collectionName string, filter interface{}, result interface{}) error {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	err := collection.FindOne(ctx, filter).Decode(result)
+	if err != nil {
+		if err != mongo.ErrNoDocuments {
+			logger.Errorf("查询文档失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		}
+		return err
+	}
+	return nil
+}
+
+// FindOneAndDecode 查询单个文档并自动解码（简化版）
+func (f *MongoDBFactory) FindOneAndDecode(collectionName string, filter interface{}) (interface{}, error) {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	var result map[string]interface{}
+	err := collection.FindOne(ctx, filter).Decode(&result)
+	if err != nil {
+		if err != mongo.ErrNoDocuments {
+			logger.Errorf("查询文档失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		}
+		return nil, err
+	}
+	return result, nil
+}
+
+// Find 查询多个文档，返回对象数组
+func (f *MongoDBFactory) Find(collectionName string, filter interface{}, results interface{}, opts ...*options.FindOptions) error {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	cursor, err := collection.Find(ctx, filter, opts...)
+	if err != nil {
+		logger.Errorf("查询文档失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		return err
+	}
+	defer cursor.Close(ctx)
+
+	// 解码到传入的切片指针中
+	if err = cursor.All(ctx, results); err != nil {
+		logger.Errorf("解码查询结果失败，集合：%s，错误：%v", collectionName, err)
+		return err
+	}
+	return nil
+}
+
+// FindAll 查询所有文档，返回对象数组
+func (f *MongoDBFactory) FindAll(collectionName string, results interface{}) error {
+	return f.Find(collectionName, bson.M{}, results)
+}
+
+// UpdateOneWithResult 更新单个文档并返回结果
+func (f *MongoDBFactory) UpdateOneWithResult(collectionName string, filter interface{}, update interface{}) (*mongo.UpdateResult, bool) {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	result, err := collection.UpdateOne(ctx, filter, update)
+	if err != nil {
+		logger.Errorf("更新文档失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		return nil, false
+	}
+	return result, true
+}
+
+// CountDocuments 统计文档数量，返回数量
+func (f *MongoDBFactory) CountDocuments(collectionName string, filter interface{}) (int64, error) {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	count, err := collection.CountDocuments(ctx, filter)
+	if err != nil {
+		logger.Errorf("统计文档数量失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		return 0, err
+	}
+	return count, nil
+}
+
+// Aggregate 聚合查询，返回对象数组
+func (f *MongoDBFactory) Aggregate(collectionName string, pipeline interface{}, results interface{}) error {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	cursor, err := collection.Aggregate(ctx, pipeline)
+	if err != nil {
+		logger.Errorf("聚合查询失败，集合：%s，管道：%v，错误：%v", collectionName, pipeline, err)
+		return err
+	}
+	defer cursor.Close(ctx)
+
+	if err = cursor.All(ctx, results); err != nil {
+		logger.Errorf("解码聚合结果失败，集合：%s，错误：%v", collectionName, err)
+		return err
+	}
+	return nil
+}
+
+// FindOneAndUpdate 查找并更新，返回更新后的文档
+func (f *MongoDBFactory) FindOneAndUpdate(collectionName string, filter interface{}, update interface{}, result interface{}) error {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	err := collection.FindOneAndUpdate(ctx, filter, update).Decode(result)
+	if err != nil {
+		if err != mongo.ErrNoDocuments {
+			logger.Errorf("查找并更新失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		}
+		return err
+	}
+	return nil
+}
+
+// FindOneAndDelete 查找并删除，返回删除的文档
+func (f *MongoDBFactory) FindOneAndDelete(collectionName string, filter interface{}, result interface{}) error {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	err := collection.FindOneAndDelete(ctx, filter).Decode(result)
+	if err != nil {
+		if err != mongo.ErrNoDocuments {
+			logger.Errorf("查找并删除失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		}
+		return err
+	}
+	return nil
+}
+
+// BulkWrite 批量写入操作，返回是否成功
+func (f *MongoDBFactory) BulkWrite(collectionName string, operations []mongo.WriteModel) bool {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	_, err := collection.BulkWrite(ctx, operations)
+	if err != nil {
+		logger.Errorf("批量写入操作失败，集合：%s，错误：%v", collectionName, err)
+		return false
+	}
+	return true
+}
+
+// CreateIndex 创建索引，返回是否成功
+func (f *MongoDBFactory) CreateIndex(collectionName string, keys interface{}, opts ...*options.IndexOptions) bool {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	indexModel := mongo.IndexModel{
+		Keys: keys,
+	}
+
+	if len(opts) > 0 && opts[0] != nil {
+		indexModel.Options = opts[0]
+	}
+
+	_, err := collection.Indexes().CreateOne(ctx, indexModel)
+	if err != nil {
+		logger.Errorf("创建索引失败，集合：%s，键：%v，错误：%v", collectionName, keys, err)
+		return false
+	}
+	return true
+}
+
+// FindWithPagination 分页查询，返回对象数组
+func (f *MongoDBFactory) FindWithPagination(
+	collectionName string,
+	filter interface{},
+	skip, limit int64,
+	sort interface{},
+	results interface{},
+) error {
+	//collection := f.GetCollection(collectionName)
+	//ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	//defer cancel()
+
+	findOptions := options.Find().
+		SetSkip(skip).
+		SetLimit(limit)
+
+	if sort != nil {
+		findOptions.SetSort(sort)
+	}
+
+	return f.Find(collectionName, filter, results, findOptions)
+}
+
+// FindOneByID 根据ID查询文档
+func (f *MongoDBFactory) FindOneByID(collectionName string, id interface{}, result interface{}) error {
+	return f.FindOne(collectionName, bson.M{"_id": id}, result)
+}
+
+// Exists 检查文档是否存在
+func (f *MongoDBFactory) Exists(collectionName string, filter interface{}) (bool, error) {
+	count, err := f.CountDocuments(collectionName, filter)
+	if err != nil {
+		return false, err
+	}
+	return count > 0, nil
+}
+
+// FindAndCount 查询文档并返回总数（用于分页场景）
+func (f *MongoDBFactory) FindAndCount(
+	collectionName string,
+	filter interface{},
+	skip, limit int64,
+	sort interface{},
+	results interface{},
+) (int64, error) {
+	// 查询数据
+	err := f.FindWithPagination(collectionName, filter, skip, limit, sort, results)
+	if err != nil {
+		return 0, err
+	}
+
+	// 查询总数
+	total, err := f.CountDocuments(collectionName, filter)
+	if err != nil {
+		return 0, err
+	}
+
+	return total, nil
+}
+
+// UpdateOne 更新单个文档，返回是否执行成功和影响记录数
+func (f *MongoDBFactory) UpdateOne(collectionName string, filter interface{}, update interface{}) (bool, int64) {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	result, err := collection.UpdateOne(ctx, filter, update)
+	if err != nil {
+		logger.Errorf("更新文档失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		return false, 0
+	}
+
+	// 返回执行成功 和 实际更新的文档数
+	return true, result.ModifiedCount
+}
+
+// UpdateOneWithMatch 更新单个文档，只有匹配到文档才返回成功
+func (f *MongoDBFactory) UpdateOneWithMatch(collectionName string, filter interface{}, update interface{}) bool {
+	success, modifiedCount := f.UpdateOne(collectionName, filter, update)
+	return success && modifiedCount > 0
+}
+
+// UpdateMany 更新多个文档，返回是否执行成功和影响记录数
+func (f *MongoDBFactory) UpdateMany(collectionName string, filter interface{}, update interface{}) (bool, int64) {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	result, err := collection.UpdateMany(ctx, filter, update)
+	if err != nil {
+		logger.Errorf("批量更新文档失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		return false, 0
+	}
+
+	return true, result.ModifiedCount
+}
+
+// DeleteOne 删除单个文档，返回是否执行成功和删除的记录数
+func (f *MongoDBFactory) DeleteOne(collectionName string, filter interface{}) (bool, int64) {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	result, err := collection.DeleteOne(ctx, filter)
+	if err != nil {
+		logger.Errorf("删除文档失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		return false, 0
+	}
+
+	// 返回执行成功 和 实际删除的文档数
+	return true, result.DeletedCount
+}
+
+// DeleteOneWithMatch 删除单个文档，只有删除了文档才返回成功
+func (f *MongoDBFactory) DeleteOneWithMatch(collectionName string, filter interface{}) bool {
+	success, deletedCount := f.DeleteOne(collectionName, filter)
+	return success && deletedCount > 0
+}
+
+// DeleteMany 删除多个文档，返回是否执行成功和删除的记录数
+func (f *MongoDBFactory) DeleteMany(collectionName string, filter interface{}) (bool, int64) {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	result, err := collection.DeleteMany(ctx, filter)
+	if err != nil {
+		logger.Errorf("批量删除文档失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		return false, 0
+	}
+
+	return true, result.DeletedCount
+}
+
+// UpsertOne 更新或插入文档（upsert操作）
+func (f *MongoDBFactory) UpsertOne(collectionName string, filter interface{}, update interface{}) (bool, interface{}) {
+	collection := f.GetCollection(collectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), f.config.Timeout)
+	defer cancel()
+
+	// 设置 upsert 选项
+	opts := options.Update().SetUpsert(true)
+
+	result, err := collection.UpdateOne(ctx, filter, update, opts)
+	if err != nil {
+		logger.Errorf("Upsert操作失败，集合：%s，过滤条件：%v，错误：%v", collectionName, filter, err)
+		return false, result
+	}
+
+	// 返回: 成功状态, 匹配数, 修改数, 插入数
+	return true, result
+}
+
+// UpdateOneByID 根据ID更新文档
+func (f *MongoDBFactory) UpdateOneByID(collectionName string, id interface{}, update interface{}) (bool, int64) {
+	return f.UpdateOne(collectionName, bson.M{"_id": id}, update)
+}
+
+// UpdateOneByIDWithMatch 根据ID更新文档，只有匹配到才返回成功
+func (f *MongoDBFactory) UpdateOneByIDWithMatch(collectionName string, id interface{}, update interface{}) bool {
+	success, modifiedCount := f.UpdateOneByID(collectionName, id, update)
+	return success && modifiedCount > 0
+}
+
+// DeleteOneByID 根据ID删除文档
+func (f *MongoDBFactory) DeleteOneByID(collectionName string, id interface{}) (bool, int64) {
+	return f.DeleteOne(collectionName, bson.M{"_id": id})
+}
+
+// DeleteOneByIDWithMatch 根据ID删除文档，只有删除了才返回成功
+func (f *MongoDBFactory) DeleteOneByIDWithMatch(collectionName string, id interface{}) bool {
+	success, deletedCount := f.DeleteOneByID(collectionName, id)
+	return success && deletedCount > 0
+}

factory/rabbitmq/rabbitmq_factory.go

@@ -20,11 +20,7 @@ type RabbitMQFactory struct {
 
 // NewRabbitMQFactory 创建RabbitMQ工厂
 func NewRabbitMQFactory() (*RabbitMQFactory, error) {
-	cfg, err := config.GetConfig()
-
-	if err != nil {
-		return nil, fmt.Errorf("failed to load config: %v", err)
-	}
+	cfg := config.GetConfig()
 
 	rabbitConfig := cfg.GetRabbitMQConfig()
 	if rabbitConfig.Host == "" || rabbitConfig.Port == 0 {
@@ -42,7 +38,7 @@ func NewRabbitMQFactory() (*RabbitMQFactory, error) {
 	// 简单的连接配置
 	mqConfig := amqp.Config{
 		Properties: amqp.Table{
-			"connection_name": cfg.GetService().InstanceName,
+			"connection_name": cfg.GetServiceConfig().InstanceName,
 		}}
 
 	// 建立连接

factory/redis/redis_factory.go

@@ -10,7 +10,7 @@ import (
 	"github.com/go-redis/redis/v8"
 )
 
-var ctx = context.Background()
+var ctxRedis = context.Background()
 
 // RedisFactory Redis客户端工厂
 type RedisFactory struct {
@@ -20,7 +20,7 @@ type RedisFactory struct {
 // NewRedisFactory 创建Redis客户端工厂
 func NewRedisFactory() (*RedisFactory, error) {
 
-	cfg := config.GetRedis()
+	cfg := config.GetRedisConfig()
 
 	// 可以添加配置验证
 	if cfg == nil || cfg.Host == "" {
@@ -53,47 +53,47 @@ type RedisClient struct {
 
 // Set 写入字符串值
 func (c *RedisClient) Set(key string, value interface{}, expiration time.Duration) error {
-	return c.client.Set(ctx, key, value, expiration).Err()
+	return c.client.Set(ctxRedis, key, value, expiration).Err()
 }
 
 // Get 读取字符串值
 func (c *RedisClient) Get(key string) (string, error) {
-	return c.client.Get(ctx, key).Result()
+	return c.client.Get(ctxRedis, key).Result()
 }
 
 // HSet 写入哈希字段
 func (c *RedisClient) HSet(key string, values ...interface{}) error {
-	return c.client.HSet(ctx, key, values...).Err()
+	return c.client.HSet(ctxRedis, key, values...).Err()
 }
 
 // HGet 读取哈希字段
 func (c *RedisClient) HGet(key, field string) (string, error) {
-	return c.client.HGet(ctx, key, field).Result()
+	return c.client.HGet(ctxRedis, key, field).Result()
 }
 
 // HGetAll 读取整个哈希
 func (c *RedisClient) HGetAll(key string) (map[string]string, error) {
-	return c.client.HGetAll(ctx, key).Result()
+	return c.client.HGetAll(ctxRedis, key).Result()
 }
 
 // LPush 列表左推入
 func (c *RedisClient) LPush(key string, values ...interface{}) error {
-	return c.client.LPush(ctx, key, values...).Err()
+	return c.client.LPush(ctxRedis, key, values...).Err()
 }
 
 // RPop 列表右弹出
 func (c *RedisClient) RPop(key string) (string, error) {
-	return c.client.RPop(ctx, key).Result()
+	return c.client.RPop(ctxRedis, key).Result()
 }
 
 // Del 删除键
 func (c *RedisClient) Del(keys ...string) error {
-	return c.client.Del(ctx, keys...).Err()
+	return c.client.Del(ctxRedis, keys...).Err()
 }
 
 // Exists 检查键是否存在
 func (c *RedisClient) Exists(keys ...string) (int64, error) {
-	return c.client.Exists(ctx, keys...).Result()
+	return c.client.Exists(ctxRedis, keys...).Result()
 }
 
 // Close 关闭连接

go.mod

@@ -14,7 +14,15 @@ require (
 require (
 	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/klauspost/compress v1.16.7 // indirect
+	github.com/montanaflynn/stats v0.7.1 // indirect
+	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
+	github.com/xdg-go/scram v1.1.2 // indirect
+	github.com/xdg-go/stringprep v1.0.4 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
 	golang.org/x/net v0.47.0 // indirect
+	golang.org/x/sync v0.18.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
 
@@ -27,6 +35,7 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/streadway/amqp v1.1.0
+	go.mongodb.org/mongo-driver v1.17.6
 	golang.org/x/crypto v0.45.0 // indirect
 	golang.org/x/text v0.31.0 // indirect
 )

go.sum

@@ -1,5 +1,6 @@
 filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
 filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+git.x2erp.com/qdy/go-base v0.1.51/go.mod h1:IYkjIY0xiqPKIOBojsR9miER2ceyly6+iwv4Zd64OT0=
 git.x2erp.com/qdy/go-base v0.1.60 h1:eGexgp8fUNMBmecpR7pelNsvr8ujYFZf1phLNFlGjVE=
 git.x2erp.com/qdy/go-base v0.1.60/go.mod h1:IYkjIY0xiqPKIOBojsR9miER2ceyly6+iwv4Zd64OT0=
 github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.0 h1:Gt0j3wceWMwPmiazCa8MzMA0MfhmPIz0Qp0FJ6qcM0U=
@@ -35,10 +36,14 @@ github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0kt
 github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
 github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A=
 github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/jmoiron/sqlx v1.4.0 h1:1PLqN7S1UYp5t4SrVVnt4nUVNemrDAtxlulVe+Qgm3o=
 github.com/jmoiron/sqlx v1.4.0/go.mod h1:ZrZ7UsYB/weZdl2Bxg6jCRO9c3YHl8r3ahlKmRT4JLY=
+github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=
+github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
@@ -47,6 +52,8 @@ github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/microsoft/go-mssqldb v1.9.4 h1:sHrj3GcdgkxytZ09aZ3+ys72pMeyEXJowT44j74pNgs=
 github.com/microsoft/go-mssqldb v1.9.4/go.mod h1:GBbW9ASTiDC+mpgWDGKdm3FnFLTUsLYN3iFL90lQ+PA=
+github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE=
+github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
 github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY=
 github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc=
 github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
@@ -63,16 +70,52 @@ github.com/streadway/amqp v1.1.0 h1:py12iX8XSyI7aN/3dUT8DFIDJazNJsVJdxNVEpnQTZM=
 github.com/streadway/amqp v1.1.0/go.mod h1:WYSrTEYHOXHd0nwFeUXAe2G2hRnQT+deZJJf88uS9Bg=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
+github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
+github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
+github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4=
+github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
+github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
+github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM=
+github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+go.mongodb.org/mongo-driver v1.17.6 h1:87JUG1wZfWsr6rIz3ZmpH90rL5tea7O3IHuSwHUpsss=
+go.mongodb.org/mongo-driver v1.17.6/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
 golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
 golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
+golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
 golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
 golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
 golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
 golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=

test.go

@@ -2,44 +2,33 @@ package main
 
 import (
 	"fmt"
-	"log"
 
 	"git.x2erp.com/qdy/go-base/config"
+	"git.x2erp.com/qdy/go-base/container"
 	"git.x2erp.com/qdy/go-db/factory/database"
 )
 
 func main() {
 
 	// 显示当前使用的数据库配置
-	config, err := config.GetConfig()
-	if err != nil {
-		log.Fatalf("failed to load config: %v", err)
+	config := config.GetConfig()
 
-		return
-	}
+	ctr := container.NewContainer(config)
 
-	dbConfig := config.GetDatabase() // 通过接口方法获取数据库配置
-	fmt.Printf("Using database type: %s\n", dbConfig.Type)
-	fmt.Printf("Database host: %s:%d\n", dbConfig.Host, dbConfig.Port)
-	fmt.Printf("Database name: %s\n", dbConfig.Database)
+	dbFactory := container.Create(ctr, database.CreateDBFactory)
 
+	dbFactory.TestConnection()
 	// 创建数据库工厂
 	fmt.Printf("第1次.\n")
-	dbFactory, err := database.GetDefaultDBFactory()
 
-	if err != nil {
-		log.Fatalf("Failed to create DB factory: %v", err)
-	}
+	dbFactory1 := database.CreateDBFactory(config)
+
+	dbFactory1.TestConnection()
 
-	//测试单例是否生效
 	fmt.Printf("第2次.\n")
-	dbFactory1, err1 := database.GetDefaultDBFactory()
-
-	if err1 != nil {
-		log.Fatalf("Failed to create DB factory: %v", err1)
-	}
-	dbFactory1.TestConnection(dbConfig.Type)
-	defer dbFactory.Close()
-	defer dbFactory1.Close()
+	dbFactory2 := container.Create(ctr, database.CreateDBFactory)
+
+	dbFactory2.TestConnection()
+	defer ctr.CloseAll()
 
 }