手写连接池--包含Window下使用VS进行开发对MySQL的相关配置

于 2024-08-19 10:41:37 发布
阅读量360 收藏 16
点赞数 11
分类专栏： 手写连接池 文章标签： 连接池 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73537205/article/details/141034573
版权

在实际的项目中，使用线连接池是非常广泛的，所以最近学习了连接池的开发，在此做一个总结。

目的

为了提高MySQL数据库(基于C/S设计)的访问瓶颈，除了在服务器端增加缓存服务器缓存常用的数据之外(例如redis)，还可以增加连接池，来提高MySQLServer的访问效率，在高并发情况下，大量的TCP三次握手、MySQL Server连接认证、MySQL Server关闭连接回收资源和TCP四次挥手所耗费的性能时间也是很明显的，增加连接池就是为了减少这一部分的性能损耗。

那么本项目就是为了在C/C++项目中，提供MySQL Server的访问效率，实现基于C++代码的数据库连接池模块，也是一个通用的连接池模型。

功能点

连接池一般包含了数据库连接所用的ip地址、port端口号、用户名和密码以及其它的性能参数，例如初始连接量，最大连接量，最大空闲时间、连接超时时间等，该项目是基于C++语言实现的连接池，主要也是实现以上几个所有连接池都支持的通用基础功能。

  • 初始连接量(initsize)):表示连接池事先会和MySQLServer创建initSize个数的connection连接，当应用发起MySQL访问时，不用再创建和MySQLServer新的连接，直接从连接池中获取一个可用的连接就可以，使用完成后，并不去释放connection，而是把当前connection再归还到连接池当中。
  • 最大连接量(maxsize):当并发访问MySQLServer的请求增多时，初始连接量已经不够使用了，此时会根据新的请求数量去创建更多的连接给应用去使用，但是新创建的连接数量上限是maxSize，不能无限制的创建连接，因为每一个连接都会占用一个socket资源，一般连接池和服务器程序是部署在一台主机上的，如果连接池占用过多的socket资源，那么服务器就不能接收太多的客户端请求了。当这些连接使用完成后，再次归还到连接池当中来维护。
  • 最大空闲时间(maxldleTime):当访问MSQL的并发请求多了以后，连接池里面的连接数量会动态增加，上限是maxSize个，当这些连接用完再次归还到连接池当中。如果在指定的maxldleTime里面这些新增加的连接都没有被再次使用过，那么新增加的这些连接资源就要被回收掉，只需要保持初始连接量initSize个连接就可以了。
  • 连接超时时间(connectionTimeout):当MVSOL的并发请求量过大，连接池中的连接数量已经到达maxSize了，而此时没有空闲的连接可供使用，那么此时应用从连接池获取连接无法成功，它通过阻塞的方式获取连接的时间如果超过connectionTimeout时间，那么获取连接失败，无法访问数据库。
    该项目主要实现上述的连接池四大功能，其余连接池更多的扩展功能，可以自行实现。

功能实现设计

ConnectionPool.cpp和ConnectionPool.h:连接池代码实现Connection.cpp和Connection.h:数据库操作代码、增删改查代码实现

连接池主要包含了以下功能点:

  1. 连接池只需要一个实例，所以ConnectionPool以单例模式进行设计
  2. 从ConnectionPool中可以获取和MySQL的连接Connection
  3. 空闲连接Connection全部维护在一个线程安全的Connection队列中，使用线程互斥锁保证队列的线程安全
  4. 如果Connection队列为空，还需要再获取连接，此时需要动态创建连接，上限数量是maxSize
  5. 在独立的线程中确保队列中空闲连接时间超过maxldleTime的就要被释放掉，只保留初始的initSize个连接就可以
  6. 如果Connection队列为空，而此时连接的数量已达上限maxSize，那么等待connectionTimeout时间如果还获取不到空闲的连接，那么获取连接失败，此处从Connection队列获取空闲连接，可以使用带超时时间的mutex互斥锁来实现连接超时时间
  7. 用户获取的连接用shared_ptr智能指针来管理，用lambda表达式定制连接释放的功能(不真正释放连接，而是把连接归还到连接池中)
  8. 连接的生产和连接的消费采用生产者-消费者线程模型来设计，使用了线程间的同步通信机制条件变量和互斥锁。

配置文件

#数据库连接池的配置文件
ip=127.0.0.1
port=3306
username=root
password=xxxxxx//自己数据库的密码
dbname=chatp
initSize=10
maxSize=1024
#最大空闲时间默认单位是秒
maxIdleTime=60
#连接超时时间单位是毫秒
connectionTimeOut=100

MySQL数据库C++代码–对应Connection.cpp中

Connection::Connection()
{
	// 初始化数据库连接
	_conn = mysql_init(nullptr);
}

Connection::~Connection()
{
	// 释放数据库连接资源
	if (_conn != nullptr)
		mysql_close(_conn);
}

bool Connection::connect(string ip, unsigned short port, 
	string username, string password, string dbname)
{
	// 连接数据库
	MYSQL *p = mysql_real_connect(_conn, ip.c_str(), username.c_str(),
		password.c_str(), dbname.c_str(), port, nullptr, 0);
	return p != nullptr;
}

bool Connection::update(string sql)
{
	// 更新操作 insert、delete、update
	if (mysql_query(_conn, sql.c_str()))
	{
		LOG("更新失败:" + sql);
		return false;
	}
	return true;
}

MYSQL_RES* Connection::query(string sql)
{
	// 查询操作 select
	if (mysql_query(_conn, sql.c_str()))
	{
		LOG("查询失败:" + sql);
		return nullptr;
	}
	return mysql_use_result(_conn);
}

Connection.h

#pragma once
#ifndef CONNECTION_H
#define CONNECTION_H
#include <mysql/mysql.h>
#include <string>
#include <ctime>
using namespace std;

/*
实现MySQL数据库的操作
*/
class Connection
{
public:
	// 初始化数据库连接
	Connection();
	// 释放数据库连接资源
	~Connection();
	// 连接数据库
	bool connect(string ip, 
		unsigned short port, 
		string user, 
		string password,
		string dbname);
		
	// 更新操作 insert、delete、update
	bool update(string sql);
	// 查询操作 select
	MYSQL_RES* query(string sql);

	// 刷新一下连接的起始的空闲时间点
	void refreshAliveTime() { _alivetime = clock(); }
	// 返回存活的时间也就是空闲的总时间 当前时间-空闲起始时间
	clock_t getAliveeTime() const { return clock() - _alivetime; }
private:
	MYSQL *_conn; // 表示和MySQL Server的一条连接
	clock_t _alivetime; // 记录进入空闲状态后（进入队列）的起始存活时间
};

#endif

连接池CommonConnectionPool.cpp

重要成员变量

string _ip; // mysql的ip地址
unsigned short _port; // mysql的端口号 3306
string _username; // mysql登录用户名
string _password; // mysql登录密码
string _dbname; // 连接的数据库名称
int _initSize; // 连接池的初始连接量
int _maxSize; // 连接池的最大连接量
int _maxIdleTime; // 连接池最大空闲时间
int _connectionTimeout; // 连接池获取连接的超时时间

queue<Connection*> _connectionQue; // 存储mysql连接的队列
mutex _queueMutex; // 维护连接队列的线程安全互斥锁
atomic_int _connectionCnt; // 记录连接所创建的connection连接的总数量 
condition_variable cv; // 设置条件变量，用于连接生产线程和连接消费线程的通信
};
  • 作用如备注

重要成员函数

获取单例连接池对象

//1. 构造函数私有化
...
private:
	// 单例#1 构造函数私有化
	ConnectionPool();
...
//2. 获取单例接口
ConnectionPool* ConnectionPool::getConnectionPool()
{
	static ConnectionPool pool; // lock和unlock
	return &pool;
}

从配置文件中加载配置项

bool ConnectionPool::loadConfigFile()
{
	FILE *pf = fopen("/root/conn_Pool/src/mysql.ini", "r");
	if (pf == nullptr)
	{
		LOG("mysql.ini file is not exist!");
		return false;
	}

	while (!feof(pf))
	{
		char line[1024] = { 0 };
		fgets(line, 1024, pf);
		string str = line;//char转变为string
		int idx = str.find('=', 0);
		if (idx == -1) // 无效的配置项
		{
			continue;
		}

		// password=123456\n
		int endidx = str.find('\n', idx);
		string key = str.substr(0, idx);
		string value = str.substr(idx + 1, endidx - idx - 1);

		if (key == "ip")
		{
			_ip = value;
		}
		else if (key == "port")
		{
			_port = atoi(value.c_str());
		}
		else if (key == "username")
		{
			_username = value;
		}
		else if (key == "password")
		{
			_password = value;
		}
		else if (key == "dbname")
		{
			_dbname = value;
		}
		else if (key == "initSize")
		{
			_initSize = atoi(value.c_str());
		}
		else if (key == "maxSize")
		{
			_maxSize = atoi(value.c_str());
		}
		else if (key == "maxIdleTime")
		{
			_maxIdleTime = atoi(value.c_str());
		}
		else if (key == "connectionTimeOut")
		{
			_connectionTimeout = atoi(value.c_str());
		}
	}
	return true;
}

构造连接池

ConnectionPool::ConnectionPool()
{
	// 加载配置项了
	if (!loadConfigFile())
	{
		return;
	}

	// 创建初始数量的连接
	for (int i = 0; i < _initSize; ++i)
	{
		Connection *p = new Connection();
		p->connect(_ip, _port, _username, _password, _dbname);
		p->refreshAliveTime(); // 刷新一下开始空闲的起始时间
		_connectionQue.push(p);
		_connectionCnt++;
	}

	thread produce(std::bind(&ConnectionPool::produceConnectionTask, this));
	produce.detach();

	thread scanner(std::bind(&ConnectionPool::scannerConnectionTask, this));
	scanner.detach();
}

生产新连接

void ConnectionPool::produceConnectionTask()
{
	for (;;)
	{
		unique_lock<mutex> lock(_queueMutex);
		while (!_connectionQue.empty())
		{
			cv.wait(lock); // 队列不空，此处生产线程进入等待状态
		}

		// 连接数量没有到达上限，继续创建新的连接
		if (_connectionCnt < _maxSize)
		{
			Connection *p = new Connection();
			p->connect(_ip, _port, _username, _password, _dbname);
			p->refreshAliveTime(); // 刷新一下开始空闲的起始时间
			_connectionQue.push(p);
			_connectionCnt++;
		}

		cv.notify_all();
	}
}

从连接池中获取一个可用的空闲连接

shared_ptr<Connection> ConnectionPool::getConnection()
{
	unique_lock<mutex> lock(_queueMutex);
	while (_connectionQue.empty())
	{
		// 等待_connectionTimeout以内，如果有可以获取的连接就通知
		// timeout确保是因为超时醒的，避免因为被唤醒但是被其他线程取走的情况
		if (cv_status::timeout == cv.wait_for(lock, chrono::milliseconds(_connectionTimeout)))
		{
			// 等待_connectionTimeout时间以后，没有人唤醒，自己醒了说明还是没有可用的连接
			if (_connectionQue.empty())
			{
				LOG("获取空闲连接超时了...获取连接失败!");
					return nullptr;
			}
		}
	}

	/*
	shared_ptr智能指针析构时，会把connection资源直接delete掉，相当于
	调用connection的析构函数，connection就被close掉了。
	这里需要自定义shared_ptr的释放资源的方式，把connection直接归还到queue当中

	shared_ptr第二个参数可以接受一个删除器
	*/
	shared_ptr<Connection> sp(_connectionQue.front(), 
		[&](Connection *pcon) {
		// 这里是在服务器应用线程中调用的，所以一定要考虑队列的线程安全操作
		unique_lock<mutex> lock(_queueMutex);
		pcon->refreshAliveTime(); // 刷新一下开始空闲的起始时间
		_connectionQue.push(pcon);//归还到连接池
	});

	_connectionQue.pop();
	cv.notify_all();  // 消费完连接以后，通知生产者线程检查一下，如果队列为空了，赶紧生产连接
	
	return sp;
}

连接回收

void ConnectionPool::scannerConnectionTask()
{
	for (;;)
	{
		// 通过sleep模拟定时效果
		this_thread::sleep_for(chrono::seconds(_maxIdleTime));

		// 扫描整个队列，释放多余的连接
		unique_lock<mutex> lock(_queueMutex);
		while (_connectionCnt > _initSize)
		{
			//入队的顺序，对头没有超过整个队列就都没有超过
			Connection *p = _connectionQue.front();
			//用毫秒
			if (p->getAliveeTime() >= (_maxIdleTime * 1000))
			{
				_connectionQue.pop();
				_connectionCnt--;
				delete p; // 调用~Connection()释放连接
			}
			else
			{
				break; // 队头的连接没有超过_maxIdleTime，其它连接肯定没有
			}
		}
	}
}

压测

#include <iostream>
using namespace std;
#include "Connection.h"
#include "CommonConnectionPool.h"

int main()
{
#if 0	
	/*
	Connection conn;
	conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
	*/

	/*Connection conn;
	char sql[1024] = { 0 };
	sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
		"zhang san", 20, "male");
	conn.connect("127.0.0.1", 3306, "root", "123456", "chat");
	conn.update(sql);*/

	clock_t begin = clock();
	
	thread t1([]() {
		ConnectionPool *cp = ConnectionPool::getConnectionPool();
		for (int i = 0; i < 2500; ++i)
		{
			char sql[1024] = { 0 };
			sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
				"zhang san", 20, "M");
			shared_ptr<Connection> sp = cp->getConnection();
			sp->update(sql);
			/*
			Connection conn;
			char sql[1024] = { 0 };
			sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
				"zhang san", 20, "M");
			conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
			conn.update(sql)
			*/
		}
	});
	thread t2([]() {
		ConnectionPool *cp = ConnectionPool::getConnectionPool();
		for (int i = 0; i < 2500; ++i)
		{
			char sql[1024] = { 0 };
			sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
				"zhang san", 20, "M");
			shared_ptr<Connection> sp = cp->getConnection();
			sp->update(sql);
			/*
			Connection conn;
			char sql[1024] = { 0 };
			sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
				"zhang san", 20, "M");
			conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
			conn.update(sql)
			*/
		}
	});
	thread t3([]() {
		ConnectionPool *cp = ConnectionPool::getConnectionPool();
		for (int i = 0; i < 2500; ++i)
		{
			char sql[1024] = { 0 };
			sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
				"zhang san", 20, "M");
			shared_ptr<Connection> sp = cp->getConnection();
			sp->update(sql);
			/*
			Connection conn;
			char sql[1024] = { 0 };
			sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
				"zhang san", 20, "M");
			conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
			conn.update(sql)
			*/
		}
	});
	thread t4([]() {
		ConnectionPool *cp = ConnectionPool::getConnectionPool();
		for (int i = 0; i < 2500; ++i)
		{
			char sql[1024] = { 0 };
			sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
				"zhang san", 20, "M");
			shared_ptr<Connection> sp = cp->getConnection();
			sp->update(sql);
			/*
			Connection conn;
			char sql[1024] = { 0 };
			sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
				"zhang san", 20, "M");
			conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
			conn.update(sql)
			*/
		}
	});

	t1.join();
	t2.join();
	t3.join();
	t4.join();

	clock_t end = clock();
	cout << (end - begin) << "ms" << endl;
#endif
	clock_t begin = clock();

	ConnectionPool *cp = ConnectionPool::getConnectionPool();
	//单线程
	for (int i = 0; i < 10000; ++i)
	{
		/*
		Connection conn;
		char sql[1024] = { 0 };
		sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
			"zhang san", 20, "M");
		conn.connect("127.0.0.1", 3306, "root", "955955", "chatp");
		conn.update(sql);
		*/

		
		shared_ptr<Connection> sp = cp->getConnection();
		char sql[1024] = { 0 };
		sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')",
			"zhang san", 20, "M");
		sp->update(sql);
	}

	clock_t end = clock();
	cout << (end - begin) << "ms" << endl;

	return 0;
}

压测数据

数据量未使用连接池花费时间使用连接池花费时间
1000单线程4630000ms 四线程：5360000ms单线程 80000ms 四线程：80000ms
5000单线程22870000ms 四线程：26990000ms单线程 210000ms 四线程：210000ms
10000单线程45700000ms 四线程：53820000ms单线程 360000ms 四线程：370000ms

注意：如果在window下开发：

在VS上需要进行相应的头文件和库文件的配置，如下：

  1. 右键项目 - C/C++ - 常规 - 附加包含目录，填写mysql.h头文件的路径；
    在这里插入图片描述

  2. 右键项目 - 链接器 - 常规 - 附加库目录，填写libmysql.lib的路径；
    在这里插入图片描述

  3. 右键项目 - 链接器 - 输入 - 附加依赖项，填写libmysql.lib库的名字；
    在这里插入图片描述

  4. 把libmysql.dll动态链接库（Linux下后缀名是.so库）放在工程目录下；
    在这里插入图片描述

吃我一个平底锅
关注
  • 11
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
本地mysql5.7以上版本配置及my.ini
Java 技术专栏，从入门到精通，熟悉企业级开发
03-13 2071
Windows 64 位 mysql 5.7以上版本安装包安装之后，没有my-default.ini和my.ini文件。我们本地开发调试的时候， 有时候也需要改变一下参数，比如最大连接数、查询缓存、缓存池、编码等。 Mysql msi安装包的Windows下载地址: https://dev.mysql.com/downloads/installer/
mysql 8.0使用手册_Centos7安装MySQL8.0 - 操作手册
weixin_33404919的博客
01-19 271
MySQL 8 正式版 8.0.11 已发布，官方表示 MySQL 8 要比 MySQL 5.7 快 2 倍，还带来了大量的改进和更快的性能！一. Mysql8.0版本相比之前版本的一些特性1) 默认编码utf8默认编码使用utf8mb4, utf8mb4编码是utf8编码的超集，兼容utf8，并且能存储4字节的表情字符历史，MySQL数据库的 "utf8"并不是真正概念里的UTF-8。MyS...
Windows环境下安装 mysql-8.0.11-winx64 遇到的问题解决办法
yu_xiaojian55的博客
11-14 6010
下载mysql安装包，我的是下载mysql-8.0.11-winx64，解压到你想安装的目录下，然后配置环境(window环境下，mac本还没试过), 1、首先，配置环境：右击此电脑-&gt;属性-&gt;高级系统设置-&gt;环境变量-&gt;path-&gt;新建 ，然后将自己的路径添加进去（例如我目录：F:\mysql\mysql-8.0.11-winx64），除此之外还要看解压的压缩包...
mysql8.0版本的服务器名称_MySQL 8.0安装部署-运维笔记
weixin_39716043的博客
12-21 478
MySQL 8 正式版 8.0.11 已发布，官方表示 MySQL 8 要比 MySQL 5.7 快 2 倍，还带来了大量的改进和更快的性能！一. Mysql8.0版本相比之前版本的一些特性1) 默认编码utf8默认编码使用utf8mb4, utf8mb4编码是utf8编码的超集，兼容utf8，并且能存储4字节的表情字符历史，MySQL数据库的 "utf8"并不是真正概念里的UTF-8。MyS...
后台管控系统架子structure-admin，一个完整的开发项目架子，包含vue前端和thinkjs后端
saucxs
11-30 858
之前写过一篇vue初始化项目，构建vuex的后台管理项目架子，这个structure-admin-web所拥有的功能 接下来，针对structure-admin-web的不足，进行了补充，开发了具有登陆的structure-admin项目， 技术站：主要是node+vue+redis+mysql+es6 欢迎访问structure-admin源码：structure-admin 同步更新到sau交...
Mysql8.0安装部署-运维笔记
weixin_30551947的博客
03-06 262
MySQL 8 正式版 8.0.11 已发布，官方表示 MySQL 8 要比 MySQL 5.7 快 2 倍，还带来了大量的改进和更快的性能！ 一. Mysql8.0版本相比之前版本的一些特性 1) 默认编码utf8默认编码使用utf8mb4, utf8mb4编码是utf8编码的超集，兼容utf8，并且能存储4字节的表情字符历史，MySQL数据库的 "utf8"并不是真正概念...
项目管理工具--Maven的配置, 安装和使用; 使用Maven搭建一套简单的SSM框架
10-24 123
Maven介绍前言1. Maven简述&配置下载+配置maven基本指令2. eclipse-maveneclipse如何中添加maven？如何用eclipse创建maven项目？index.jsp报错问题:3. pom.xml详解pom.xml 中的pom节点基本配置依赖配置依赖怎么写?4. 如何让新项目利用maven依赖已经完成...
Linux-4.4-x86_64 内核配置选项简介
轮子工厂
10-15 4987
Linux-4.4-x86_64 内核配置选项简介 作者：金步国 64-bit kernel CONFIG_64BIT 编译64位内核.本文仅讲述x86_64(AMD64)平台的内核编译,所以这个是必选项. General setup 常规设置 Cross-compiler tool prefix CONFIG_CROSS_COMPILE 交叉编译工具前缀(比如"arm-linux...
java开发工程师面试题总结（适用于1-2年工作经验的人）
热门推荐
不善言谈者
04-21 12万+
这些资料有的是自己在网上看到的，有的是自己亲身经历后整理的。 1.JAVA的垮平台原理 JVM也是一个软件，不同的平台有不同的版本。我们编写的Java源码，编译后会生成一种 .class 文件，称为字节码文件。Java虚拟机就是负责将字节码文件翻译成特定平台下的机器码然后运行。也就是说，只要在不同平台上安装对应的JVM，就可以运行字节码文件，运行我们编写的Java程序。 而这个...
行业分类-设备装置-对手写字符的字体结构进行检测的方法及装置.zip
08-24
在本压缩包中，主要包含了一个名为“对手写字符的字体结构进行检测的方法及装置.pdf”的文件，以下将详细阐述其相关知识点。 首先，对手写字符的检测通常基于图像处理技术。这个过程分为几个关键步骤：图像预处理、...
yolov5-使用yolov5进行手写单词检测+识别.zip
03-05
《使用YOLOv5进行手写单词检测与识别》 YOLO（You Only Look Once）是一种基于深度学习的目标检测框架，其设计旨在实现快速而准确的实时目标检测。YOLOv5是该系列的最新版本，它在前几代的基础上进行了优化，提供了...
java数据库连接池源码及使用示例
01-25
本资源包含了一个名为`jdbcPool`的手写数据库连接池源码以及一个`jdbcPoolTest`的调用示例，支持Oracle和MySQL数据库。 首先，我们来看`jdbcPool`连接池的实现。在Java中，连接池通常由以下几个核心组件组成： 1. ...
行业分类-设备装置-对手写字符的无旋转识别.zip
08-24
行业分类-设备装置-对手写字符的无旋转识别.zip
java手写数据库连接池
11-02
在实际开发中，虽然手写数据库连接池可以加深对数据库连接池原理的理解，但更常见的情况是使用成熟的连接池实现，如C3P0、Apache DBCP、HikariCP等，它们经过大量优化，提供了更好的性能和稳定性。 总的来说，理解...
后端性能优化：高并发处理.zip
08-18
后端技术系列教程，包括： API开发全套教程 后端安全全套教程 后端微服务架构全套教程 后端性能优化全套教程 后端框架全套教程 后端缓存技术全套教程 后端编程语言全套教程 数据库技术全套教程
实时计算：Apache Flink.zip
08-18
史上最全大数据技术全套教程，包括： 分布式存储系统 大数据基础 大数据处理框架 大数据管理与监控 实时计算 数据仓库 数据分析工具 数据湖 数据集成工具 消息队列 等流行技术的系列教程
River Valley - Level v1.0.3.unitypackage
最新发布
08-18
River Valley - Level v1.0.3
网络安全渗透测试辅助浏览器插件（Google Chrome 版） - Chrome - HackBar-v2.3.1
08-18
HackBar是一款专为网络渗透测试和安全评估设计的浏览器插件，功能丰富且易于使用。它允许用户自定义并直接发送HTTP请求，支持手动构造GET和POST请求，并可添加自定义的HTTP头部和参数。插件内置了编码/解码工具，如URL编码、Base64编码和MD5加密，便于在测试中处理数据。此外，HackBar还提供了常见漏洞的测试Payload，如SQL注入、XSS和XXE，助力用户快速检测网站漏洞。同时，它还具备Cookie管理功能，方便用户进行身份验证和绕过登录限制等测试
手写JDBC连接池详解
06-20
手写JDBC连接池是Java开发中一种自定义管理数据库连接资源的方式，它在性能优化和资源复用方面起着关键作用。下面是一个简单的概述： 1. **基本概念**： - JDBC（Java Database Connectivity）是Java平台用于访问数据库的标准API。 - 连接池是一种设计模式，预先创建并维护一组数据库连接，以供应用程序重用，减少每次请求时的开销。 2. **实现原理**： - 初始化阶段：创建一个连接池，设置参数如最大连接数、最小连接数、超时时间等。 - 获取连接：当应用需要连接时，从池中获取一个空闲的连接，如果所有连接都忙，可能需要等待或创建新的连接。 - 使用连接：应用执行SQL操作，使用完后释放回连接池，而不是直接关闭。 - 回收连接：连接使用完毕，连接池会将其关闭并重新加入到可用连接队列，或者根据配置策略（如最大生命周期）进行销毁。 3. **常见组件**： - 数据源（DataSource）：JNDI命名的接口，用于配置和管理数据库连接。 - ConnectionPool：连接池实现，比如C3P0、HikariCP、DBCP等。 - Connection对象：实际的数据库连接，由连接池管理。 4. **优点**： - 提高性能：减少频繁创建和关闭连接的时间消耗。 - 资源管理：避免内存泄露，确保资源有效释放。 - 易于扩展：连接池能适应并发需求的变化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值