修改工厂,实现单例模式

drivers/driver.go

 package drivers
 
 import (
-	"database/sql"
 	"fmt"
 	"time" // 添加 time 包导入
+
+	"github.com/jmoiron/sqlx"
 )
 
 // DBConfig 数据库配置
 	// Name 返回驱动名称
 	Name() string
 	// Open 打开数据库连接
-	Open(config DBConfig) (*sql.DB, error)
+	Open(config DBConfig) (*sqlx.DB, error)
 	// BuildDSN 构建连接字符串
 	BuildDSN(config DBConfig) string
 }
 }
 
 // configureConnectionPool 配置连接池的公共函数
-func configureConnectionPool(db *sql.DB, config DBConfig) {
+func configureConnectionPool(db *sqlx.DB, config DBConfig) {
 	if config.MaxOpenConns > 0 {
 		db.SetMaxOpenConns(config.MaxOpenConns)
 	}

drivers/mysql.go

 package drivers
 
 import (
-	"database/sql"
 	"fmt"
 
 	_ "github.com/go-sql-driver/mysql"
+	"github.com/jmoiron/sqlx"
 )
 
 type MySQLDriver struct{}
 		config.Database)
 }
 
-func (d *MySQLDriver) Open(config DBConfig) (*sql.DB, error) {
+func (d *MySQLDriver) Open(config DBConfig) (*sqlx.DB, error) {
 	dsn := d.BuildDSN(config)
-	db, err := sql.Open("mysql", dsn)
+	db, err := sqlx.Open("mysql", dsn)
 	if err != nil {
 		return nil, err
 	}

drivers/oracle.go

 package drivers
 
 import (
-	"database/sql"
 	"fmt"
 
+	"github.com/jmoiron/sqlx"
 	_ "github.com/sijms/go-ora/v2"
 )
 
 		config.Database)
 }
 
-func (d *OracleDriver) Open(config DBConfig) (*sql.DB, error) {
+func (d *OracleDriver) Open(config DBConfig) (*sqlx.DB, error) {
 	dsn := d.BuildDSN(config)
-	db, err := sql.Open("oracle", dsn)
+	db, err := sqlx.Open("oracle", dsn)
 	if err != nil {
 		return nil, err
 	}

drivers/postgres.go

 package drivers
 
 import (
-	"database/sql"
 	"fmt"
 
+	"github.com/jmoiron/sqlx"
 	_ "github.com/lib/pq"
 )
 
 		config.Database)
 }
 
-func (d *PostgresDriver) Open(config DBConfig) (*sql.DB, error) {
+func (d *PostgresDriver) Open(config DBConfig) (*sqlx.DB, error) {
 	dsn := d.BuildDSN(config)
-	db, err := sql.Open("postgres", dsn)
+	db, err := sqlx.Open("postgres", dsn)
 	if err != nil {
 		return nil, err
 	}

drivers/sqlserver.go

 package drivers
 
 import (
-	"database/sql"
 	"fmt"
 
+	"github.com/jmoiron/sqlx"
 	_ "github.com/microsoft/go-mssqldb"
 )
 
 		config.Database)
 }
 
-func (d *SQLServerDriver) Open(config DBConfig) (*sql.DB, error) {
+func (d *SQLServerDriver) Open(config DBConfig) (*sqlx.DB, error) {
 	dsn := d.BuildDSN(config)
-	db, err := sql.Open("sqlserver", dsn)
+	db, err := sqlx.Open("sqlserver", dsn)
 	if err != nil {
 		return nil, err
 	}

factory/db_factory.go

 package factory
 
 import (
-	"database/sql"
 	"fmt"
 	"io"
+	"sync"
 
 	"git.x2erp.com/qdy/go-base/config"
 	"git.x2erp.com/qdy/go-base/types"
 	"git.x2erp.com/qdy/go-db/drivers"
+	"git.x2erp.com/qdy/go-db/functions"
+
+	"github.com/jmoiron/sqlx"
 )
 
-// DBFactory 数据库工厂
 type DBFactory struct {
-	config config.IConfig
-}
-
-// NewDBFactory 创建数据库工厂
-func NewDBFactory() (*DBFactory, error) {
-	// 使用配置单例 哪里都可以直接使用
-	cfg := config.GetConfig()
-
-	// 检查配置初始化是否有错误
-	if err := config.GetInitError(); err != nil {
-		return nil, fmt.Errorf("failed to load config: %v", err)
-	}
-
-	// 检查数据库配置是否完整
-	if !cfg.IsDatabaseConfigured() {
-		return nil, fmt.Errorf("database configuration is incomplete")
-	}
-
-	return &DBFactory{config: cfg}, nil
+	db *sqlx.DB
 }
 
-// CreateDB 创建数据库连接
-func (f *DBFactory) CreateDB() (*sql.DB, error) {
-	dbConfig := f.config.GetDatabase()
-	dbType := dbConfig.Type
-
-	// 获取对应的驱动
-	dbDriver, err := drivers.Get(dbType)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get database driver: %v", err)
-	}
+var (
+	instanceDBFactory *DBFactory
+	once              sync.Once
+)
 
-	// 将内部 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,
+// GetDBFactory 创建数据库工厂单例
+func GetDBFactory() (*DBFactory, error) {
+	var initErr error
+	var msg = "DBFactory instance retrieved from memory.\n"
+
+	once.Do(func() {
+		// 使用配置单例
+		cfg := config.GetConfig()
+
+		// 检查配置初始化是否有错误
+		if err := config.GetInitError(); err != nil {
+			initErr = fmt.Errorf("failed to load config: %v", err)
+			return
+		}
+
+		// 检查数据库配置是否完整
+		if !cfg.IsDatabaseConfigured() {
+			initErr = fmt.Errorf("database configuration is incomplete")
+			return
+		}
+
+		// 显示所支持的数据库驱动
+		driversStr := drivers.GetAllDrivers()
+		fmt.Printf("Available database drivers: %v\n", driversStr)
+
+		dbConfig := cfg.GetDatabase()
+		dbType := dbConfig.Type
+
+		// 获取对应的驱动
+		dbDriver, err := drivers.Get(dbType)
+		if err != nil {
+			initErr = 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,
+		}
+
+		// 创建数据库连接
+		db, err := dbDriver.Open(driverConfig)
+		if err != nil {
+			initErr = fmt.Errorf("failed to open database connection: %v", err)
+			return
+		}
+
+		// 测试连接
+		if err := functions.TestConnection(db, dbType); err != nil {
+			db.Close()
+			initErr = fmt.Errorf("database connection test failed: %v", err)
+			return
+		}
+
+		msg = "DBFactory is successfully created.\n"
+		instanceDBFactory = &DBFactory{db: db}
+	})
+
+	if initErr != nil {
+		return nil, initErr
 	}
 
-	// 创建数据库连接
-	db, err := dbDriver.Open(driverConfig)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open database connection: %v", err)
-	}
+	fmt.Print(msg)
 
-	return db, nil
+	return instanceDBFactory, nil
 }
 
-// GetConfig 获取配置信息
-func (f *DBFactory) GetConfig() config.IConfig {
-	return f.config
+// GetDB 获取数据库连接（线程安全）
+func (f *DBFactory) GetDB() *sqlx.DB {
+	return f.db
 }
 
-// GetAvailableDrivers 获取可用的数据库驱动
-func (f *DBFactory) GetAvailableDrivers() []string {
-	return drivers.GetAllDrivers()
+// Close 关闭数据库连接
+func (f *DBFactory) Close() error {
+	if f.db != nil {
+		err := f.db.Close()
+		f.db = nil
+		return err
+	}
+	return nil
 }
 
-// CreateQueryExecutor 创建查询执行器
-// func (f *DBFactory) CreateQueryExecutor(db *sql.DB) *QueryExecutor {
-// 	return newQueryExecutor(db)
-// }
-
-// -------------- 对外暴露的初始化方法（核心入口）--------------
-// NewDBQuery 初始化查询实例（对外提供唯一初始化入口）
-// db: 已初始化的数据库连接（由调用方传入，解耦数据库配置）
-func newDBQuery(db *sql.DB) *queryExecutor {
-	return newQueryExecutor(db)
+// QueryToJSON 快捷查询，直接返回 JSON 字节流
+func (f *DBFactory) QueryToJSON(sql string) *types.QueryResult {
+	return functions.QueryToJSON(f.db, sql)
 }
 
-// QuickQueryToJSON 快捷查询，直接返回 JSON 字节流
-func QueryToJSON(db *sql.DB, sql string) *types.QueryResult {
-	return newDBQuery(db).queryToJSON(sql)
+// QueryToCSV 快捷查询，直接返回 CSV 字符串（包含表头）
+func (f *DBFactory) QueryToCSV(sql string) ([]byte, error) {
+	return functions.QueryToCSV(f.db, sql)
 }
 
-// QuickQueryToCSV 快捷查询，直接返回 CSV 字符串（包含表头）
-func QueryToCSV(db *sql.DB, sql string) ([]byte, error) {
-	return newDBQuery(db).queryToCSV(sql)
+// QueryWithColumns 快捷查询，返回完整结果（含列信息）
+func (f *DBFactory) QueryWithColumns(sql string) *types.QueryResult {
+	return functions.QueryWithColumns(f.db, sql)
 }
 
-// QuickExecuteWithColumns 快捷查询，返回完整结果（含列信息）
-func QueryWithColumns(db *sql.DB, sql string) *types.QueryResult {
-	return newDBQuery(db).queryWithColumns(sql)
+// QueryDataOnly 快捷查询，返回纯数据（性能优先）
+func (f *DBFactory) QueryDataOnly(sql string) *types.QueryResult {
+	return functions.QueryDataOnly(f.db, sql)
 }
 
-// QuickExecuteDataOnly 快捷查询，返回纯数据（性能优先）
-func QueryDataOnly(db *sql.DB, sql string) *types.QueryResult {
-	return newDBQuery(db).queryDataOnly(sql)
+// QueryCSV 快捷查询，返回 CSV 格式结果（支持自定义是否包含表头）
+func (f *DBFactory) QueryCSV(sql string, includeHeader bool) *types.QueryResult {
+	return functions.QueryCSV(f.db, sql, includeHeader)
 }
 
-// QuickExecuteCSV 快捷查询，返回 CSV 格式结果（支持自定义是否包含表头）
-func QueryCSV(db *sql.DB, sql string, includeHeader bool) *types.QueryResult {
-	return newDBQuery(db).queryCSV(sql, includeHeader)
+// QueryCSVStream 快捷流式输出 CSV（直接写入 io.Writer，适合大文件）
+func (f *DBFactory) QueryCSVStream(sql string, w io.Writer, includeHeader bool) (int, error) {
+	return functions.QueryCSVStream(f.db, sql, w, includeHeader)
 }
 
-// QuickExecuteCSVStream 快捷流式输出 CSV（直接写入 io.Writer，适合大文件）
-func QueryCSVStream(db *sql.DB, sql string, w io.Writer, includeHeader bool) (int, error) {
-	return newDBQuery(db).queryCSVStream(sql, w, includeHeader)
+// ExecuteDDL 快捷执行DDL语句
+func (f *DBFactory) ExecuteDDL(ddlSQL string) error {
+	return functions.ExecuteDDL(f.db, ddlSQL)
 }
 
-// QuickExecuteDDL 快捷执行DDL语句
-func ExecuteDDL(db *sql.DB, ddlSQL string) error {
-	factory := &DBFactory{}
-	return factory.executeDDL(db, ddlSQL)
+// ExecuteDDLWithTx 快捷在事务中执行DDL语句
+func (f *DBFactory) ExecuteDDLWithTx(ddlSQL string) error {
+	return functions.ExecuteDDLWithTx(f.db, ddlSQL)
 }
 
-// QuickExecuteDDLWithTx 快捷在事务中执行DDL语句
-func ExecuteDDLWithTx(db *sql.DB, ddlSQL string) error {
-	factory := &DBFactory{}
-	return factory.executeDDLWithTx(db, ddlSQL)
+// ExecuteMultipleDDL 快捷执行多个DDL语句
+func (f *DBFactory) ExecuteMultipleDDL(ddlSQLs []string) error {
+	return functions.ExecuteMultipleDDL(f.db, ddlSQLs)
 }
 
-// QuickExecuteMultipleDDL 快捷执行多个DDL语句
-func ExecuteMultipleDDL(db *sql.DB, ddlSQLs []string) error {
-	factory := &DBFactory{}
-	return factory.executeMultipleDDL(db, ddlSQLs)
+// GetAvailableDrivers 获取可用的数据库驱动
+func (f *DBFactory) GetAvailableDrivers() []string {
+	return drivers.GetAllDrivers()
 }
 
-// testConnection 测试数据库连接
-func TestConnection(db *sql.DB, dbType string) error {
-	var query string
-	switch dbType {
-	case "mysql", "postgres", "sqlserver":
-		query = "SELECT 1"
-	case "oracle":
-		query = "SELECT 1 FROM DUAL"
-	default:
-		query = "SELECT 1"
-	}
-
-	var result int
-	err := db.QueryRow(query).Scan(&result)
-	if err != nil {
-		return err
-	}
-
-	if result != 1 {
-		return fmt.Errorf("unexpected test result: %d", result)
-	}
-
-	return nil
+func (f *DBFactory) TestConnection(dbType string) error {
+	return functions.TestConnection(f.db, dbType)
 }

factory/execute.go → functions/execute.go

-package factory
+package functions
 
 import (
-	"database/sql"
 	"fmt"
+
+	"github.com/jmoiron/sqlx"
 )
 
 // ExecuteDDL 执行DDL语句（创建、删除、更新表等）
-func (f *DBFactory) executeDDL(db *sql.DB, ddlSQL string) error {
-	if db == nil {
-		return fmt.Errorf("database connection is nil")
-	}
+func ExecuteDDL(db *sqlx.DB, ddlSQL string) error {
 
 	if ddlSQL == "" {
 		return fmt.Errorf("DDL SQL statement is empty")
 }
 
 // ExecuteDDLWithTx 在事务中执行DDL语句
-func (f *DBFactory) executeDDLWithTx(db *sql.DB, ddlSQL string) error {
-	if db == nil {
-		return fmt.Errorf("database connection is nil")
-	}
+func ExecuteDDLWithTx(db *sqlx.DB, ddlSQL string) error {
 
 	if ddlSQL == "" {
 		return fmt.Errorf("DDL SQL statement is empty")
 }
 
 // ExecuteMultipleDDL 执行多个DDL语句
-func (f *DBFactory) executeMultipleDDL(db *sql.DB, ddlSQLs []string) error {
-	if db == nil {
-		return fmt.Errorf("database connection is nil")
-	}
+func ExecuteMultipleDDL(db *sqlx.DB, ddlSQLs []string) error {
 
 	if len(ddlSQLs) == 0 {
 		return fmt.Errorf("DDL SQL statements are empty")

factory/query.go → functions/query.go

-package factory
+package functions
 
 import (
-	"database/sql"
 	"encoding/csv"
 	"encoding/json"
 	"fmt"
 	"time"
 
 	"git.x2erp.com/qdy/go-base/types"
+	"github.com/jmoiron/sqlx"
 )
 
-// func typesFunction() *types.QueryResult { // 确保使用了该包导出的类型，例如 QueryResult
-// 	return &types.QueryResult{}
-// }
-
-// QueryExecutor 查询执行器
-type queryExecutor struct {
-	db *sql.DB
-}
-
-// NewQueryExecutor 创建查询执行器
-func newQueryExecutor(db *sql.DB) *queryExecutor {
-	return &queryExecutor{db: db}
-}
-
 // QueryToJSON 执行查询并返回JSON格式数据（统一返回QueryResult）
-func (e *queryExecutor) queryToJSON(sql string) *types.QueryResult {
+func QueryToJSON(db *sqlx.DB, sql string) *types.QueryResult {
 	startTime := time.Now()
 	result := &types.QueryResult{}
 
 		return result
 	}
 
-	rows, err := e.db.Query(sql)
+	rows, err := db.Query(sql)
 	if err != nil {
 		result.Success = false
 		result.Error = fmt.Sprintf("Query execution failed: %v", err)
 }
 
 // QueryToCSV 查询并返回 CSV 字节数据（包含表头）
-func (e *queryExecutor) queryToCSV(sql string) ([]byte, error) {
+func QueryToCSV(db *sqlx.DB, sql string) ([]byte, error) {
 
 	if sql == "" {
 		return nil, fmt.Errorf("SQL query cannot be empty")
 	}
 
-	rows, err := e.db.Query(sql)
+	rows, err := db.Query(sql)
 	if err != nil {
 		return nil, fmt.Errorf("query execution failed: %v", err)
 	}
 }
 
 // ExecuteQueryWithColumns 执行查询并返回完整结果（包含列信息）
-func (e *queryExecutor) queryWithColumns(sql string) *types.QueryResult {
+func QueryWithColumns(db *sqlx.DB, sql string) *types.QueryResult {
 	startTime := time.Now()
 	result := &types.QueryResult{}
 
 		return result
 	}
 
-	rows, err := e.db.Query(sql)
+	rows, err := db.Query(sql)
 	if err != nil {
 		result.Success = false
 		result.Error = fmt.Sprintf("Query execution failed: %v", err)
 }
 
 // ExecuteQueryDataOnly 执行查询并返回纯数据（不包含列信息，性能更高）
-func (e *queryExecutor) queryDataOnly(sql string) *types.QueryResult {
+func QueryDataOnly(db *sqlx.DB, sql string) *types.QueryResult {
 	startTime := time.Now()
 	result := &types.QueryResult{}
 
 		return result
 	}
 
-	rows, err := e.db.Query(sql)
+	rows, err := db.Query(sql)
 	if err != nil {
 		result.Success = false
 		result.Error = fmt.Sprintf("Query execution failed: %v", err)
 }
 
 // ExecuteQueryCSV 执行查询并返回CSV格式数据
-func (e *queryExecutor) queryCSV(sql string, includeHeader bool) *types.QueryResult {
+func QueryCSV(db *sqlx.DB, sql string, includeHeader bool) *types.QueryResult {
 	startTime := time.Now()
 	result := &types.QueryResult{}
 
 		return result
 	}
 
-	rows, err := e.db.Query(sql)
+	rows, err := db.Query(sql)
 	if err != nil {
 		result.Success = false
 		result.Error = fmt.Sprintf("Query execution failed: %v", err)
 }
 
 // ExecuteQueryCSVStream 流式返回CSV数据
-func (e *queryExecutor) queryCSVStream(sql string, w io.Writer, includeHeader bool) (int, error) {
-	rows, err := e.db.Query(sql)
+func QueryCSVStream(db *sqlx.DB, sql string, w io.Writer, includeHeader bool) (int, error) {
+
+	rows, err := db.Query(sql)
 	if err != nil {
 		return 0, err
 	}

functions/testConnection.go

+package functions
+
+import (
+	"fmt"
+
+	"github.com/jmoiron/sqlx"
+)
+
+// TestConnection 测试数据库连接
+func TestConnection(db *sqlx.DB, dbType string) error {
+	var query string
+	switch dbType {
+	case "mysql", "postgres", "sqlserver":
+		query = "SELECT 1"
+	case "oracle":
+		query = "SELECT 1 FROM DUAL"
+	default:
+		query = "SELECT 1"
+	}
+
+	var result int
+	err := db.QueryRow(query).Scan(&result)
+	if err != nil {
+		return err
+	}
+
+	if result != 1 {
+		return fmt.Errorf("unexpected test result: %d", result)
+	}
+
+	fmt.Println("test Connection  database is success.")
+	return nil
+}

go.mod

 	github.com/sijms/go-ora/v2 v2.9.0
 )
 
-require gopkg.in/yaml.v2 v2.4.0 // indirect
+require (
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+)
 
 require (
 	filippo.io/edwards25519 v1.1.0 // indirect
 	git.x2erp.com/qdy/go-base v0.1.10
+	github.com/go-redis/redis/v8 v8.11.5
 	github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect
 	github.com/golang-sql/sqlexp v0.1.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
+	github.com/jmoiron/sqlx v1.4.0
 	golang.org/x/crypto v0.38.0 // indirect
 	golang.org/x/text v0.25.0 // indirect
 )

go.sum

 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
 github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI=
 github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo=
+github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
 github.com/go-sql-driver/mysql v1.9.3 h1:U/N249h2WzJ3Ukj8SowVFjdtZKfu9vlLZxjPXV1aweo=
 github.com/go-sql-driver/mysql v1.9.3/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
 github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
 github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI=
 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/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=
 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+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/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=

test.go

 package main
 
 import (
-	"database/sql"
 	"fmt"
 	"log"
 
+	"git.x2erp.com/qdy/go-base/config"
 	"git.x2erp.com/qdy/go-db/factory"
 )
 
 func main() {
-	// 创建数据库工厂
-	dbFactory, err := factory.NewDBFactory()
-	if err != nil {
-		log.Fatalf("Failed to create DB factory: %v", err)
-	}
-
-	// 显示可用的数据库驱动
-	drivers := dbFactory.GetAvailableDrivers()
-	fmt.Printf("Available database drivers: %v\n", drivers)
 
 	// 显示当前使用的数据库配置
-	config := dbFactory.GetConfig()
+	config := config.GetConfig()
 	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)
 
-	// 创建数据库连接
-	db, err := dbFactory.CreateDB()
-	if err != nil {
-		log.Fatalf("Failed to create database connection: %v", err)
-	}
-	defer db.Close()
-
-	fmt.Println("Successfully connected to database!")
-
-	// 测试连接
-	if err := testConnection(db, dbConfig.Type); err != nil {
-		log.Printf("Query test failed: %v", err)
-	} else {
-		fmt.Println("Database connection test passed!")
-	}
-}
-
-func testConnection(db *sql.DB, dbType string) error {
-	var query string
-	switch dbType {
-	case "mysql", "postgres", "sqlserver":
-		query = "SELECT 1"
-	case "oracle":
-		query = "SELECT 1 FROM DUAL"
-	default:
-		query = "SELECT 1"
-	}
+	// 创建数据库工厂
+	fmt.Printf("第1次.\n")
+	dbFactory, err := factory.GetDBFactory()
 
-	var result int
-	err := db.QueryRow(query).Scan(&result)
 	if err != nil {
-		return fmt.Errorf("test query failed: %v", err)
+		log.Fatalf("Failed to create DB factory: %v", err)
 	}
 
-	if result != 1 {
-		return fmt.Errorf("unexpected test result: %d", result)
+	//测试单例是否生效
+	fmt.Printf("第2次.\n")
+	dbFactory1, err1 := factory.GetDBFactory()
+
+	if err1 != nil {
+		log.Fatalf("Failed to create DB factory: %v", err1)
 	}
+	dbFactory1.TestConnection(dbConfig.Type)
+	defer dbFactory.Close()
+	defer dbFactory1.Close()
 
-	return nil
 }