MySQL连接池

最新推荐文章于 2024-06-03 08:55:22 发布
最新推荐文章于 2024-06-03 08:55:22 发布
阅读量270 收藏
点赞数
分类专栏： MySQL 文章标签： mysql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43712886/article/details/104320479
版权

今天心血来潮，想用C++封装一套通用的Mysql连接池，支持单线程和多线程并发调用，下面是我的分享。

连接池有3个部分组成分别是：1.MySQL连接实例；2.MySQL连接管理；3.操作MySQL客户端实例。

MySQL连接实例类命名为MysqlConn，包含了数据库连接，数据库重连，管理Statement和预处理PreparedStatement等功能。

MySQL连接管理类命名为MysqlConnMgr，管理所有的连接实例，对每个实例做定时检测，确保实例可用。提供实例获取和回收接口，并且支持多线程调用。

MySQL客户端实例有两个，MysqlClient支持普通的sql调用，MysqlPreClient支持预处理语句调用。构造函数和析构函数分别实现实例获取和回收的功能。另外客户端实例类负责查询结果的内存回收，简化外部接口的调用。

以下是整个连接池的源码，都是干货，可以随手拿去用吧。

MysqlApi.h文件：

#pragma once

#include <iostream>
#include <string>
#include <sstream>
#include <list>
#include <map>
#include <mutex>
#include <mysql_connection.h>
#include <mysql_driver.h>
#include <cppconn/exception.h>
#include <cppconn/driver.h>  
#include <cppconn/connection.h>  
#include <cppconn/resultset.h>  
#include <cppconn/prepared_statement.h>  
#include <cppconn/statement.h>

namespace MysqlApi
{
	
typedef int IDType;

class MysqlClient;
class MysqlPreClient;
class MysqlConnMgr;

class MysqlConn
{
private:
	MysqlConn(){}
	~MysqlConn(){ FreeAll(); }

	bool ConnectTo(const std::string& url, const std::string& user, const std::string& passwd);

	bool Reconnect();

	bool AddPreStatement(IDType id, const std::string& stmts);

	sql::Connection* GetConn() { return m_conn; }
	
	sql::Statement* GetStatement();

	sql::PreparedStatement* GetPreStatement(IDType id);

	uint64_t GetConnectedTime() const { return m_connectedTime; }
	uint64_t GetTraceTime() const { return m_traceTime; }
	
	int GetId() const { return m_id; }
	void SetId(int id){ m_id = id; }
	
	void FreeAll();
	
	friend class MysqlClient;
	friend class MysqlPreClient;
	friend class MysqlConnMgr;

private:
	int m_id;
	std::string m_url;
	std::string m_user;
	std::string m_passwd;

	uint64_t m_traceTime     = 0;
	uint64_t m_connectedTime = 0;
	
	sql::Driver*     m_driver    = nullptr;
	sql::Connection* m_conn      = nullptr;
	sql::Statement*  m_statement = nullptr;
	
	std::map<IDType, std::string> m_strs;
	std::map<IDType, sql::PreparedStatement*> m_stmts;
};

class MysqlConnMgr
{
public:
	static MysqlConnMgr& Instance() { static MysqlConnMgr obj; return obj; }

	bool ConnectTo(IDType id, int conn_num, const std::string& url, const std::string& user, 
				   const std::string& passwd, std::map<IDType, std::string>& stmts);
				   
	void CheckConns(uint64_t curTime=0);
	
	void SetHasLock(bool hasLock) { m_hasLock = hasLock;}

	~MysqlConnMgr();

private:
	MysqlConnMgr();
	
	MysqlConn* PopConn(IDType id);
	
	void PushConn(IDType id, MysqlConn* conn);
	
	friend class MysqlClient;
	friend class MysqlPreClient;
	
	struct LockData
	{
		LockData(bool valid, std::mutex& val):valid_val(valid),mutex_val(val)
		{
			if(valid_val){mutex_val.unlock();}
		}
		
		~LockData(){ if(valid_val){mutex_val.unlock();} }
		
		bool valid_val = false;
		std::mutex& mutex_val;
	};
	
private:
	std::mutex m_mutex;
	bool m_hasLock = false;
	uint64_t m_traceTime = 0;	
	std::map<IDType, std::list<MysqlConn*> > m_conns;
};

class MysqlClient
{
public:
	MysqlClient(IDType id);
	~MysqlClient();

	bool Execute(const std::string& sql);
	sql::ResultSet * ExecuteQuery(const std::string& sql);
	int ExecuteUpdate(const std::string& sql);

	uint64_t GetUpdateCount();

private:
	IDType m_id;
	MysqlConn* m_conn = nullptr;
	sql::Statement* m_statement = nullptr;
	std::list<sql::ResultSet*> m_resList;
};

class MysqlPreClient
{
public:
	MysqlPreClient(IDType id, IDType preId);
	~MysqlPreClient();

	bool Execute();
	sql::ResultSet *ExecuteQuery();
    int ExecuteUpdate();
	
	void ClearParameters();

	void SetBigInt(const std::string& value);

	void SetBlob(std::istream * blob);

	void SetBoolean(bool value);

	void SetDateTime(const std::string& value);

	void SetDouble(double value);

	void SetInt(int32_t value);

	void SetUInt(uint32_t value);

	void SetInt64(int64_t value);

	void SetUInt64(uint64_t value);

	void SetNull(int sqlType);

	void SetString(const std::string& value);

private:
	IDType m_id;
	IDType m_preId;
	
	unsigned int m_index = 0;
	MysqlConn * m_conn = nullptr;
	sql::PreparedStatement* m_preState = nullptr;
	std::list<sql::ResultSet*> m_resList;
};

}

MysqlApi.cc文件：

#include "MysqlApi.h"

namespace MysqlApi
{
//
bool MysqlConn::ConnectTo(const std::string& url, const std::string& user, const std::string& passwd)
{
	m_url    = url;
	m_user   = user;
	m_passwd = passwd;

	m_driver = sql::mysql::get_driver_instance();
	if (m_driver)
	{
		m_conn = m_driver->connect(m_url, m_user, m_passwd);
		if (m_conn == nullptr)
		{
			//TODO LOG
			return false;
		}
		
		m_statement     = m_conn->createStatement();
		m_connectedTime = (uint64_t)time(NULL);
		return true;
	}
	else
	{
		//TODO LOG
		return false;
	}
}

bool MysqlConn::Reconnect()
{
	FreeAll();
	
	if ( ConnectTo(m_url, m_user, m_passwd) )
	{
		std::map<IDType, std::string> copy_strs;
		copy_strs.swap(m_strs);
		for(auto &it : copy_strs)
		{
			AddPreStatement(it.first, it.second);
		}
		return true;
	}
	return false;
}

bool MysqlConn::AddPreStatement(IDType id, const std::string& stmts)
{
	sql::PreparedStatement* tVal = m_conn->prepareStatement(stmts);
	if (!tVal)
	{
		//TODO LOG
		return false;
	}

	auto it = m_stmts.find(id);
	if (it != m_stmts.end())
	{
		delete it->second;
		it->second = tVal;
	}
	else
	{
		m_stmts[id] = tVal;
	}
	
	m_strs[id] = stmts;
	return true;
}

sql::Statement* MysqlConn::GetStatement() 
{ 
	m_traceTime = (uint64_t)time(NULL); 
	return m_statement; 
}

sql::PreparedStatement* MysqlConn::GetPreStatement(IDType id)
{
	auto it = m_stmts.find(id);
	if (it != m_stmts.end())
	{
		it->second->clearParameters();
		m_traceTime = time(NULL);
		return it->second;
	}
	return nullptr;
}

void MysqlConn::FreeAll()
{
	for(auto &it : m_stmts)
	{
		delete it.second;
		it.second = nullptr;
	}
	m_stmts.clear();
	
	if (m_statement)
	{
		delete m_statement;
		m_statement = nullptr;
	}
	
	if (m_conn)
	{
		m_conn->close();
		delete m_conn;
		m_conn = nullptr;
	}
}

///
MysqlConnMgr::~MysqlConnMgr()
{
	LockData temp_lock(m_hasLock, m_mutex);
	
	for(auto &it : m_conns)
	{
		for (auto it_list = it.second.begin(); it_list != it.second.end(); it_list++)
		{
			delete (*it_list);
			(*it_list) = nullptr;
		}
		it.second.clear();
	}
	m_conns.clear();
}

MysqlConnMgr::MysqlConnMgr()
{
	m_traceTime   = (uint64_t)time(NULL);
}

bool MysqlConnMgr::ConnectTo(IDType id, int conn_num, const std::string& url, const std::string& user, 
							const std::string& passwd, std::map<IDType, std::string>& stmts)
{
	for(int i = 0; i < conn_num; i++)
	{
		MysqlConn* newConn = new MysqlConn();
		
		if ( !newConn->ConnectTo(url, user, passwd) )
		{
			delete newConn;
			newConn = nullptr;
			return false;
		}
		
		for(auto &it : stmts)
		{
			if( !newConn->AddPreStatement(it.first, it.second) )
			{
				delete newConn;
				newConn = nullptr;
				return false;				
			}
		}
		
		newConn->SetId(i + 1);

		LockData temp_lock(m_hasLock, m_mutex);
		
		std::list<MysqlConn*>& list_data = m_conns[id];
		list_data.push_back(newConn);
		
	}
	return true;
}

MysqlConn* MysqlConnMgr::PopConn(IDType id)
{
	LockData temp_lock(m_hasLock, m_mutex);
	
	auto it = m_conns.find(id);
	if( it != m_conns.end() )
	{
		if( !it->second.empty())
		{
			MysqlConn* conn = it->second.front();
			it->second.pop_front();
			return conn;
		}
	}
	return nullptr;
}
	
void MysqlConnMgr::PushConn(IDType id, MysqlConn* conn)				
{
	if(!conn){
		return;
	}
	
	LockData temp_lock(m_hasLock, m_mutex);
	
	auto it = m_conns.find(id);
	if( it != m_conns.end() )
	{
		for (auto it_list = it->second.begin(); it_list != it->second.end(); it_list++)
		{
			if( conn->GetId() == (*it_list)->GetId() ){
				return;
			}
		}
		it->second.push_back(conn);
	} 
	else 
	{
		delete conn;
		conn = nullptr;
	}
}

void MysqlConnMgr::CheckConns(uint64_t curTime)
{
	if (0 == curTime)
	{
		curTime = (uint64_t)time(NULL);
	}
	
	if(m_traceTime + 60 > curTime)
	{
		return;
	}
	
	m_traceTime = curTime;
	
	static uint64_t check_reconnect_time = 3600 * 7;
	
	LockData temp_lock(m_hasLock, m_mutex);
	
	for(auto it = m_conns.begin(); it != m_conns.end(); it++)
	{
		for(auto it_list = it->second.begin(); it_list != it->second.end(); it_list++)
		{
			if( (*it_list)->GetTraceTime() + check_reconnect_time < m_traceTime)
			{
				(*it_list)->Reconnect();
			}
		}
	}
}

/
MysqlClient::MysqlClient(IDType id)
{
	m_id = id;
	
	m_conn = MysqlConnMgr::Instance().PopConn(m_id);
	if (m_conn)
	{
		m_statement = m_conn->GetStatement();
	}
}

MysqlClient::~MysqlClient()
{
	for (auto it = m_resList.begin(); it != m_resList.end(); it++)
	{
		delete (*it);
		(*it) = nullptr;
	}
	m_resList.clear();
	
	if(m_conn)
	{
		MysqlConnMgr::Instance().PushConn(m_id, m_conn);
	}
}

bool MysqlClient::Execute(const std::string& sql)
{
	if (m_statement)
	{
		return m_statement->execute(sql);
	}
	return false;
}

sql::ResultSet* MysqlClient::ExecuteQuery(const std::string& sql)
{
	if (m_statement)
	{
		sql::ResultSet* retRes = m_statement->executeQuery(sql);
		if (retRes)
		{
			m_resList.push_back(retRes);
		}
		return retRes;
	}
	return nullptr;
}
int MysqlClient::ExecuteUpdate(const std::string& sql)
{
	if (m_statement)
	{
		return m_statement->executeUpdate(sql);
	}
	return -1;
}

uint64_t MysqlClient::GetUpdateCount()
{
	if (m_statement)
	{
		return m_statement->getUpdateCount();
	}
	return 0;
}

/
MysqlPreClient::MysqlPreClient(IDType id, IDType preId)
{
	m_id = id;
	m_preId = preId;
	
	m_conn = MysqlConnMgr::Instance().PopConn(m_id);
	if (m_conn)
	{
		m_preState = m_conn->GetPreStatement(m_preId);
		if(m_preState)
		{
			ClearParameters();
		}
	}
}

MysqlPreClient::~MysqlPreClient()
{
	for (auto it = m_resList.begin(); it != m_resList.end(); it++)
	{
		delete (*it);
		(*it) = nullptr;
	}
	m_resList.clear();
	
	if(m_conn)
	{
		MysqlConnMgr::Instance().PushConn(m_id, m_conn);
	}
}

void MysqlPreClient::ClearParameters()
{
	m_index = 0;
	m_preState->clearParameters();	
}

bool MysqlPreClient::Execute()
{
	if (m_preState)
	{
		return m_preState->execute();
	}
	return false;
}

sql::ResultSet *MysqlPreClient::ExecuteQuery()
{
	if (m_preState)
	{
		sql::ResultSet* retRes = m_preState->executeQuery();
		if (retRes)
		{
			m_resList.push_back(retRes);
		}

		return retRes;
	}
	return nullptr;
}

int MysqlPreClient::ExecuteUpdate()
{
	if (m_preState)
	{
		return m_preState->executeUpdate();
	}
	return -1;
}

void MysqlPreClient::SetBigInt(const std::string& value)
{
	if (m_preState)
	{
		m_preState->setBigInt(m_index++, value);
	}
}

void MysqlPreClient::SetBlob(std::istream * blob)
{
	if (m_preState)
	{
		m_preState->setBlob(m_index++, blob);
	}
}

void MysqlPreClient::SetBoolean(bool value)
{
	if (m_preState)
	{
		m_preState->setBoolean(m_index++, value);
	}
}

void MysqlPreClient::SetDateTime(const std::string& value)
{
	if (m_preState)
	{
		m_preState->setDateTime(m_index++, value);
	}
}

void MysqlPreClient::SetDouble(double value)
{
	if (m_preState)
	{
		m_preState->setDouble(m_index++, value);
	}
}

void MysqlPreClient::SetInt(int32_t value)
{
	if (m_preState)
	{
		m_preState->setInt(m_index++, value);
	}
}

void MysqlPreClient::SetUInt(uint32_t value)
{
	if (m_preState)
	{
		m_preState->setUInt(m_index++, value);
	}
}

void MysqlPreClient::SetInt64(int64_t value)
{
	if (m_preState)
	{
		m_preState->setInt64(m_index++, value);
	}
}

void MysqlPreClient::SetUInt64(uint64_t value)
{
	if (m_preState)
	{
		m_preState->setUInt64(m_index++, value);
	}
}

void MysqlPreClient::SetNull(int sqlType)
{
	if (m_preState)
	{
		m_preState->setNull(m_index++, sqlType);
	}
}

void MysqlPreClient::SetString(const std::string& value)
{
	if (m_preState)
	{
		m_preState->setString(m_index++, value);
	}
}

}
weixin_43712886
关注
专栏目录
connection 连接mysql_用connection对象连接数据库
weixin_35920143的博客
01-30 5344
本文将详细介绍如何使用connection对象连接数据库。对于不同的.net数据提供者，ado.net采用不同的connection对象连接数据库。这些connection对象为我们屏蔽了具体的实现细节，并提供了一种统一的实现方法。connection类有四种：sqlconnection，oledbconnection，odbcconnection和oracleconnection。sqlconn...
mysql connection.h_MySQL connector c++使用笔记
weixin_30363285的博客
01-26 289
ConnectionDriverPreparedStatementResultSetResultSetMetaDataStatement下载安装mysql connector c++, 启动mysql, 使用test database.准备数据(使用官方提供的示例数据, 参考 MySQL手册 3.3.3 http://dev.mysql.com/doc/refman/5.1/zh/tutorial...
MySql_connection
仙优的专栏
01-31 112
--------------------------------------------------http://dev.mysql.com/downloads 1.MySQL Server 5.12.Navicat 8 for MySQL （数据库交互工具）-------------------------------------------------- package com; impo...
mysql connection.h_连接mysql数据库
weixin_30855927的博客
02-01 676
#include#include#include#includeusingnamespacestd;intmain(){//connectionparamsFILE*file;char*host="localhost";char*user="root";char*pass="123456";char*db="mysql";//sockMYSQL*...
MySQL JDBC 及其连接池
longge0508的博客
05-03 1887
JDBC JDBC，即Java数据库连接，是SUN公司推出的Java访问数据库的标准规范（接口）。 1. JDBC是一种用于执行SQL语句的Java API。 2. JDBC可以为多种关系数据库提供统一访问入口。 3. JDBC是由一组Java工具类和接口组成。 JDBC开发步骤 1. 注册驱动。 2. 获得连接。 3. 获得语句执行者。 4. 执行sql语句。 5. 处理...
MySQL-连接池
m0_52975065的博客
10-11 575
最小连接数: 是数据库一直保持的数据库连接数，所以如果应用程序对数据库连接的使用量不大，将有大量的数据库 资源被浪费。 初始化连接数： 连接池启动时创建的初始化数据库连接数量。 最大连接数： 是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求被加入到等待队 列中。 最大等待时间： 当没有可用连接时，连接池等待连接被归还的最大时间，超过时间则抛出异常，可设置参数为0或者负 数使得无限等待(根据不同连接池配置)。 数据库连接池在初始化的时候会创建initialSize个连接，当有数据库
【MySQL】mysql连接池
迷途书生的博客
01-24 2217
1、对象池简介 对象池中包含若干提前准备好的若干实例，当需要时从对象池中提取，当不需要时，则重新放入对象池。一方面，使用对象池不需要频繁的产生和销毁实例对象，另一方面，对象池中的实例如果不够程序调用才会继续产生实例，这大大节省了性能。 2、数据库连接池简介 据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。 3、为
nodejs封装好的mysql数据库模块，带mysql连接池以及百万测试数据
08-07
本模块基于Node.js实现了对MySQL数据库的封装，利用了mysql连接池来优化性能，并且包含了用于测试的百万级数据，确保了在大数据量场景下的稳定性和效率。以下将详细介绍该模块的关键知识点： 1. **Node.js与MySQL**...
mysql连接池
06-29
MySQL连接池是数据库管理中的一个重要概念，主要用于优化数据库应用程序的性能和效率。它是一组预先建立的数据库连接，这些连接可以被多个用户或线程共享，而不是为每次数据库操作都创建新的连接。这样做的好处是...
workerman写mysql连接池的实例代码
01-19
首先要了解为什么用连接...由于PHP是单进程单线程的，使用PHP实现数据库连接池，肯定需要用单独的进程去做，那么就会涉及到进程间的通讯，使得原本和mysql直接通讯的过程变成 与连接池再到mysql的通讯，增加了应用端的
mysql——connection -jdbc
03-28
同名字，mysql的连接的jdbc 在做其他软件连接mysql的时候尤其是odbc数据源的时候用得到，
mysql-connection.rar
10-28
delphi7---delphi xe10.3.2 使用libmysql.dll连接MySQL数据库 无需ODBC及其MySQL ODBC 3.51 Driver驱动
jdbc-mysql-connection
03-12
官网下载的mysql驱动包jdbc (有50个字节了没有50个字节了没有50个字节了没)
MySQL连接池-易语言
06-11
MySQL连接池是数据库管理中的一个重要概念，特别是在使用易语言进行编程时，理解并正确使用连接池可以显著提高程序性能和资源利用率。易语言是一种中国本土的编程语言，它以其直观的语法和丰富的库支持，使得数据库...
【MySQL】MySQL Connect -- 详解
最新发布
Elena's Blog
06-03 2398
使用。
mysql_connect函数解释
sout的博客
05-22 5006
(PHP 4, PHP 5) mysql_connect — 打开一个到 MySQL 服务器的连接 Warning 本扩展自 PHP 5.5.0 起已废弃，并在自 PHP 7.0.0 开始被移除。应使用 MySQLi 或 PDO_MySQL 扩展来替换之。参见 MySQL：选择 API 指南以及相关 FAQ 来获取更多信息。用以替代本函数的有： mysqli_connect() PDO:...
mysql的connection对象_4.3.1 通过Connection对象建立数据库连接
weixin_39586683的博客
02-28 981
4.3.1 通过Connection对象建立数据库连接Connection对象代表与数据库的连接。连接过程包括所执行的SQL语句和在该连接上所返回的结果。一个应用程序可与单个数据库有一个或多个连接，或者可与许多数据库有连接。图4-2 JDBC API结构关系图1. JDBC连接URLJDBC URL提供了一种标识数据库的方法，可以使相应的驱动程序能识别该数据库并与之建立连接。JDBC URL的...
mysql connection.h_mysql -h localhost和mysql -h 127.0.0.1的区别
weixin_42181693的博客
01-26 140
标签：今天早上同事说MySQL root账号登录不上了。我试了一下#mysql -u root -p提示”Access denied for user ‘root’@’localhost’ (using password: YES)”因为年后有同事离职，我第一反应是谁修改了root密码？按照忘记root密码来重置一下密码：#/etc/init.d/mysql stop#mysqld_safe –s...
java mysql connection
jovigu
08-06 1418
/*File Jdbc10.javaCopyright 2004, R.G.BaldwinRev 09/16/04The purpose of this program is to test theability to use JDBC to access a MySQL database
VC++实现双队列MySQL连接池
"VC++双队列连接池用于优化对MySQL数据库的访问，采用STL容器list实现连接池管理，确保高效复用数据库连接。" 在VC++开发中，为了提高应用程序对MySQL数据库的访问效率，可以使用连接池技术。连接池是一种管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值