QT数据库连接池的实现

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