C++抽象工厂模式在跨数据库访问中的实践方案-源码库

C++抽象工厂模式在跨数据库访问中的实践方案：一套代码兼容多种数据库的架构设计

作为一名长期奋战在一线的C++开发者，我经历过太多因为数据库迁移而导致的代码重构噩梦。记得有一次项目从MySQL切换到PostgreSQL，整个团队花了整整两周时间修改数据库访问层，那种痛苦至今记忆犹新。正是这样的经历让我深入研究了抽象工厂模式在跨数据库访问中的应用，今天就来分享这套经过实战检验的解决方案。

为什么选择抽象工厂模式

在跨数据库访问的场景中，我们面临的核心问题是：不同数据库的API接口、连接方式、SQL语法都存在差异。如果直接在业务代码中硬编码特定数据库的实现，一旦需要切换数据库，修改成本将非常巨大。

抽象工厂模式的精髓在于提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。在数据库访问场景中，这意味着我们可以为每种数据库创建一个具体的工厂，每个工厂负责创建该数据库对应的连接对象、命令对象、数据读取器对象等。

经过多个项目的实践，我发现这种模式带来了三个显著优势：

解耦业务逻辑与数据库实现：业务代码只依赖抽象接口，不关心具体数据库类型
易于扩展：新增数据库支持只需添加新的具体工厂，无需修改现有代码
统一接口：所有数据库操作使用相同的接口，降低学习成本

架构设计与核心接口定义

首先我们需要设计一套统一的抽象接口，这是整个架构的基石。经过多次迭代，我总结出了以下几个核心接口：

// 数据库连接抽象接口
class IDBConnection {
public:
    virtual ~IDBConnection() = default;
    virtual bool connect(const std::string& connectionString) = 0;
    virtual bool disconnect() = 0;
    virtual bool execute(const std::string& sql) = 0;
};

// 数据库命令抽象接口  
class IDBCommand {
public:
    virtual ~IDBCommand() = default;
    virtual bool setConnection(std::shared_ptr connection) = 0;
    virtual bool setCommandText(const std::string& commandText) = 0;
    virtual std::shared_ptr executeReader() = 0;
    virtual int executeNonQuery() = 0;
};

// 数据读取器抽象接口
class IDataReader {
public:
    virtual ~IDataReader() = default;
    virtual bool read() = 0;
    virtual int getInt(int index) = 0;
    virtual std::string getString(int index) = 0;
    // 其他数据类型获取方法...
};

// 抽象工厂接口
class IDBFactory {
public:
    virtual ~IDBFactory() = default;
    virtual std::shared_ptr createConnection() = 0;
    virtual std::shared_ptr createCommand() = 0;
    virtual std::shared_ptr createDataReader() = 0;
};

这里有个重要的设计决策：我选择使用智能指针来管理对象生命周期，避免了手动内存管理的复杂性。在实际项目中，这个决策大大减少了内存泄漏的问题。

具体数据库实现

有了抽象接口，接下来就是为不同的数据库实现具体类。以MySQL和PostgreSQL为例：

// MySQL具体工厂
class MySQLFactory : public IDBFactory {
public:
    std::shared_ptr createConnection() override {
        return std::make_shared();
    }
    
    std::shared_ptr createCommand() override {
        return std::make_shared();
    }
    
    std::shared_ptr createDataReader() override {
        return std::make_shared();
    }
};

// MySQL连接实现
class MySQLConnection : public IDBConnection {
private:
    MYSQL* mysql_;

public:
    MySQLConnection() : mysql_(nullptr) {}
    
    bool connect(const std::string& connectionString) override {
        // 解析连接字符串
        // 初始化MySQL连接
        mysql_ = mysql_init(nullptr);
        return mysql_real_connect(mysql_, host.c_str(), user.c_str(), 
                                password.c_str(), database.c_str(), port, nullptr, 0);
    }
    
    bool execute(const std::string& sql) override {
        return mysql_query(mysql_, sql.c_str()) == 0;
    }
    
    // 其他方法实现...
};

// PostgreSQL工厂和具体类实现类似，这里省略...

在实际开发中，我建议将不同数据库的实现放在独立的命名空间中，避免命名冲突。同时，要注意不同数据库在事务处理、连接池管理等方面的差异，在具体实现中处理好这些细节。

工厂选择与配置管理

如何动态选择使用哪个数据库工厂？我通常采用配置文件+简单工厂模式的方式：

class DBFactorySelector {
public:
    static std::shared_ptr createFactory(const std::string& dbType) {
        if (dbType == "mysql") {
            return std::make_shared();
        } else if (dbType == "postgresql") {
            return std::make_shared();
        } else if (dbType == "sqlite") {
            return std::make_shared();
        }
        throw std::runtime_error("Unsupported database type: " + dbType);
    }
};

配置文件可以使用JSON格式：

{
    "database": {
        "type": "mysql",
        "connectionString": "host=localhost;user=root;password=123456;database=test"
    }
}

实战应用示例

让我们看一个完整的用户查询示例：

class UserRepository {
private:
    std::shared_ptr factory_;
    
public:
    UserRepository(const std::string& dbType) {
        factory_ = DBFactorySelector::createFactory(dbType);
    }
    
    User getUserById(int id) {
        auto connection = factory_->createConnection();
        auto command = factory_->createCommand();
        
        if (!connection->connect(connectionString)) {
            throw std::runtime_error("Database connection failed");
        }
        
        command->setConnection(connection);
        command->setCommandText("SELECT * FROM users WHERE id = " + std::to_string(id));
        
        auto reader = command->executeReader();
        if (reader->read()) {
            User user;
            user.id = reader->getInt(0);
            user.name = reader->getString(1);
            return user;
        }
        
        throw std::runtime_error("User not found");
    }
};

踩坑与优化建议

在多个项目实践中，我积累了一些宝贵的经验教训：

连接管理优化：频繁创建销毁连接会影响性能。我建议引入连接池模式，在工厂中维护连接池：

class ConnectionPool {
private:
    std::queue> pool_;
    
public:
    std::shared_ptr getConnection() {
        if (pool_.empty()) {
            return factory_->createConnection();
        }
        auto conn = pool_.front();
        pool_.pop();
        return conn;
    }
    
    void returnConnection(std::shared_ptr conn) {
        pool_.push(conn);
    }
};

SQL方言处理：不同数据库的SQL语法存在差异，特别是分页查询。我建议将常见的方言差异封装在具体命令类中：

// 在具体命令类中处理分页差异
class MySQLCommand : public IDBCommand {
public:
    std::string buildPagedQuery(const std::string& baseSql, int page, int pageSize) {
        return baseSql + " LIMIT " + std::to_string(pageSize) + 
               " OFFSET " + std::to_string((page - 1) * pageSize);
    }
};

异常处理：不同数据库的异常信息格式不同，建议在具体实现中统一异常类型，便于上层处理。