QT mysql 数据库线程池 与数据库操作封装

windows_oracle2023-11-26 12:47

最近事情比较多很久没有写学习笔记了，数据库线程池，+ 数据库封装，虽说数据库操作有很多不需要写sql 的，ORM 封装的方式去操作数据库。但是从业这些年一直是自己动手写sql ，还是改不了这个习惯。不说了直接上代码。

数据库线程池

cpp 复制代码 
ConnectionPool.h 文件

#ifndef CONNECTIONPOOL_H
#define CONNECTIONPOOL_H

#include <QtSql>
#include <QQueue>
#include <QString>
#include <QMutex>
#include <QMutexLocker>

#include "ConnectionPool.h"

class ConnectionPool {
public:
    static void release(); // 关闭所有的数据库连接
    static QSqlDatabase createConnection();                 // 获取数据库连接
    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); // 创建数据库连接
    void initialize();
    void loadConfigFile();

public:

    QQueue<QString> usedConnectionNames;   // 已使用的数据库连接名
    QQueue<QString> unusedConnectionNames; // 未使用的数据库连接名

    QJsonObject mJsonObject;
    // 数据库信息
    QString hostName;
    QString databaseName;
    QString username;
    QString password;
    QString databaseType;
    int     port;

    bool    testOnBorrow;    // 取得连接的时候验证连接是否有效
    QString testOnBorrowSql; // 测试访问数据库的 SQL

    int maxWaitTime;  // 获取连接最大等待时间
    int waitInterval; // 尝试获取连接时等待间隔时间
    int maxConnectionCount; // 最大连接数



    static QMutex mutex;
    static QWaitCondition waitConnection;
    static ConnectionPool *instance;
};

#endif // CONNECTIONPOOL_H
cpp 复制代码 
ConnectionPool.cpp


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

QMutex ConnectionPool::mutex;
QWaitCondition ConnectionPool::waitConnection;
ConnectionPool* ConnectionPool::instance = NULL;

ConnectionPool::ConnectionPool()
{
    initialize();
}

ConnectionPool::~ConnectionPool()
{
    // 销毁连接池的时候删除所有的连接
    foreach(QString connectionName, usedConnectionNames)
    {
        QSqlDatabase::removeDatabase(connectionName);
    }

    foreach(QString connectionName, unusedConnectionNames)
    {
        QSqlDatabase::removeDatabase(connectionName);
    }
}

void ConnectionPool::loadConfigFile()
{
    QString path = qApp->applicationDirPath();
    QString strFile;
    strFile = path + "/config/DBConfig.json";
    QFile file(strFile);
    if(!file.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        qDebug() << "could't open projects json";
        return;
    }

    QString value = file.readAll();
    file.close();

    QJsonParseError parseJsonErr;
    QJsonDocument document = QJsonDocument::fromJson(value.toUtf8(), &parseJsonErr);
    if(!(parseJsonErr.error == QJsonParseError::NoError))
    {
        qDebug() << parseJsonErr.errorString();
        return;
    }

    mJsonObject=document.object();
}

void ConnectionPool::initialize()
{
    //loadConfigFile();
    hostName     = "127.0.0.1";
    databaseName = "test";
    username     = "root";
    password     = "admin";
    databaseType = "QMYSQL";
    port         = 3306;
    testOnBorrow = true;
    testOnBorrowSql = "SELECT 1";
    waitInterval = 200;
    maxWaitTime     = 5000;
    maxConnectionCount = 10;

}


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::createConnection()
{
    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();
    }

    qDebug() << "connectionCount:"<<connectionCount;
    qDebug() << "pool.maxConnectionCount:"<<pool.maxConnectionCount;
    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(port);
    if (!db.open())
    {
        qDebug() << "Open datatabase error:" << db.lastError().text();
        return QSqlDatabase();
    }

    return db;
}

数据库封装：

cpp 复制代码 
SqlDatabase.h


#ifndef SQLDATABASE_H
#define SQLDATABASE_H

#include <QJsonArray>
#include <QJsonValue>
#include <QJsonObject>

class  SqlDatabase
{
public:
    SqlDatabase();
    ~SqlDatabase();

public:
    static void InsertDB(QString strTableName,QJsonArray jsonValue);
    static void UpdateDB(QString strTableName,QJsonArray jsonValue,QString strColumnCondition);
    static int  InsertDB(QString strTableName,QJsonObject jsonValue);
    static void UpdateDB(QString strTableName,QJsonObject jsonValue,QString strCondition);
    static void QueryRecord(QString strSql,QJsonArray &nJsonValue);
    static int  QueryCount(QString strSql);
    static bool Delete(QString strSql);
    static bool Delete(QString strTableName,QString strCondition);
};

#endif // SQLDATABASE_H
cpp 复制代码 
SqlDatabase.cpp



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


#pragma execution_character_set("utf-8")

SqlDatabase::SqlDatabase()
{

}

SqlDatabase::~SqlDatabase()
{
    ConnectionPool::Destroy();
}

void SqlDatabase::InsertDB(QString strTableName,QJsonArray jsonValues)
{
    QSqlDatabase db =ConnectionPool::CreateConnection();
    QString strValues="";
    QString strNames="";
    bool iskeyName=false;
    for(int j=0;j<jsonValues.size();j++)
    {
        QJsonObject::iterator it;
        QString strKeyValue;
        QJsonObject tmpObj =jsonValues.at(j).toObject();
        for(it=tmpObj.begin();it!=tmpObj.end();it++)
        {
            if(strKeyValue.isEmpty())
            {
                if(it.value().isDouble())
                {
                    it.value()=QString::number(it.value().toDouble(),'f',12);
                }
                strKeyValue=QString("'%1'").arg(it.value().toString());
                if(!iskeyName)
                {
                    strNames=QString("%1").arg(it.key());
                }
            }
            else
            {
                if(it.value().isDouble())
                {
                    it.value()=QString::number(it.value().toDouble(),'f',12);
                }
                strKeyValue+=QString(",'%1'").arg(it.value().toString());
                if(!iskeyName)
                {
                    strNames+=QString(",%1").arg(it.key());
                }
            }
        }

        iskeyName =true;
        if(strValues.isEmpty())
        {
            strValues +="("+strKeyValue+")";
        }
        else
        {
            strValues +=",("+strKeyValue+")";
        }
    }
    QString strSql=QString("INSERT INTO %1 (%2)  VALUES %3 ").arg(strTableName).arg(strNames).arg(strValues);
    QSqlQuery query(db);
    if(!query.exec(strSql))
    {
        qDebug()<<"Failed to INSERT:"<<strSql;
    }
    ConnectionPool::CloseConnection(db);
}

void SqlDatabase::UpdateDB(QString strTableName,QJsonArray jsonValue,QString strColumnCondition)
{
	QString mHeadSql= QString(" UPDATE  %1 m,( ").arg(strTableName);
    QString mEndSql=" ) n ";
	QString mSetConditionSql="";
    QString mValueSql="";
    QString mCondition="";
    QString strSql="";
	for(int i=0;i<jsonValue.size();i++)
    {
        QJsonObject jsonObject=jsonValue.at(i).toObject();
        QJsonObject::iterator it;
        QString strValue="";
        if(!mValueSql.isEmpty())
        {
            mValueSql +=  " UNION ";
        }
        for(it=jsonObject.begin();it!=jsonObject.end();it++)
        {
            if(it.value().isDouble())
            {
                it.value()=QString::number(it.value().toDouble(),'f',3);
            }
            if(strValue =="")
			{
                strValue =QString(" SELECT '%0' as `%1`").arg(it.value().toString()).arg(it.key());
                mSetConditionSql =QString(" SET m.%0 = n.%1").arg(it.key()).arg(it.key());
			}
			else
			{
                strValue +=QString(",'%0' as `%1`").arg(it.value().toString()).arg(it.key());
                mSetConditionSql += QString(" ,m.%0 = n.%1").arg(it.key()).arg(it.key());
			}	
		}

        mValueSql += strValue;
	}

    mCondition += QString(" WHERE m.%0 = n.%1").arg(strColumnCondition).arg(strColumnCondition);

    strSql =mHeadSql +mValueSql + mEndSql + mSetConditionSql+ mCondition;
    qDebug()<<strSql;
}

int SqlDatabase::InsertDB(QString strTableName,QJsonObject jsonValue)
{
    QSqlDatabase db =ConnectionPool::CreateConnection();
    QString strValues="";
    QString strNames="";
    int nLastNum=0;
    QJsonObject::iterator it;
    for(it=jsonValue.begin();it!=jsonValue.end();it++)
    {
        if(strValues.isEmpty())
        {
            if(it.value().isDouble())
            {
                it.value()=QString::number(it.value().toDouble(),'f',12);
            }
            strValues=QString("'%1'").arg(it.value().toString());
            strNames=QString("%1").arg(it.key());
        }
        else
        {
            if(it.value().isDouble())
            {
                it.value()=QString::number(it.value().toDouble(),'f',12);
            }
            strValues+=QString(",'%1'").arg(it.value().toString());
            strNames+=QString(",%1").arg(it.key());
        }
    }
    QString strSql=QString("INSERT INTO %1 (%2)  VALUES(%3) ").arg(strTableName).arg(strNames).arg(strValues);

    QSqlQuery query(db);
    if(!query.exec(strSql))
    {
        qDebug()<<"Failed to InsertDB:"<<query.lastError().text();
    }
    else
    {
        nLastNum=query.lastInsertId().toInt();
    }

    ConnectionPool::CloseConnection(db);
    return  nLastNum;
}

void SqlDatabase::UpdateDB(QString strTableName,QJsonObject jsonValue,QString strCondition)
{
    QSqlDatabase db =ConnectionPool::CreateConnection();
    QString strValues="";
    QString strNames="";
    QJsonObject::iterator it;
    for(it=jsonValue.begin();it!=jsonValue.end();it++)
    {
        if(strValues.isEmpty())
        {
            if(it.value().isDouble())
            {
                it.value()=QString::number(it.value().toDouble(),'f',12);
            }
            strValues=QString("%1='%2'").arg(it.key()).arg(it.value().toString());
        }
        else
        {
            if(it.value().isDouble())
            {
                it.value()=QString::number(it.value().toDouble(),'f',12);
            }
            strValues+=QString(",%1='%2'").arg(it.key()).arg(it.value().toString());
        }
    }

    QString strSql=QString("UPDATE  %1  SET %2  %3 ").arg(strTableName).arg(strValues).arg(strCondition);
    QSqlQuery query(db);
    if(!query.exec(strSql))
    {
        qDebug()<<"Failed to UpdateDB:"<<query.lastError().text();
    }

    ConnectionPool::CloseConnection(db);
}

void SqlDatabase::QueryRecord(QString strSql,QJsonArray &nJsonValue)
{
    QSqlDatabase db =ConnectionPool::CreateConnection();
    QSqlQuery query(db);
    if(!query.exec(strSql))
    {
       qDebug()<<"Failed to QueryRecord:"<<query.lastError().text();
    }

    while(query.next())
    {
        QSqlRecord qResultRecord=query.record();
        QJsonObject jsonObject;
        for(int fileIndex =0; fileIndex<qResultRecord.count();fileIndex++)
        {
            if(query.value(fileIndex).isNull())
            {
                jsonObject.insert(qResultRecord.fieldName(fileIndex),QJsonValue::Null);
            }
            else if(query.value(fileIndex).type() ==QVariant::Int)
            {
                jsonObject.insert(qResultRecord.fieldName(fileIndex),query.value(fileIndex).toInt());
            }
            else if(query.value(fileIndex).type() == QVariant::Double)
            {
                jsonObject.insert(qResultRecord.fieldName(fileIndex),query.value(fileIndex).toDouble());
            }
            else if(query.value(fileIndex).type() == QVariant::LongLong)
            {
                jsonObject.insert(qResultRecord.fieldName(fileIndex),query.value(fileIndex).toLongLong());
            }
            else
            {
                jsonObject.insert(qResultRecord.fieldName(fileIndex),query.value(fileIndex).toString());
            }
        }
        nJsonValue.append(jsonObject);
    }
    ConnectionPool::CloseConnection(db);
}

int SqlDatabase::QueryCount(QString strSql)
{
   QSqlDatabase db =ConnectionPool::CreateConnection();
   QSqlQuery query(db);
   int totalCnt=0;
   QString strSqlCount=QString(" SELECT COUNT(*) AS Cnt FROM  (%1) t ").arg(strSql);
   if(!query.exec(strSqlCount))
   {
       qDebug()<<"Failed to QueryCount:"<<query.lastError().text();
   }

   while(query.next())
   {
        totalCnt=query.value("Cnt").toInt();
   }
   ConnectionPool::CloseConnection(db);
   return totalCnt;
}

bool SqlDatabase::Delete(QString strSql)
{
    bool bRet =true;
    QSqlDatabase db =ConnectionPool::CreateConnection();
    QSqlQuery query(db);
    if(!query.exec(strSql))
    {
        qDebug()<<"Failed to Delete:"<<query.lastError().text();
        bRet = false;
    }

    ConnectionPool::CloseConnection(db);
    return bRet;
}

bool SqlDatabase::Delete(QString strTableName,QString strCondition)
{
    bool bRet =true;
    QSqlDatabase db =ConnectionPool::CreateConnection();
    QSqlQuery query(db);
    QString strSql=QString(" DELETE FROM %1 %2 ").arg(strTableName).arg(strCondition);
    if(!query.exec(strSql))
    {
        qDebug()<<"Failed to Delete:"<<query.lastError().text();
        bRet = false;
    }

    ConnectionPool::CloseConnection(db);
    return bRet;
}

此处说一下批量更新

源数据是这样需要更新

id：1 shorName ：aaaaa score1:56.9 ranking :22

id：2 shorName ：bbbbb score1:89.9 score3:59.9 ranking :27

id：3 shorName ：ccccc score1:76.9 score2:81.9 ranking :29

sql 语句 批量更新

sql 复制代码 
UPDATE test m,(
	SELECT
		'1.000' AS `id`,
		'a' AS `name`,
		'22.000' AS `ranking`,
		'56.900' AS `score1`,
		'39.500' AS `score2`,
		'56.700' AS `score3`,
		'aaaa' AS `shorName` UNION
	SELECT
		'2.000' AS `id`,
		'b' AS `name`,
		'27.000' AS `ranking`,
		'89.900' AS `score1`,
		'39.500' AS `score2`,
		'59.900' AS `score3`,
		'bbbbb' AS `shorName` UNION
	SELECT
		'3.000' AS `id`,
		'c' AS `name`,
		'29.000' AS `ranking`,
		'76.900' AS `score1`,
		'72.900' AS `score2`,
		'81.900' AS `score3`,
		'ccccc' AS `shorName` 
	) n 
	SET m.id = n.id,
	m.NAME = n.NAME,
	m.ranking = n.ranking,
	m.score1 = n.score1,
	m.score2 = n.score2,
	m.score3 = n.score3,
	m.shorName = n.shorName 
WHERE
	m.id = n.id
相关推荐
masa0103 分钟前
JavaScript--JavaScript基础
开发语言·javascript
拓端研究室TRL6 分钟前
Python用TOPSIS熵权法重构粮食系统及期刊指标权重多属性决策MCDM研究|附数据代码...
开发语言·python·重构
行走的山峰9 分钟前
etcd三节点，其中一个坏掉了的恢复办法
数据库·etcd
一只特立独行的猪6111 小时前
Java面试——集合篇
java·开发语言·面试
大得3692 小时前
go注册中心Eureka，注册到线上和线下，都可以访问
开发语言·eureka·golang
shelby_loo3 小时前
通过 Docker 部署 MySQL 服务器
服务器·mysql·docker
ImomoTo3 小时前
HarmonyOS学习(十三)——数据管理(二) 关系型数据库
数据库·学习·harmonyos·arkts·鸿蒙
小珑也要变强3 小时前
队列基础概念
c语言·开发语言·数据结构·物联网
AI原吾6 小时前
掌握Python-uinput：打造你的输入设备控制大师
开发语言·python·apython-uinput
机器视觉知识推荐、就业指导6 小时前
Qt/C++事件过滤器与控件响应重写的使用、场景的不同
开发语言·数据库·c++·qt
热门推荐
01软件工程从理论到实践客观题汇总(头歌第一章至第八章)02RAG 实践- Ollama+RagFlow 部署本地知识库032024年高教社杯数学建模国赛C题超详细解题思路分析04【halcon】halcon字符识别——OCR05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提072024年网络安全比赛--系统渗透测试（超详细）08苍穹外卖面试总结09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10分享几个惊艳的 Three.js 个人站点