基於MysqlConnector/C++的數據庫鏈接池的實現

1.鏈接池的介紹：

1.1應用背景：

通常的應用程序都會訪問到數據庫，在程序訪問數據庫的時候，每一次數據訪問請求都必須通過下面幾個步驟：創建數據庫鏈接，打開數據庫，對數據庫中的數據進行操做，關閉數據庫鏈接。而創建數據庫鏈接和打開數據庫是一件很消耗資源而且費時的工做，若是在系統中很頻繁的發生這種數據庫鏈接，必然會影響到系統的性能，甚至會致使系統的崩潰。

1.2技術思想：

在系統初始化階段，創建必定數量的數據庫鏈接對象(Connection)，並將其存儲在鏈接池中定義的容器中。當有數據庫訪問請求時，就從鏈接池中的這個容器中拿出一個鏈接；當容器中的鏈接已經用完，而且尚未達到系統定義的最大鏈接數時，能夠再建立一個新的鏈接，噹噹前使用的鏈接數達到最大鏈接數時，就要等待其餘訪問請求將鏈接放回容器後才能使用。當使用完鏈接的時候，必須將鏈接放回容器中，這樣不一樣的數據庫訪問請求就能夠共享這些鏈接，經過重複使用這些已經創建的數據庫鏈接，能夠解決上節中說到的頻繁創建鏈接的缺點，從而提升了系統的性能。

通過上述描述，咱們能夠概括出數據庫鏈接池的主要操做：

(1)首先創建一個數據庫鏈接池對象

(2)初始化必定數量的數據庫鏈接，放入鏈接池對象的容器中

(3)當有數據庫訪問請求時，直接從鏈接池的容器中獲得一個鏈接，這裏出現三種狀況：

(a)當容器中的還有鏈接時，則返回給數據庫訪問請求者一個鏈接

(b)當容器中沒有鏈接時，而且當前創建的鏈接數沒有達到系統定義的最大鏈接數，則建立一個新的數據庫鏈接。

(c)當容器中的沒有鏈接而且當前創建的鏈接數達到系統定義的最大鏈接數，則當前訪問數據庫請求就要等待其餘訪問請求釋放鏈接。

(4)當數據庫訪問完成後，應該將鏈接放回鏈接池的容器中。

(5)當服務中止時，須要先釋放數據庫鏈接池中的全部數據庫鏈接，而後再釋放數據庫鏈接池對象。

2.編程實現：

頭文件(connection_pool.h)：

[html]  view plain copy

1.  /*  
2.          *File: connection_pool.h  
3.           *Author: csc  
4.      */  
5. #ifndef_CONNECTION_POOL_H  
6. #define _CONNECTION_POOL_H  
7. #include<mysql_connection.h>  
8. #include<mysql_driver.h>  
9. #include<cppconn/exception.h>  
10. #include<cppconn/driver.h>  
11. #include<cppconn/connection.h>  
12. #include<cppconn/resultset.h>  
13. #include<cppconn/prepared_statement.h>  
14. #include<cppconn/statement.h>  
15. #include<pthread.h>  
16. #include<list>  
17. usingnamespace std;  
18. usingnamespace sql;  
19.   
20. classConnPool{  
21. private:  
22.     int    curSize;//當前已創建的數據庫鏈接數量  
23.     int    maxSize;//鏈接池中定義的最大數據庫鏈接數  
24.     string    username;  
25.     string    password;  
26.     string    url;  
27.     list<Connection*>    connList;//鏈接池的容器隊列  
28.     pthread_mutex_tlock;//線程鎖  
29.     staticConnPool *    connPool;  
30.     Driver*    driver;  
31.   
32. Connection* CreateConnection();//建立一個鏈接  
33. void    InitConnection(int iInitialSize);//初始化數據庫鏈接池  
34. void    DestoryConnection(Connection *conn);//銷燬數據庫鏈接對象  
35. void    DestoryConnPool();//銷燬數據庫鏈接池  
36. ConnPool(stringurl,string user,string password,int maxSize);//構造方法  
37. public:  
38.     ~ConnPool();  
39.     Connection*GetConnection();//得到數據庫鏈接  
40.     void    ReleaseConnection(Connection *conn);//將數據庫鏈接放回到鏈接池的容器中  
41.     static    ConnPool *GetInstance();//獲取數據庫鏈接池對象  
42. };  
43. #endif  /*_CONNECTION_POOL_H */  

頭文件中定義了一個容器connList,裏面存放了不少個未使用的鏈接；在對容器內的鏈接進行操做的時候，須要加鎖來保證程序的安全性，因此頭文件中定義了一個lock，經過使用lock保證了同一時間只有一個線程對容器進行操做。

鏈接池類要統一管理整個應用程序中的鏈接，因此在整個系統中只須要維護一個鏈接池對象，試想：若是系統中定義了多個鏈接池對象，那麼每個對象均可以創建maxSize個鏈接，這樣就失去了建立鏈接池的初衷，破環了經過鏈接池統一管理系統中鏈接的思想。因此這裏使用單例模式編寫鏈接池類，單例模式確保一個類只有一個實例，本身進行實例化而且向整個系統提供這個實例。在頭文件中，咱們定義了一個靜態的鏈接池對象connPool，鏈接池類提供一個靜態的公共方法GetInstance(),外部程序經過調用這個方法來得到鏈接池對象。而且將鏈接池類的構造函數定義爲私有的，外部的應用程序不可以經過new來實例化鏈接池類，只能經過GetInstance()方法得到鏈接池對象；在GetInstance()方法中須要判斷鏈接池類中定義的connPool是否爲NULL，若爲NULL則調用私有構造函數實例化connPool，若不爲空，則直接返回connPool。這樣就實現了鏈接池類的單例模式，從而保證了系統運行過程當中只創建一個鏈接池類的實例對象。

在實例化鏈接池類的對象時，要對鏈接池作一些初始化的操做，即創建必定數量的數據庫鏈接。程序中經過InitConnection(intiInitialSize)方法對鏈接池進行初始化，建立iInitialSize個鏈接，而且將這些鏈接放在鏈接池中的容器connList中，每新建一個鏈接，curSize就加1。當有數據庫訪問請求時，須要從鏈接池中獲取一個鏈接，經過GetConnection()方法實現：首先判斷容器中是否還有鏈接，若是有，則拿出容器中的第一個鏈接，而且將該鏈接移出容器；得到的鏈接要進行判斷，若是鏈接已經關閉，則回收該鏈接的內存空間，而且從新建立一個鏈接；而後判斷新建立的鏈接是否爲空，若是爲空，則說明當前已經創建鏈接的數量並非curSize個，而是(curSize-1)個(應該除去這個空鏈接)。若是容器中已經沒有鏈接了，則要判斷當前的curSize值是否已經達到規定的maxSize，若是沒有小於maxSize，將創建一個新的鏈接(++curSize)。若是超過maxSize則等待其餘數據庫訪問請求釋放數據庫鏈接。

鏈接使用完之後，須要將鏈接放回鏈接池中，經過ReleaseConnection(sql::Connection* conn)方法實現，它的實現很是簡單，就是將傳進來的connection鏈接添加到鏈接池的容器中。

當須要回收鏈接池的內存空間時，須要先回收鏈接池中全部鏈接的內存空間，而後再釋放鏈接池對象的內存空間。

實現數據庫鏈接池主要的步驟就是上述這些，具體的代碼實現以下所示：

[cpp]  view plain copy

1. #include<stdexcept>  
2. #include<exception>  
3. #include<stdio.h>  
4. #include"connection_pool.h"  
5.   
6. usingnamespace std;  
7. usingnamespace sql;  
8.   
9. ConnPool*ConnPool::connPool=NULL;  
10. //鏈接池的構造函數  
11. ConnPool::ConnPool(stringurl, string userName,string password, int maxSize)  
12. {  
13.     this->maxSize=maxSize;  
14.     this->curSize=0;  
15.     this->username=userName;  
16.     this->password=password;  
17.     this->url=url;  
18.     try{  
19.         this->driver=sql::mysql::get_driver_instance();  
20.     }  
21.     catch(sql::SQLException&e)  
22.     {  
23.         perror("驅動鏈接出錯;\n");  
24.     }  
25.     catch(std::runtime_error&e)  
26.     {  
27.         perror("運行出錯了\n");  
28.     }  
29.     this->InitConnection(maxSize/2);  
30. }  
31. //獲取鏈接池對象，單例模式  
32. ConnPool*ConnPool::GetInstance(){  
33.     if(connPool==NULL)  
34.     {  
35.         connPool=newConnPool("tcp://127.0.0.1:3306","root","root",50);  
36.     }  
37.     returnconnPool;  
38. }  
39. //初始化鏈接池，建立最大鏈接數的一半鏈接數量  
40. voidConnPool::InitConnection(int iInitialSize)  
41. {  
42.     Connection*conn;  
43.     pthread_mutex_lock(&lock);  
44.     for(inti=0;i<iInitialSize;i++)  
45.     {  
46.         conn=this->CreateConnection();  
47.         if(conn){  
48.             connList.push_back(conn);  
49.             ++(this->curSize);  
50.         }  
51.         else  
52.         {  
53.             perror("建立CONNECTION出錯");  
54.         }  
55.     }  
56.     pthread_mutex_unlock(&lock);  
57. }  
58. //建立鏈接,返回一個Connection  
59. Connection*ConnPool::CreateConnection(){  
60.     Connection*conn;  
61.     try{  
62.         conn=driver->connect(this->url,this->username,this->password);//創建鏈接  
63.         returnconn;  
64.     }  
65.     catch(sql::SQLException&e)  
66.     {  
67.         perror("建立鏈接出錯");  
68.         returnNULL;  
69.     }  
70.     catch(std::runtime_error&e)  
71.     {  
72.         perror("運行時出錯");  
73.         returnNULL;  
74.     }  
75. }  
76. //在鏈接池中得到一個鏈接  
77. Connection*ConnPool::GetConnection(){  
78.     Connection*con;  
79.     pthread_mutex_lock(&lock);  
80.     if(connList.size()>0)//鏈接池容器中還有鏈接  
81.     {  
82.         con=connList.front();//獲得第一個鏈接  
83.         connList.pop_front();//移除第一個鏈接  
84.         if(con->isClosed())//若是鏈接已經被關閉，刪除後從新創建一個  
85.         {  
86.             deletecon;  
87.             con=this->CreateConnection();  
88.         }  
89.         //若是鏈接爲空，則建立鏈接出錯  
90.         if(con==NULL)  
91.         {  
92.             --curSize;  
93.         }  
94.         pthread_mutex_unlock(&lock);  
95.         returncon;  
96.     }  
97.     else{  
98.         if(curSize< maxSize){//還能夠建立新的鏈接  
99.             con= this->CreateConnection();  
100.             if(con){  
101.                 ++curSize;  
102.                 pthread_mutex_unlock(&lock);  
103.                 returncon;  
104.             }  
105.             else{  
106.                 pthread_mutex_unlock(&lock);  
107.                 returnNULL;  
108.             }  
109.         }  
110.         else{//創建的鏈接數已經達到maxSize  
111.             pthread_mutex_unlock(&lock);  
112.             returnNULL;  
113.         }  
114.     }  
115. }  
116. //回收數據庫鏈接  
117. voidConnPool::ReleaseConnection(sql::Connection * conn){  
118.     if(conn){  
119.         pthread_mutex_lock(&lock);  
120.         connList.push_back(conn);  
121.         pthread_mutex_unlock(&lock);  
122.     }  
123. }  
124. //鏈接池的析構函數  
125. ConnPool::~ConnPool()  
126. {  
127.     this->DestoryConnPool();  
128. }  
129. //銷燬鏈接池,首先要先銷燬鏈接池的中鏈接  
130. voidConnPool::DestoryConnPool(){  
131.     list<Connection*>::iterator icon;  
132.     pthread_mutex_lock(&lock);  
133.     for(icon=connList.begin();icon!=connList.end();++icon)  
134.     {  
135.         this->DestoryConnection(*icon);//銷燬鏈接池中的鏈接  
136.     }  
137.     curSize=0;  
138.     connList.clear();//清空鏈接池中的鏈接  
139.     pthread_mutex_unlock(&lock);  
140. }  
141. //銷燬一個鏈接  
142. voidConnPool::DestoryConnection(Connection* conn)  
143. {  
144.     if(conn)  
145.     {  
146.         try{  
147.             conn->close();  
148.         }  
149.         catch(sql::SQLException&e)  
150.         {  
151.             perror(e.what());  
152.         }  
153.         catch(std::exception&e)  
154.         {  
155.             perror(e.what());  
156.         }  
157.         deleteconn;  
158.     }  
159. }