Qt 数据库连接池实现与管理

在 Qt 应用程序中，频繁创建和销毁数据库连接会带来显著的性能开销。数据库连接池通过复用现有连接，避免重复创建和销毁连接的开销，从而提高应用程序的响应速度和吞吐量。本文将详细介绍 Qt 中数据库连接池的实现与管理方法。

一、数据库连接池的核心概念

1. 基本原理

• 连接复用：预先创建一定数量的数据库连接，存储在池中。
• 按需分配：应用程序需要连接时从池中获取，使用完毕后返回池中而非关闭。
• 连接管理：监控连接状态，自动回收超时或失效的连接。

2. 关键组件

• 连接池类：管理连接的创建、分配和回收。
• 连接包装类：封装数据库连接，确保连接使用完毕后能正确返回池中。
• 配置类：存储连接池参数（如最大连接数、超时时间等）。

二、简单连接池的实现

以下是一个基于 Qt 的简单数据库连接池实现：

#include <QObject>
#include <QSqlDatabase>
#include <QSqlError>
#include <QString>
#include <QTimer>
#include <QQueue>
#include <QMutex>
#include <QMutexLocker>
#include <QDateTime>
#include <QDebug>

class DatabasePool : public QObject
{
    Q_OBJECT
public:
    static DatabasePool* getInstance();
    
    // 获取数据库连接
    QSqlDatabase acquireConnection(const QString &connectionName = QString());
    
    // 释放数据库连接
    void releaseConnection(const QString &connectionName);
    
    // 配置数据库连接参数
    void configure(const QString &driver, const QString &host, const QString &databaseName,
                  const QString &username, const QString &password,
                  int port = 0, int maxConnections = 10, int idleTime = 30000);
    
    // 销毁连接池
    void destroy();
    
private:
    explicit DatabasePool(QObject *parent = nullptr);
    ~DatabasePool();
    
    // 禁止拷贝和赋值
    DatabasePool(const DatabasePool&) = delete;
    DatabasePool& operator=(const DatabasePool&) = delete;
    
    // 创建新连接
    QSqlDatabase createConnection(const QString &connectionName);
    
    // 清理空闲连接
    void cleanupIdleConnections();
    
private:
    static DatabasePool* m_instance;
    static QMutex m_mutex;
    
    QString m_driver;
    QString m_host;
    QString m_databaseName;
    QString m_username;
    QString m_password;
    int m_port;
    int m_maxConnections;
    int m_idleTime;
    
    struct ConnectionInfo {
        QDateTime lastUsed;
        bool inUse;
    };
    
    QQueue<QString> m_availableConnections;
    QHash<QString, ConnectionInfo> m_connectionInfo;
    QMutex m_poolMutex;
    QTimer *m_cleanupTimer;
};

#include "databasepool.h"

DatabasePool* DatabasePool::m_instance = nullptr;
QMutex DatabasePool::m_mutex;

DatabasePool* DatabasePool::getInstance()
{
    QMutexLocker locker(&m_mutex);
    if (!m_instance) {
        m_instance = new DatabasePool();
    }
    return m_instance;
}

DatabasePool::DatabasePool(QObject *parent) : QObject(parent)
{
    m_maxConnections = 10;
    m_idleTime = 30000;  // 30秒
    
    // 初始化清理定时器
    m_cleanupTimer = new QTimer(this);
    connect(m_cleanupTimer, &QTimer::timeout, this, &DatabasePool::cleanupIdleConnections);
    m_cleanupTimer->start(10000);  // 每10秒检查一次
}

DatabasePool::~DatabasePool()
{
    destroy();
}

void DatabasePool::configure(const QString &driver, const QString &host, const QString &databaseName,
                            const QString &username, const QString &password,
                            int port, int maxConnections, int idleTime)
{
    QMutexLocker locker(&m_poolMutex);
    
    m_driver = driver;
    m_host = host;
    m_databaseName = databaseName;
    m_username = username;
    m_password = password;
    m_port = port;
    m_maxConnections = maxConnections;
    m_idleTime = idleTime;
}

QSqlDatabase DatabasePool::acquireConnection(const QString &connectionName)
{
    QMutexLocker locker(&m_poolMutex);
    
    QString name = connectionName;
    if (name.isEmpty()) {
        // 生成唯一的连接名称
        static int counter = 0;
        name = QString("Connection_%1").arg(++counter);
    }
    
    // 检查是否有可用的连接
    while (!m_availableConnections.isEmpty()) {
        QString availableName = m_availableConnections.dequeue();
        ConnectionInfo &info = m_connectionInfo[availableName];
        
        // 检查连接是否有效
        QSqlDatabase db = QSqlDatabase::database(availableName, false);
        if (db.isOpen() && db.isValid()) {
            info.inUse = true;
            info.lastUsed = QDateTime::currentDateTime();
            return db;
        } else {
            // 连接无效，移除并关闭
            QSqlDatabase::removeDatabase(availableName);
            m_connectionInfo.remove(availableName);
        }
    }
    
    // 没有可用连接，检查是否可以创建新连接
    if (m_connectionInfo.size() < m_maxConnections) {
        QSqlDatabase db = createConnection(name);
        ConnectionInfo info;
        info.inUse = true;
        info.lastUsed = QDateTime::currentDateTime();
        m_connectionInfo[name] = info;
        return db;
    }
    
    // 达到最大连接数，无法创建新连接
    qWarning() << "DatabasePool: 达到最大连接数，无法获取连接";
    return QSqlDatabase();
}

void DatabasePool::releaseConnection(const QString &connectionName)
{
    QMutexLocker locker(&m_poolMutex);
    
    if (m_connectionInfo.contains(connectionName)) {
        ConnectionInfo &info = m_connectionInfo[connectionName];
        info.inUse = false;
        info.lastUsed = QDateTime::currentDateTime();
        m_availableConnections.enqueue(connectionName);
    } else {
        qWarning() << "DatabasePool: 尝试释放不存在的连接:" << connectionName;
    }
}

QSqlDatabase DatabasePool::createConnection(const QString &connectionName)
{
    QSqlDatabase db = QSqlDatabase::addDatabase(m_driver, connectionName);
    db.setHostName(m_host);
    db.setDatabaseName(m_databaseName);
    db.setUserName(m_username);
    db.setPassword(m_password);
    if (m_port > 0) {
        db.setPort(m_port);
    }
    
    if (!db.open()) {
        qCritical() << "DatabasePool: 无法创建数据库连接:" << db.lastError().text();
        QSqlDatabase::removeDatabase(connectionName);
        return QSqlDatabase();
    }
    
    return db;
}

void DatabasePool::cleanupIdleConnections()
{
    QMutexLocker locker(&m_poolMutex);
    
    QDateTime now = QDateTime::currentDateTime();
    QList<QString> connectionsToRemove;
    
    // 查找所有空闲时间超过阈值的连接
    for (auto it = m_connectionInfo.begin(); it != m_connectionInfo.end(); ++it) {
        const QString &connectionName = it.key();
        const ConnectionInfo &info = it.value();
        
        if (!info.inUse && info.lastUsed.msecsTo(now) > m_idleTime) {
            connectionsToRemove.append(connectionName);
        }
    }
    
    // 移除并关闭这些连接
    for (const QString &connectionName : connectionsToRemove) {
        // 从可用队列中移除
        m_availableConnections.removeAll(connectionName);
        
        // 关闭并移除数据库连接
        QSqlDatabase::database(connectionName, false).close();
        QSqlDatabase::removeDatabase(connectionName);
        
        // 从连接信息中移除
        m_connectionInfo.remove(connectionName);
    }
}

void DatabasePool::destroy()
{
    QMutexLocker locker(&m_poolMutex);
    
    // 停止清理定时器
    m_cleanupTimer->stop();
    
    // 关闭并移除所有数据库连接
    for (const QString &connectionName : m_connectionInfo.keys()) {
        QSqlDatabase::database(connectionName, false).close();
        QSqlDatabase::removeDatabase(connectionName);
    }
    
    // 清空所有数据结构
    m_availableConnections.clear();
    m_connectionInfo.clear();
}

三、连接池的使用方法

1. 初始化连接池

#include "databasepool.h"

// 初始化连接池
void initDatabasePool()
{
    DatabasePool::getInstance()->configure(
        "QMYSQL",               // 数据库驱动
        "localhost",            // 主机名
        "mydatabase",           // 数据库名
        "username",             // 用户名
        "password",             // 密码
        3306,                   // 端口
        10,                     // 最大连接数
        30000                   // 空闲超时时间（毫秒）
    );
}

2. 获取和释放连接

void performDatabaseOperation()
{
    // 从连接池获取连接
    QSqlDatabase db = DatabasePool::getInstance()->acquireConnection();
    
    if (db.isOpen()) {
        // 执行数据库操作
        QSqlQuery query(db);
        query.exec("SELECT * FROM users");
        
        while (query.next()) {
            // 处理结果
            QString name = query.value("name").toString();
            qDebug() << "User:" << name;
        }
        
        // 操作完成后释放连接
        DatabasePool::getInstance()->releaseConnection(db.connectionName());
    } else {
        qCritical() << "无法获取数据库连接:" << db.lastError().text();
    }
}

3. 使用 RAII 技术自动管理连接

为了更安全地管理连接，可以创建一个 RAII（资源获取即初始化）包装类：

class DatabaseConnection {
public:
    explicit DatabaseConnection(const QString &connectionName = QString()) {
        m_db = DatabasePool::getInstance()->acquireConnection(connectionName);
    }
    
    ~DatabaseConnection() {
        if (m_db.isOpen()) {
            DatabasePool::getInstance()->releaseConnection(m_db.connectionName());
        }
    }
    
    QSqlDatabase& database() {
        return m_db;
    }
    
    bool isValid() const {
        return m_db.isOpen();
    }
    
private:
    QSqlDatabase m_db;
};

使用示例：

void safeDatabaseOperation()
{
    DatabaseConnection conn;
    if (conn.isValid()) {
        QSqlQuery query(conn.database());
        query.exec("INSERT INTO logs (message) VALUES ('Operation completed')");
    }
    // 连接会在 conn 离开作用域时自动释放
}

四、连接池的高级特性

1. 多数据库支持

扩展连接池以支持多个不同的数据库配置：

// 添加一个数据库配置
void addDatabaseConfig(const QString &configName, const QString &driver,
                      const QString &host, const QString &databaseName,
                      const QString &username, const QString &password,
                      int port = 0, int maxConnections = 10, int idleTime = 30000);

// 从指定配置获取连接
QSqlDatabase acquireConnection(const QString &configName, const QString &connectionName = QString());

2. 连接健康检查

在获取连接时检查连接是否有效：

bool isConnectionValid(const QString &connectionName)
{
    QSqlDatabase db = QSqlDatabase::database(connectionName, false);
    if (!db.isOpen()) {
        return false;
    }
    
    // 执行简单的查询检查连接是否真正可用
    QSqlQuery query("SELECT 1", db);
    return query.next();
}

3. 连接超时处理

在获取连接时添加超时机制，避免长时间等待：

QSqlDatabase acquireConnectionWithTimeout(const QString &connectionName = QString(), int timeoutMs = 5000)
{
    QMutexLocker locker(&m_poolMutex);
    
    QTime timer;
    timer.start();
    
    while (timer.elapsed() < timeoutMs) {
        // 尝试获取连接...
        
        // 如果没有可用连接，等待一段时间再试
        locker.unlock();
        QThread::msleep(100);
        locker.relock();
    }
    
    // 超时处理
    qWarning() << "DatabasePool: 获取连接超时";
    return QSqlDatabase();
}

五、性能优化与注意事项

1. 连接数配置

• 过小：会导致应用程序频繁等待连接，降低性能。
• 过大：会消耗过多数据库服务器资源，甚至导致服务器崩溃。
• 建议：根据数据库服务器配置和应用程序负载测试确定最佳连接数。

2. 线程安全

• 使用互斥锁（如 QMutex）保护共享资源（连接池）。
• 每个线程应使用独立的数据库连接，避免多线程共享同一连接。

3. 错误处理

• 捕获并记录数据库操作中的错误。
• 实现连接恢复机制，当连接失效时能够自动重新建立连接。

4. 监控与统计

• 添加连接池使用情况的统计功能（如当前连接数、等待时间等）。
• 实现监控接口，便于运行时调整连接池参数。

六、总结

数据库连接池是 Qt 应用程序中提高数据库访问性能的重要技术，通过连接复用和有效管理，可以显著减少连接创建和销毁的开销。实现一个高效、稳定的连接池需要考虑线程安全、连接健康检查、超时处理等多方面因素。合理配置和使用连接池，可以使 Qt 应用程序在处理大量数据库请求时保持高性能和稳定性。