C++ MySQL数据库连接池

新手学了C++多线程,看了些资料练手写了C++数据库连接池小项目,自己的源码地址

关键技术点

MySQL数据库编程、单例模式、queue队列容器、C++11多线程编程、线程互斥、线程同步通信和

unique_lock、基于CAS的原子整形、智能指针shared_ptr、lambda表达式、生产者-消费者线程模型

连接池项目

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

在市场上比较流行的连接池包括阿里的druid,c3p0以及apache dbcp连接池,它们对于短时间内大量的数据库增删改查操作性能的提升是很明显的,但是它们有一个共同点就是,全部由Java实现的。

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

连接池功能点介绍

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

  • 初始连接量(initSize):表示连接池事先会和MySQL Server创建initSize个数的connection连接,当应用发起MySQL访问时,不用再创建和MySQL Server新的连接,直接从连接池中获取一个可用的连接就可以,使用完成后,并不去释放connection,而是把当前connection再归还到连接池当中。

  • 最大连接量(maxSize):当并发访问MySQL Server的请求增多时,初始连接量已经不够使用了,此时会根据新的请求数量去创建更多的连接给应用去使用,但是新创建的连接数量上限是maxSize,不能无限制的创建连接,因为每一个连接都会占用一个socket资源,一般连接池和服务器程序是部署在一台主机上的,如果连接池占用过多的socket资源,那么服务器就不能接收太多的客户端请求了。当这些连接使用完成后,再次归还到连接池当中来维护。

  • 最大空闲时间(maxIdleTime):当访问MySQL的并发请求多了以后,连接池里面的连接数量会动态增加,上限是maxSize个,当这些连接用完再次归还到连接池当中。如果在指定的maxIdleTime里面,这些新增加的连接都没有被再次使用过,那么新增加的这些连接资源就要被回收掉,只需要保持初始连接量initSize个连接就可以了。

  • 连接超时时间(connectionTimeout):当MySQL的并发请求量过大,连接池中的连接数量已经到达maxSize了,而此时没有空闲的连接可供使用,那么此时应用从连接池获取连接无法成功,它通过阻塞的方式获取连接的时间如果超connectionTimeout时间,那么获取连接失败,无法访问数据库。

实现的逻辑图片

数据表的结构

我们建立一个mysql数据库的数据表来演示后面如何用C++连接数据表,并且写SQL.

先进入mysql,输入密码

  1. mysql -u root -p

创建一个数据库名叫chat,同时创建数据表

  1. CREATE DATABASE chat;
  2. use chat;
  3. CREATE TABLE user (
  4. id INT(11) NOT NULL AUTO_INCREMENT,
  5. name VARCHAR(50) NOT NULL,
  6. age INT(11) NOT NULL,
  7. sex ENUM('male', 'female') NOT NULL,
  8. PRIMARY KEY (id)
  9. );

如果输出OK就代表创建user好了,我们来看看数据表

  1. desc user;
  2. +-------+-----------------------+------+-----+---------+----------------+
  3. | Field | Type | Null | Key | Default | Extra |
  4. +-------+-----------------------+------+-----+---------+----------------+
  5. | id | int | NO | PRI | NULL | auto_increment |
  6. | name | varchar(50) | NO | | NULL | |
  7. | age | int | NO | | NULL | |
  8. | sex | enum('male','female') | NO | | NULL | |
  9. +-------+-----------------------+------+-----+---------+----------------+

查看一下内容,没有

  1. mysql> select * from user;
  2. Empty set (0.19 sec)

到这里我们MySQL表就创建好了,我们不用管他,我们进行编写CPP连接数据库代码

连接数据库,并且执行sql语句

打开VS2019,并且创建一个控制台项目,项目结构如图

main.cpp负责执行主函数代码,Connect负责编写封装数据库的连接和sql操作,mysqlPool负责编写数据库连接池。

但我们还不急着编写代码,先导入需要的外部库,在VS上需要进行相应的头文件和库文件的配置,如下:

  • 1.右键项目 - C/C++ - 常规 - 附加包含目录,填写mysql.h头文件的路径
  • 2.右键项目 - 链接器 - 常规 - 附加库目录,填写libmysql.lib的路径
  • 3.右键项目 - 链接器 - 输入 - 附加依赖项,填写libmysql.lib库的名字
  • 4.把libmysql.dll动态链接库(Linux下后缀名是.so库)放在工程目录下

如果你没有修改过MySQL路径,一般mysql.h在你的电脑路径如下

如果你没有修改过MySQL路径,一般libmysql.lib在你的电脑路径如下

libmysql.dll文件存放在你项目文件路径下面

1.封装Mysql.h的接口成connection类

接下来封装一下mysql的数据库连接代码,不懂的看看注释,也很简单的调用Mysql.h的接口,我们在connection中额外加入创建时间函数和存活时间函数,不能让空闲的线程存活时间超过定义的最大空闲时间

connect.h的代码如下

  1. #pragma once
  2. #include <mysql.h>
  3. #include <string>
  4. #include <ctime>
  5. using namespace std;
  6. /*
  7. 封装MySQL数据库的接口操作
  8. */
  9. class Connection
  10. {
  11. public:
  12. // 初始化数据库连接
  13. Connection();
  14. // 释放数据库连接资源
  15. ~Connection();
  16. // 连接数据库
  17. bool connect(string ip,
  18. unsigned short port,
  19. string user,
  20. string password,
  21. string dbname);
  22. // 更新操作 insert、delete、update
  23. bool update(string sql);
  24. // 查询操作 select
  25. MYSQL_RES* query(string sql);
  26. // 刷新一下连接的起始的空闲时间点
  27. void refreshAliveTime() { _alivetime = clock(); }
  28. // 返回存活的时间
  29. clock_t getAliveeTime()const { return clock() - _alivetime; }
  30. private:
  31. MYSQL* _conn; // 表示和MySQL Server的一条连接
  32. clock_t _alivetime; // 记录进入空闲状态后的起始存活时间
  33. };

connect.cpp的代码如下


  1. #include "public.h"
  2. #include "Connect.h"
  3. #include <iostream>
  4. using namespace std;
  5. Connection::Connection()
  6. {
  7. // 初始化数据库连接
  8. _conn = mysql_init(nullptr);
  9. }
  10. Connection::~Connection()
  11. {
  12. // 释放数据库连接资源
  13. if (_conn != nullptr)
  14. mysql_close(_conn);
  15. }
  16. bool Connection::connect(string ip, unsigned short port,
  17. string username, string password, string dbname)
  18. {
  19. // 连接数据库
  20. MYSQL* p = mysql_real_connect(_conn, ip.c_str(), username.c_str(),
  21. password.c_str(), dbname.c_str(), port, nullptr, 0);
  22. return p != nullptr;
  23. }
  24. bool Connection::update(string sql)
  25. {
  26. // 更新操作 insert、delete、update
  27. if (mysql_query(_conn, sql.c_str()))
  28. {
  29. LOG(+ "更新失败:" + sql);
  30. return false;
  31. }
  32. return true;
  33. }
  34. MYSQL_RES* Connection::query(string sql)
  35. {
  36. // 查询操作 select
  37. if (mysql_query(_conn, sql.c_str()))
  38. {
  39. LOG("查询失败:" + sql);
  40. return nullptr;
  41. }
  42. return mysql_use_result(_conn);
  43. }

在public.h中编写的代码,帮助我们输出日志和警告

  1. #pragma once
  2. #include <iostream>
  3. #define LOG(str) \
  4. std::cout << __FILE__ << ":"<<__LINE__<<" " \
  5. __TIMESTAMP__ << ":"<<str <<std::endl;

使用这个宏,你可以在代码中的任何地方轻松输出日志信息。

我们暂时用这个main先测试下connection类

main.cpp代码

  1. #include <iostream>
  2. #include "Connect.h"
  3. int main()
  4. {
  5. Connection conn;
  6. char sql[1024] = { 0 };
  7. //插入一条数据
  8. sprintf(sql, "insert into user(name,age,sex) values('%s','%d','%s');", "zhang san", 20, "male");
  9. conn.connect("127.0.0.1", 3306, "root", "123456", "chat");
  10. conn.update(sql); //更新sql语句
  11. return 0;
  12. }

如果你的vs2019给你报安全警告,应该是sprintf的问题,你右击项目,选择属性中C++的常规中SDL检查,设置为否。

编译运行后,我们返回MySQL的界面,发现数据已经插入成功了

  1. mysql> select * from user;
  2. +----+-----------+-----+------+
  3. | id | name | age | sex |
  4. +----+-----------+-----+------+
  5. | 1 | zhang san | 20 | male |
  6. +----+-----------+-----+------+
  7. 1 row in set (0.02 sec)

现在我们已经成功能调用外部接口来连接Mysql数据库了,接下来我们来编写连接池.

2.编写连接池

2.1MySQL配置文件和加载配置文件

我们来编写mySqlPool的代码,因为数据库连接池只有一个,所以我们写成单例模式。同时会有多个服务端进入连接池,所以我们要添加互斥锁来避免线程之间的冲突。

我们在项目中创建一个名叫mysql.ini配置文件存储数据库连接的信息,例如数据库ip地址,用户名,密码等

mysql.ini的内容如下,如果你的用户名和密码跟里面不同,请修改

  1. #数据库连接池的配置文件
  2. ip=127.0.0.1
  3. port=3306
  4. username=root
  5. password=123456
  6. initSize=10
  7. maxSize=1024
  8. #最大空闲时间默认单位为秒
  9. maxIdleTime=60
  10. #连接超时时间单位是毫米
  11. connectionTimeOut=100

我们把mysqlPool.h文件中需要的函数都声明好,等会在cpp中实现。

  1. #pragma once
  2. #include "public.h"
  3. #include "Connect.h"
  4. #include <queue>
  5. #include <mutex>
  6. #include <string>
  7. #include <atomic>
  8. #include <memory>
  9. #include <functional>
  10. #include <condition_variable>
  11. //因为数据库连接池子只有一个,所以我们采用单例模式
  12. class mySqlPool {
  13. public:
  14. //获取连接池对象实例
  15. static mySqlPool* getMySqlPool();
  16. std::shared_ptr<Connection> getConnection();//从连接池获取一个可用的空闲连接
  17. private:
  18. mySqlPool();//构造函数私有化
  19. bool loadConfigFile();//从配置文件中加载配置项
  20. void produceConnectionTask(); //运行在独立的线程中,专门负责生产新连接
  21. //扫描超过maxIdleTime时间的空闲连接,进行队列的连接回收
  22. void scannerConnectionTask();
  23. std::string _ip;//mysql的ip地址
  24. std::string _dbname;//数据库的名称
  25. unsigned short _port; //mysql端口号3306
  26. std::string _username;//mysql用户名
  27. std::string _password;//mysql登陆密码
  28. int _initSize;//连接池的初始连接量
  29. int _maxSize;//连接池的最大连接量
  30. int _maxIdleTime;//连接池最大空闲时间
  31. int _connectionTimeOut;//连接池获取连接的超时时间
  32. std::queue<Connection*> _connectionQue;//存储mysql连接队列
  33. std::mutex _queueMutex; //维护连接队列的线程安全互斥锁
  34. std::atomic_int _connectionCnt; //记录连接所创建的connect的数量
  35. std::condition_variable cv;//设置条件变量,用于生产者线程和消费者线程的通信
  36. };

编写mySqlPool.cpp 中加载我们上面.ini配置文件的函数

  1. //在mySqlPool.cpp中
  2. //加载配置文件
  3. bool mySqlPool::loadConfigFile()
  4. {
  5. FILE* pf = fopen("mysql.ini", "r");
  6. if (pf == nullptr)
  7. {
  8. LOG("mysql.ini file is not exits!");
  9. return false;
  10. }
  11. while (!feof(pf)) //遍历配置文件
  12. {
  13. char line[1024] = { 0 };
  14. fgets(line, 1024, pf);
  15. std::string str = line;
  16. int idx = str.find('=', 0); //从0开始找'='符号的位置
  17. if (idx == -1)continue;
  18. int endidx = str.find('\n', idx);//从idx寻找'\n'的位置,也就是末尾
  19. std::string key = str.substr(0, idx); //获取配置文件中=号左边的key
  20. //从等号后到末尾,刚好是value的string形式
  21. std::string value = str.substr(idx + 1, endidx - idx - 1);
  22. if (key == "ip")
  23. {
  24. _ip = value;
  25. }
  26. else if (key == "port")
  27. {
  28. //字符串转换成unsigned short
  29. _port = static_cast<unsigned short>(std::stoul(value));
  30. }
  31. else if (key == "username")
  32. {
  33. _username = value;
  34. }
  35. else if (key == "password")
  36. {
  37. _password = value;
  38. }
  39. else if (key == "dbname")
  40. {
  41. _dbname = value;
  42. }
  43. else if (key == "initSize")
  44. {
  45. _initSize = std::stoi(value);
  46. }
  47. else if (key == "maxSize")
  48. {
  49. _maxSize = std::stoi(value);
  50. }
  51. else if (key == "maxIdleTime")
  52. {
  53. _maxIdleTime = std::stoi(value);
  54. }
  55. else if (key == "connectionTimeOut")
  56. {
  57. _connectionTimeOut = std::stoi(value);
  58. }
  59. }
  60. return true;
  61. }

这样我们加载配置文件就完成了

2.2编写连接池单例模式

单例模式确保数据库连接池在整个应用程序中只有一个实例。这样,所有需要数据库连接的线程或操作都可以从这个池中获取连接,而不是每次都创建新的连接。这大大减少了资源消耗和性能损耗。(如果不懂数据模式单例模式可以百度一下)

我们在.h文件中,我们先将构造函数private化,这样外部就只能通过接口来获取,我们在cpp中来编写具体的实现代码

构造方法

  1. //mySqlPool.h
  2. //构造方法
  3. mySqlPool::mySqlPool()
  4. {
  5. if (!loadConfigFile())
  6. {
  7. LOG("load Config File is error!");
  8. return;
  9. }
  10. //创建初始数量的连接
  11. for (int i = 0; i < _initSize; ++i)
  12. {
  13. Connection* p = new Connection();
  14. p->connect(_ip, _port, _username, _password, _dbname);
  15. }
  16. //启动一个新线程,作为连接的生产者
  17. std::thread produce(std::bind(&mySqlPool::produceConnectionTask, this));
  18. produce.detach();
  19. //启动一个新线程,作为空闲连接超时的回收者
  20. std::thread scanner(std::bind(&mySqlPool::scannerConnectionTask, this));
  21. scanner.detach();
  22. }

单例模式

  1. //mySqlPool.h
  2. //单例模式
  3. mySqlPool* mySqlPool::getMySqlPool()
  4. {
  5. static mySqlPool pool;
  6. return &pool;
  7. }

现在我们已经成功的编写了单例模式,接下来我们开始获取数据库的连接。

数据库连接的线程通信

我们创建一个connect*线程队列queue来存放MySQL数据库的连接connect,同时我们还会额外创建两个线程。

一个线程是生产者,开始从Connect类中获取initSize个连接加入连接队列中准备着,当判断连接队列empty,又开始获取连接加入连接队列中 ,如果不为empty就进入阻塞状态。

生产者线程代码

  1. //运行在独立的线程中,专门负责生产新连接
  2. void mySqlPool::produceConnectionTask()
  3. {
  4. while (true)
  5. {
  6. std::unique_lock<std::mutex> lock(_queueMutex);
  7. while (!_connectionQue.empty())
  8. cv.wait(lock); //队列不为空不生产线程
  9. //没有到上线就可以生产线程
  10. if (_connectionCnt < _maxSize)
  11. {
  12. auto p = new Connection();
  13. p->connect(_ip, _port, _username, _password, _dbname);
  14. p->refreshAliveTime();//创建的时候刷新存活时间
  15. _connectionQue.push(p);
  16. ++_connectionCnt;
  17. }
  18. cv.notify_all();
  19. }
  20. }

另外一个线程是消费者,如果服务端想要获取队列中的连接,消费者线程将会从队列中拿出connection来,如果队列为empty,线程会处于阻塞状态。

消费者线程代码

  1. /从连接池获取一个可用的空闲连接
  2. std::shared_ptr<Connection> mySqlPool::getConnection()
  3. {
  4. std::unique_lock<std::mutex> lock(_queueMutex);
  5. while (_connectionQue.empty())
  6. {
  7. //如果超时没有获取可用的空闲连接返回空
  8. if (std::cv_status::timeout == cv.wait_for(lock, std::chrono::milliseconds(100)))
  9. if (_connectionQue.empty())
  10. {
  11. LOG("get Connection error");
  12. return nullptr;
  13. }
  14. }
  15. std::shared_ptr<Connection> sp(_connectionQue.front(), [&](Connection* pcon) {
  16. //保证只能同一时刻只能有一个线程归还连接给队列
  17. std::unique_lock<std::mutex> lock(_queueMutex);
  18. pcon->refreshAliveTime();//创建的时候刷新存活时间
  19. _connectionQue.push(pcon);
  20. });
  21. _connectionQue.pop();
  22. cv.notify_all();
  23. return sp;
  24. }

如果队列里面大于初始个数的新connection空闲时间大于最大空闲时间,我们将会回收该连接(但是不会完全释放,我们将其归还在连接池中)。

上面getConnection代码的这段就是实现了回收功能

  1. std::shared_ptr<Connection> sp(_connectionQue.front(), [&](Connection* pcon) {
  2. //保证只能同一时刻只能有一个线程归还连接给队列
  3. std::unique_lock<std::mutex> lock(_queueMutex);
  4. pcon->refreshAliveTime();//创建的时候刷新存活时间
  5. _connectionQue.push(pcon);
  6. });

扫描超过maxIdleTime时间的空闲连接,进行队列的连接回收

  1. //连接线程回收
  2. void mySqlPool::scannerConnectionTask()
  3. {
  4. while (true)
  5. {
  6. //通过sleep模拟定时效果,每_maxIdleTime检查一次
  7. std::this_thread::sleep_for(std::chrono::seconds(_maxIdleTime));
  8. //扫描整个队列释放多余的超时连接
  9. std::unique_lock<std::mutex> lock(_queueMutex);
  10. while (_connectionCnt > _initSize)
  11. {
  12. auto p = _connectionQue.front();
  13. if (p->getAliveeTime() >= (_maxIdleTime * 1000))
  14. {
  15. _connectionQue.pop();
  16. delete p;//这里会调用智能指针,回收到队列中
  17. }
  18. }
  19. }
  20. }

到这里,我们连接池的代码已经完成了,接下来是测试一下代码

连接池的压力测试

我们分别测试连接个数为10,100,1000时候的性能差异,创建一个test.h文件,编写测试代码

注意下面的测试可能根据不同的电脑性能,可能速度会有所差异。

普通连接

  1. //test.h
  2. //非线程池的连接
  3. void testSql( int n)
  4. {
  5. clock_t begin = clock();
  6. std::thread t([&n]() {
  7. for (int i = 1; i < n; ++i)
  8. {
  9. Connection cnn;
  10. char sql[1024] = { 0 };
  11. sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
  12. cnn.connect("127.0.0.1", 3306, "root", "123456", "chat");
  13. cnn.update(sql);
  14. }});
  15. t.join();
  16. clock_t end = clock();
  17. std::cout << "普通连接数量为:" << n << "的sql执行时间:" << (end - begin) << "ms" << std::endl;
  18. }

main.cpp中调用

  1. #include <iostream>
  2. #include "Connect.h"
  3. #include "mySqlPool.h"
  4. #include "test.h"
  5. int main()
  6. {
  7. testSql(10);//普通连接数量为 : 10的sql执行时间 : 2838ms
  8. testSql(100);//普通连接数量为 : 100的sql执行时间: 12299
  9. testSql(1000);//普通连接数量为 : 1000的sql执行时间 : 104528ms
  10. return 0;
  11. }

单线程的线程池

  1. //test.h
  2. void f(int n)
  3. {
  4. mySqlPool* cp = mySqlPool::getMySqlPool();
  5. for (int i = 1; i <= n; ++i)
  6. {
  7. std::shared_ptr<Connection> sp = cp->getConnection();
  8. char sql[1024] = { 0 };
  9. sprintf(sql, "insert into user(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
  10. sp->update(sql);
  11. }
  12. }
  13. //测试连接池连接
  14. void testSqlPool(int n)
  15. {
  16. clock_t begin = clock();
  17. std::thread t1(f, n);
  18. t1.join();
  19. clock_t end = clock();
  20. std::cout << "单线程采用数据库连接池,连接数量为:" << n << "的sql执行时间:" << (end - begin) << "ms" << std::endl;
  21. }

main.cpp中调用

  1. #include <iostream>
  2. #include "Connect.h"
  3. #include "mySqlPool.h"
  4. #include "test.h"
  5. int main()
  6. {
  7. testSqlPool(10);//单线程 采用数据库连接池,连接数量为:10的sql执行时间:1745ms
  8. testSqlPool(100);//单线程 采用数据库连接池,连接数量为:100的sql执行时间:9779ms
  9. testSqlPool(1000);//单线程 采用数据库连接池,连接数量为:1000的sql执行时间 : 86016ms
  10. return 0;
  11. }

多线程的线程池

  1. //test.h
  2. //测试连接池连接 4线程
  3. void testSqlPool4(int n)
  4. {
  5. int n2 = n / 4;
  6. clock_t begin = clock();
  7. std::thread t1(f, n2);
  8. std::thread t2(f, n2);
  9. std::thread t3(f, n2);
  10. std::thread t4(f, n2);
  11. t1.join();
  12. t2.join();
  13. t3.join();
  14. t4.join();
  15. clock_t end = clock();
  16. std::cout << "四线程采用数据库连接池,连接数量为:" << n << "的sql执行时间:" << (end - begin) << "ms" << std::endl;
  17. }

main.cpp中调用

  1. #include <iostream>
  2. #include "Connect.h"
  3. #include "mySqlPool.h"
  4. #include "test.h"
  5. int main()
  6. {
  7. testSqlPool4(100);//4条线程 采用数据库连接池,连接数量为:100的sql执行时间 : 3715ms
  8. testSqlPool4(1000);//4条线程 采用数据库连接池,连接数量为:1000的sql执行时间 : 34686ms
  9. return 0;
  10. }

由上面测试数据可以得出,普通连接<单线程连接池<多线程连接池,连接池比普通连接还是优化很多的。

C++ mySQL数据库连接池(windows平台)的更多相关文章

  1. 一个简单的MySql数据库连接池的实现

    package cn.hc.connectionPool; import java.io.IOException; import java.io.InputStream; import java.sq ...

  2. Python实现Mysql数据库连接池

    python连接Mysql数据库: python编程中可以使用MySQLdb进行数据库的连接及诸如查询/插入/更新等操作,但是每次连接mysql数据库请求时,都是独立的去请求访问,相当浪费资源,而且访 ...

  3. mysql数据库连接池使用(三)数据库元数据信息反射数据库获取数据库信息

    1.1. mysql数据库连接池使用(三)数据库元数据信息反射数据库获取数据库信息 有时候我们想要获取到数据库的基本信息,当前程序连接的那个数据库,数据库的版本信息,数据库中有哪些表,表中都有什么字段 ...

  4. MySql数据库连接池专题

    MySql数据库连接池专题 - aspirant - 博客园https://www.cnblogs.com/aspirant/p/6747238.html

  5. python3 实现mysql数据库连接池

    首先声明一下,这篇博客进行了通过自己的代码方式,加上这篇博客,最后总结出这段代码.参考博客连接:http://blog.csdn.net/zbc1090549839/article/details/5 ...

  6. MySql数据库连接池

    1.传统链接(如下为示意图) 注意: (1).传统方式找DriverManager要连接,数目是有限的. (2).传统方式的close(),并没有将Connection重用,只是切断应用程序和数据库的 ...

  7. mysql数据库连接池使用(二)实现自己的数据库连接池

    上一个章节,我们讲了xml文件的解析框架XMLConfiguration的使用,不懂的可以参考 Apache Commons Configuration读取xml配置具体使用. 这个章节主要实现自己的 ...

  8. mysql数据库连接池使用(一)dbcp方式的配置

    Apache的数据库连接池 DBCP的常用配置说明,因为项目中用到了需要对其封装,所以必须先了解怎么配置以及各个配置字段的含义,理解的基础上开发我们自己的数据库连接池.可以参考官网dbcp官网. db ...

  9. node+mysql 数据库连接池

    1. 什么是数据库连接池? 数据库连接池是程序启动时建立足够的数据库连接,并将这些连接组成一个池,由程序动态地对池中的连接进行申请,使用和释放. 2. 使用数据库连接池原理及优点是什么? 数据库连接池 ...

  10. Tomcat中配置MySQL数据库连接池

    Web开发中与数据库的连接是必不可少的,而数据库连接池技术很好的优化了动态页与数据库的连接,相比单个连接数据库连接池节省了很大的资源.用一个通俗的比喻:如果一个人洗澡需花一桶水,那一百个人就要花一百桶 ...

随机推荐

  1. ElementUI实现表格(table) 行上下移动的效果

    参考地址 https://blog.csdn.net/sunshine0508/article/details/88390155 看大佬的地址 <div id="app"&g ...

  2. 【JS 逆向百例】网洛者反爬练习平台第七题:JSVMPZL 初体验

    关注微信公众号:K哥爬虫,持续分享爬虫进阶.JS/安卓逆向等技术干货! 声明 本文章中所有内容仅供学习交流,抓包内容.敏感网址.数据接口均已做脱敏处理,严禁用于商业用途和非法用途,否则由此产生的一切后 ...

  3. 我为什么从Windows转到Linux?

    本文来自读者投稿! 大家好!我是 Guide 哥,Java 后端开发.一个会一点前端,喜欢烹饪的自由少年. 如果文章有任何需要改善和完善的地方,欢迎在评论区指出,共同进步! 喔,看到这个标题千万不要以 ...

  4. 大语言模型的预训练[3]之Prompt Learning:Prompt Engineering、Answer engineering、Multi-prompt learning、Training strategy详解

    大语言模型的预训练[3]之Prompt Learning:Prompt Engineering.Answer engineering.Multi-prompt learning.Training st ...

  5. C/C++ 动态解密释放ShellCode

    今天在复习<加密与解密>时,在软件保护这一章中有一个代码与数据结合的案例,其原理是将代码段中的代码进行xor异或加密处理以后回写到原始位置,当程序运行后将此处的内容动态的进行解密,解密后回 ...

  6. 如何在 Mac 上配置 VirtualBox Host-Only 网络适配器

    默认Mac 上安装 VirtualBox 后,没有自动配置Host-Only 网络适配器,需要我们手工添加.方法如下: 打开VirtualBox软件, 依次点击 "管理 -> 工具 - ...

  7. 如何使用MBP制作Win启动盘

    最近有一个需求,想给家人的一台笔记本安装一套win 10的操作系统,但是我手头上现在没有对应的启动U盘. 由于工作原因,很多年没用win了,工作电脑也都是MBP,根本没有之前使用win时熟悉的Ultr ...

  8. Wamp MySQL 报错 Got a packet bigger than 'max_allowed_packet' bytes

    点击电脑右下角wamp图标,然后进入mysql 下面的 my.ini 转移数据发现报这个错,字面意思允许的不够大.网上很多说法不起作用,解决方法如下: [mysqld] port=3306 expli ...

  9. .NET Core开发实战(第34课:MediatR:轻松实现命令查询职责分离模式(CQRS))--学习笔记(下)

    34 | MediatR:轻松实现命令查询职责分离模式(CQRS) 实际上我们在定义我的查询的时候,也可以这样定义,例如我们定义一个 MyOrderQuery,把订单的所有名称都输出出去 namesp ...

  10. NVME(学习杂谈)—Asynchronous Event

    Asynchronous Event Request Host Software Recommendations 当一个异步事件请求完成(提供Event Type,Event Information, ...