博客

mysql.h文件

#ifndef MYSQL
#define MYSQL
 
#include <QtSql>
#include <QQueue>
#include <QString>
#include <QMutex>
#include <QMutexLocker>
#include<QDebug>
#include<QSettings>//配置文件
 
class ConnectionPool {
public:
    static void release(); // 关闭所有的数据库连接
    static QSqlDatabase openConnection();                 // 获取数据库连接
    static void closeConnection(QSqlDatabase connection); // 释放数据库连接回连接池
 
    ~ConnectionPool();
 
private:
    static ConnectionPool& getInstance();
 
    ConnectionPool();
    ConnectionPool(const ConnectionPool &other);
    ConnectionPool& operator=(const ConnectionPool &other);
    QSqlDatabase createConnection(const QString &connectionName); // 创建数据库连接
 
    QQueue<QString> usedConnectionNames;   // 已使用的数据库连接名
    QQueue<QString> unusedConnectionNames; // 未使用的数据库连接名
 
    // 数据库信息
    QString hostName;
    QString databaseName;
    QString username;
    QString password;
    QString databaseType;
 
    bool    testOnBorrow;    // 取得连接的时候验证连接是否有效
    QString testOnBorrowSql; // 测试访问数据库的 SQL
 
    int maxWaitTime;  // 获取连接最大等待时间
    int waitInterval; // 尝试获取连接时等待间隔时间
    int maxConnectionCount; // 最大连接数
 
    static QMutex mutex;
    static QWaitCondition waitConnection;
    static ConnectionPool *instance;
};
 
 
#endif // MYSQL

.cpp文件

#include "mysql.h"
#include "login.h"
//#include <QDebug>
 
 
QMutex ConnectionPool::mutex;
QWaitCondition ConnectionPool::waitConnection;
ConnectionPool* ConnectionPool::instance = NULL;
 
ConnectionPool::ConnectionPool() {
    hostName     = "localhost";//主机名
    databaseName = "quick";//需要访问的数据库
    username     = "root";//用户名
    password     = "****";//密码
    databaseType = "QMYSQL";//数据库类型
 
    testOnBorrow = true;
    testOnBorrowSql = "SELECT 1";
 
    maxWaitTime  = 1000;
    waitInterval = 200;
    maxConnectionCount  = 1000;
}
 
ConnectionPool::~ConnectionPool() {
    // 销毁连接池的时候删除所有的连接
    foreach(QString connectionName, usedConnectionNames) {
        QSqlDatabase::removeDatabase(connectionName);
    }
 
    foreach(QString connectionName, unusedConnectionNames) {
        QSqlDatabase::removeDatabase(connectionName);
    }
}
 
ConnectionPool& ConnectionPool::getInstance() {
    if (NULL == instance) {
        QMutexLocker locker(&mutex);
 
        if (NULL == instance) {
            instance = new ConnectionPool();
        }
    }
 
    return *instance;
}
 
void ConnectionPool::release() {
    QMutexLocker locker(&mutex);
    delete instance;
    instance = NULL;
}
 
QSqlDatabase ConnectionPool::openConnection() {
    ConnectionPool& pool = ConnectionPool::getInstance();
    QString connectionName;
 
    QMutexLocker locker(&mutex);
 
    // 已创建连接数
    int connectionCount = pool.unusedConnectionNames.size() + pool.usedConnectionNames.size();
 
    // 如果连接已经用完，等待 waitInterval 毫秒看看是否有可用连接，最长等待 maxWaitTime 毫秒
    for (int i = 0;
         i < pool.maxWaitTime
         && pool.unusedConnectionNames.size() == 0 && connectionCount == pool.maxConnectionCount;
         i += pool.waitInterval) {
        waitConnection.wait(&mutex, pool.waitInterval);
 
        // 重新计算已创建连接数
        connectionCount = pool.unusedConnectionNames.size() + pool.usedConnectionNames.size();
    }
 
    if (pool.unusedConnectionNames.size() > 0) {
        // 有已经回收的连接，复用它们
        connectionName = pool.unusedConnectionNames.dequeue();
    } else if (connectionCount < pool.maxConnectionCount) {
        // 没有已经回收的连接，但是没有达到最大连接数，则创建新的连接
        connectionName = QString("Connection-%1").arg(connectionCount + 1);
    } else {
        // 已经达到最大连接数
        qDebug() << "Cannot create more connections.";
        return QSqlDatabase();
    }
 
    // 创建连接
    QSqlDatabase db = pool.createConnection(connectionName);
 
    // 有效的连接才放入 usedConnectionNames
    if (db.isOpen()) {
        pool.usedConnectionNames.enqueue(connectionName);
    }
 
    return db;
}
 
void ConnectionPool::closeConnection(QSqlDatabase connection) {
    ConnectionPool& pool = ConnectionPool::getInstance();
    QString connectionName = connection.connectionName();
 
    // 如果是我们创建的连接，从 used 里删除，放入 unused 里
    if (pool.usedConnectionNames.contains(connectionName)) {
        QMutexLocker locker(&mutex);
        pool.usedConnectionNames.removeOne(connectionName);
        pool.unusedConnectionNames.enqueue(connectionName);
        waitConnection.wakeOne();
    }
}
 
QSqlDatabase ConnectionPool::createConnection(const QString &connectionName) {
    // 连接已经创建过了，复用它，而不是重新创建
    if (QSqlDatabase::contains(connectionName)) {
        QSqlDatabase db1 = QSqlDatabase::database(connectionName);
 
        if (testOnBorrow) {
            // 返回连接前访问数据库，如果连接断开，重新建立连接
            qDebug() << "Test connection on borrow, execute:" << testOnBorrowSql << ", for" << connectionName;
            QSqlQuery query(testOnBorrowSql, db1);
 
            if (query.lastError().type() != QSqlError::NoError && !db1.open()) {
                qDebug() << "Open datatabase error:" << db1.lastError().text();
                return QSqlDatabase();
            }
        }
 
        return db1;
    }
 
    // 创建一个新的连接  注意：如果需要跨线程操作时这里需要连接时需要设置个静态连接数据库
    QSqlDatabase db = QSqlDatabase::addDatabase(databaseType, connectionName);
    db.setHostName(hostName);
    db.setDatabaseName(databaseName);
    db.setUserName(username);
    db.setPassword(password);
    //db.setPort(3306);
 
    if (!db.open()) {
        qDebug() << "Open datatabase error:" << db.lastError().text();
        return QSqlDatabase();
    }
 
    return db;
}

使用方法：

#include "ConnectionPool.h"
#include <QDebug>

void foo() {
    // 1. 从数据库连接池里取得连接
    QSqlDatabase db = ConnectionPool::openConnection();

    // 2. 使用连接查询数据库
    QSqlQuery query(db);
    query.exec("SELECT * FROM user where id=1");

    while (query.next()) {
        qDebug() << query.value("username").toString();
    }

    // 3. 连接使用完后需要释放回数据库连接池
    ConnectionPool::closeConnection(db);
}

int main(int argc, char *argv[]) {
    foo();

    ConnectionPool::release(); // 4. 释放数据库连接
    return 0;
}

数据库连接池的特点

• 获取连接时不需要了解连接的名字
• 支持多线程，保证获取到的连接一定是没有被其他线程正在使用（并且连接数据库必须是静态创建）
• 按需创建连接
• 可以创建多个连接
• 可以控制连接的数量
• 连接被复用，不是每次都重新创建一个新的连接
• 连接断开了后会自动重连
• 当无可用连接时，获取连接的线程会等待一定时间尝试继续获取，直到超时才会返回一个无效的连接
• 关闭连接很简单

根据：

QT数据库连接池的实现_Swxctx的博客-CSDN博客_qt 数据库连接池

Qt QSqlDataBase数据库连接线程池_lwwl12的博客-CSDN博客