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

 

#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;
}