基于MysqlConnector/C++的數(shù)據(jù)庫連接池的實現(xiàn)是怎樣的

基于MysqlConnector/C++的數(shù)據(jù)庫連接池的實現(xiàn)是怎樣的，針對這個問題，這篇文章詳細介紹了相對應(yīng)的分析和解答，希望可以幫助更多想解決這個問題的小伙伴找到更簡單易行的方法。

1.連接池的介紹：

1.1應(yīng)用背景：

一般的應(yīng)用程序都會訪問到數(shù)據(jù)庫，在程序訪問數(shù)據(jù)庫的時候，每一次數(shù)據(jù)訪問請求都必須經(jīng)過下面幾個步驟：建立數(shù)據(jù)庫連接，打開數(shù)據(jù)庫，對數(shù)據(jù)庫中的數(shù)據(jù)進行操作，關(guān)閉數(shù)據(jù)庫連接。而建立數(shù)據(jù)庫連接和打開數(shù)據(jù)庫是一件很消耗資源并且費時的工作，如果在系統(tǒng)中很頻繁的發(fā)生這種數(shù)據(jù)庫連接，必然會影響到系統(tǒng)的性能，甚至?xí)?dǎo)致系統(tǒng)的崩潰。

1.2技術(shù)思想：

在系統(tǒng)初始化階段，建立一定數(shù)量的數(shù)據(jù)庫連接對象(Connection)，并將其存儲在連接池中定義的容器中。當有數(shù)據(jù)庫訪問請求時，就從連接池中的這個容器中拿出一個連接；當容器中的連接已經(jīng)用完，并且還沒有達到系統(tǒng)定義的最大連接數(shù)時，可以再創(chuàng)建一個新的連接，當當前使用的連接數(shù)達到最大連接數(shù)時，就要等待其他訪問請求將連接放回容器后才能使用。當使用完連接的時候，必須將連接放回容器中，這樣不同的數(shù)據(jù)庫訪問請求就可以共享這些連接，通過重復(fù)使用這些已經(jīng)建立的數(shù)據(jù)庫連接，可以解決上節(jié)中說到的頻繁建立連接的缺點，從而提高了系統(tǒng)的性能。

經(jīng)過上述描述，我們可以歸納出數(shù)據(jù)庫連接池的主要操作：

(1)首先建立一個數(shù)據(jù)庫連接池對象

(2)初始化一定數(shù)量的數(shù)據(jù)庫連接，放入連接池對象的容器中

(3)當有數(shù)據(jù)庫訪問請求時，直接從連接池的容器中得到一個連接，這里出現(xiàn)三種情況：

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

(b)當容器中沒有連接時，并且當前建立的連接數(shù)沒有達到系統(tǒng)定義的最大連接數(shù)，則創(chuàng)建一個新的數(shù)據(jù)庫連接。

(c)當容器中的沒有連接并且當前建立的連接數(shù)達到系統(tǒng)定義的最大連接數(shù)，則當前訪問數(shù)據(jù)庫請求就要等待其他訪問請求釋放連接。

(4)當數(shù)據(jù)庫訪問完成后，應(yīng)該將連接放回連接池的容器中。

(5)當服務(wù)停止時，需要先釋放數(shù)據(jù)庫連接池中的所有數(shù)據(jù)庫連接，然后再釋放數(shù)據(jù)庫連接池對象。

2.編程實現(xiàn)：

頭文件(connection_pool.h)：

[html] view
plaincopy

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. intcurSize;//當前已建立的數(shù)據(jù)庫連接數(shù)量  

23. intmaxSize;//連接池中定義的最大數(shù)據(jù)庫連接數(shù)  

24. stringusername;  

25. stringpassword;  

26. stringurl;  

27. list<Connection*>connList;//連接池的容器隊列  

28. pthread_mutex_tlock;//線程鎖  

29. staticConnPool *connPool;  

30. Driver*driver;  

31. 
    

32. Connection*CreateConnection();//創(chuàng)建一個連接  

33. voidInitConnection(int iInitialSize);//初始化數(shù)據(jù)庫連接池  

34. voidDestoryConnection(Connection *conn);//銷毀數(shù)據(jù)庫連接對象  

35. voidDestoryConnPool();//銷毀數(shù)據(jù)庫連接池  

36. ConnPool(stringurl,string user,string password,int maxSize);//構(gòu)造方法  

37. public:  

38. ~ConnPool();  

39. Connection*GetConnection();//獲得數(shù)據(jù)庫連接  

40. voidReleaseConnection(Connection *conn);//將數(shù)據(jù)庫連接放回到連接池的容器中  

41. staticConnPool *GetInstance();//獲取數(shù)據(jù)庫連接池對象  

42. };  

43. #endif  /*_CONNECTION_POOL_H */  

頭文件中定義了一個容器connList,里面存放了很多個未使用的連接；在對容器內(nèi)的連接進行操作的時候，需要加鎖來保證程序的安全性，所以頭文件中定義了一個lock，通過使用lock保證了同一時間只有一個線程對容器進行操作。

連接池類要統(tǒng)一管理整個應(yīng)用程序中的連接，所以在整個系統(tǒng)中只需要維護一個連接池對象，試想：如果系統(tǒng)中定義了多個連接池對象，那么每一個對象都可以建立maxSize個連接，這樣就失去了創(chuàng)建連接池的初衷，破環(huán)了通過連接池統(tǒng)一管理系統(tǒng)中連接的思想。所以這里使用單例模式編寫連接池類，單例模式確保一個類只有一個實例，自己進行實例化并且向整個系統(tǒng)提供這個實例。在頭文件中，我們定義了一個靜態(tài)的連接池對象connPool，連接池類提供一個靜態(tài)的公共方法GetInstance(),外部程序通過調(diào)用這個方法來獲得連接池對象。并且將連接池類的構(gòu)造函數(shù)定義為私有的，外部的應(yīng)用程序不能夠通過new來實例化連接池類，只能通過GetInstance()方法獲得連接池對象；在GetInstance()方法中需要判斷連接池類中定義的connPool是否為NULL，若為NULL則調(diào)用私有構(gòu)造函數(shù)實例化connPool，若不為空，則直接返回connPool。這樣就實現(xiàn)了連接池類的單例模式，從而保證了系統(tǒng)運行過程中只建立一個連接池類的實例對象。

在實例化連接池類的對象時，要對連接池做一些初始化的操作，即建立一定數(shù)量的數(shù)據(jù)庫連接。程序中通過InitConnection(intiInitialSize)方法對連接池進行初始化，創(chuàng)建iInitialSize個連接，并且將這些連接放在連接池中的容器connList中，每新建一個連接，curSize就加1。當有數(shù)據(jù)庫訪問請求時，需要從連接池中獲取一個連接，通過GetConnection()方法實現(xiàn)：首先判斷容器中是否還有連接，如果有，則拿出容器中的第一個連接，并且將該連接移出容器；獲得的連接要進行判斷，如果連接已經(jīng)關(guān)閉，則回收該連接的內(nèi)存空間，并且重新創(chuàng)建一個連接；然后判斷新創(chuàng)建的連接是否為空，如果為空，則說明當前已經(jīng)建立連接的數(shù)量并不是curSize個，而是(curSize-1)個(應(yīng)該除去這個空連接)。如果容器中已經(jīng)沒有連接了，則要判斷當前的curSize值是否已經(jīng)達到規(guī)定的maxSize，如果沒有小于maxSize，將建立一個新的連接(++curSize)。如果超過maxSize則等待其他數(shù)據(jù)庫訪問請求釋放數(shù)據(jù)庫連接。

連接使用完以后，需要將連接放回連接池中，通過ReleaseConnection(sql::Connection* conn)方法實現(xiàn)，它的實現(xiàn)非常簡單，就是將傳進來的connection連接添加到連接池的容器中。

當需要回收連接池的內(nèi)存空間時，需要先回收連接池中所有連接的內(nèi)存空間，然后再釋放連接池對象的內(nèi)存空間。

實現(xiàn)數(shù)據(jù)庫連接池主要的步驟就是上述這些，具體的代碼實現(xiàn)如下所示：

[cpp] view
plaincopy

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. //連接池的構(gòu)造函數(shù)

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("驅(qū)動連接出錯;\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. //初始化連接池，創(chuàng)建最大連接數(shù)的一半連接數(shù)量

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("創(chuàng)建CONNECTION出錯");  

54.         }  

55.     }  

56.     pthread_mutex_unlock(&lock);  

57. }  

58. //創(chuàng)建連接,返回一個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("創(chuàng)建連接出錯");  

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())//如果連接已經(jīng)被關(guān)閉，刪除后重新建立一個

85.         {  

86.             deletecon;  

87.             con=this->CreateConnection();  

88.         }  

89.         //如果連接為空，則創(chuàng)建連接出錯

90.         if(con==NULL)  

91.         {  

92.             --curSize;  

93.         }  

94.         pthread_mutex_unlock(&lock);  

95.         returncon;  

96.     }  

97.     else{  

98.         if(curSize< maxSize){//還可以創(chuàng)建新的連接

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{//建立的連接數(shù)已經(jīng)達到maxSize

111.             pthread_mutex_unlock(&lock);  

112.             returnNULL;  

113.         }  

114.     }  

115. }  

116. //回收數(shù)據(jù)庫連接

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. //連接池的析構(gòu)函數(shù)

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. }  

[cpp]
view plaincopyprint?

1. /*

2.  * main.cpp

3.  *

4.  *  Created on: 2013-3-26

5.  *      Author: holy

6.  */

7. 
   

8. #include "connection_pool.h"

9. 
   

10. namespace ConnectMySQL {  

11. 
    

12. //初始化連接池

13. ConnPool *connpool = ConnPool::GetInstance();  

14. 
    

15. void run() {  

16. 
    

17.     Connection *con;  

18.     Statement *state;  

19.     ResultSet *result;  

20. 
    

21.     // 從連接池中獲取mysql連接

22.     con = connpool->GetConnection();  

23. 
    

24.     state = con->createStatement();  

25.     state->execute("use holy");  

26. 
    

27.     // 查詢

28.     result = state->executeQuery("select * from student where id < 1002");  

29. 
    

30.     // 輸出查詢

31.     while (result->next()) {  

32.         int id = result->getInt("id");  

33.         string name = result->getString("name");  

34.         cout << id << " : " << name << endl;  

35.     }  

36.     delete state;  

37.     connpool->ReleaseConnection(con);  

38. }  

39. }  

40. 
    

41. int main(int argc, char* argv[]) {  

42.     ConnectMySQL::run();  

43.     return 0;  

44. }  

關(guān)于基于MysqlConnector/C++的數(shù)據(jù)庫連接池的實現(xiàn)是怎樣的問題的解答就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，如果你還有很多疑惑沒有解開，可以關(guān)注億速云行業(yè)資訊頻道了解更多相關(guān)知識。