数据库连接池的实现方法(MySQL+C++)

本文主要介绍基于MySQL、使用C++语言实现数据库连接池的方法。

1. 准备依赖的文件

我们利用 MySQL 提供的“mysql-connector-c++”以及 boost 编写数据库连接池。

1.1 mysql-connector-c++安装

“mysql-connector-c++”可以从 MySQL 的官网上下载,如下图:

说明:

 

  • 上图中的链接为(https://dev.mysql.com/downloads/connector/cpp/),此链接后续可能会改变;
  • 需要根据实际情况(如 OS 及其版本)选择对应的发行版;

在上述页面中下载下来的文件,直接包含了“mysql-connector”的头文件和共享库,如下:

注意:“mysql-connector”提供的头文件“mysql_connection.h”放在了“jdbc”目录下(如上图),本文虽然使用的是C++语言,但是也需要连接该头文件。

 

1.2 boost安装

使用 yum 直接安装,如下:

yum install boost-devel.x86_64

 

2. 示例代码

数据库连接池头文件(connection_pool.h),代码如下:

#ifndef __CONNECTION_POOL_H__
#define __CONNECTION_POOL_H__

#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>
#include <pthread.h>
#include <list>
#include <string>

using namespace std;
using namespace sql;

class ConnPool
{
public:
    ~ConnPool();
    // 获取数据库连接
    Connection* GetConnection();
    // 将数据库连接放回到连接池的容器中
    void ReleaseConnection(Connection *conn);
    // 获取数据库连接池对象
    static ConnPool* GetInstance();

private:
    // 当前已建立的数据库连接数量
    int curSize;
    // 连接池定义的最大数据库连接数
    int maxSize;
    string username;
    string password;
    string url;
    // 连接池容器
    list<Connection*> connList;
    // 线程锁
    pthread_mutex_t lock;
    static ConnPool* connPool;
    Driver* driver;

    // 创建一个连接
    Connection* CreateConnection();
    // 初始化数据库连接池
    void InitConnection(int iInitialSize);
    // 销毁数据库连接对象
    void DestoryConnection(Connection *conn);
    // 销毁数据库连接池
    void DestoryConnPool();
    // 构造方法
    ConnPool(string url, string user,string password, int maxSize);
};

#endif/*_CONNECTION_POOL_H */

数据库连接池实现文件(connection_pool.cpp),代码如下:

#include <stdexcept>
#include <exception>
#include <stdio.h>
#include "connection_pool.h"

using namespace std;
using namespace sql;

ConnPool* ConnPool::connPool = NULL;

// 获取连接池对象,单例模式
ConnPool* ConnPool::GetInstance()
{
    if (connPool == NULL)
    {
        connPool = new ConnPool("tcp://192.168.213.130:3306", "root", "", 20);
    }
    
    return connPool;
}

// 数据库连接池的构造函数
ConnPool::ConnPool(string url, string userName, string password, int maxSize)
{
    this->maxSize = maxSize;
    this->curSize = 0;
    this->username = userName;
    this->password = password;
    this->url = url;
    
    try
    {
        this->driver = sql::mysql::get_driver_instance();
    }
    catch (sql::SQLException& e)
    {
        perror("get driver error.\n");
    }
    catch (std::runtime_error& e)
    {
        perror("[ConnPool] run time error.\n");
    }

    // 在初始化连接池时,建立一定数量的数据库连接
    this->InitConnection(maxSize/2);
}

// 初始化数据库连接池,创建最大连接数一半的连接数量
void ConnPool::InitConnection(int iInitialSize)
{
    Connection* conn;
    pthread_mutex_lock(&lock);
    
    for (int i = 0; i < iInitialSize; i++)
    {
        conn = this->CreateConnection();
        if (conn)
        {
            connList.push_back(conn);
            ++(this->curSize);
        }
        else
        {
            perror("Init connection error.");
        }
    }
    
    pthread_mutex_unlock(&lock);
}

// 创建并返回一个连接
Connection* ConnPool::CreateConnection()
{
    Connection* conn;
    try
    {
        // 建立连接
        conn = driver->connect(this->url, this->username, this->password);
        return conn;
    }
    catch (sql::SQLException& e)
    {
        perror("create connection error.");
        return NULL;
    }
    catch (std::runtime_error& e)
    {
        perror("[CreateConnection] run time error.");
        return NULL;
    }
}

// 从连接池中获得一个连接
Connection* ConnPool::GetConnection()
{
    Connection* con;
    pthread_mutex_lock(&lock);

    // 连接池容器中还有连接
    if (connList.size() > 0)
    {
        // 获取第一个连接
        con = connList.front();
        // 移除第一个连接
        connList.pop_front();
        // 判断获取到的连接的可用性
        // 如果连接已经被关闭,删除后重新建立一个
        if (con->isClosed())
        {
            delete con;
            con = this->CreateConnection();
            // 如果连接为空,说明创建连接出错
            if (con == NULL)
            {
                // 从容器中去掉这个空连接
                --curSize;
            }
        }
        
        pthread_mutex_unlock(&lock);
        return con;
    }
    // 连接池容器中没有连接
    else
    {
        // 当前已创建的连接数小于最大连接数,则创建新的连接
        if (curSize < maxSize)
        {
            con = this->CreateConnection();
            if (con)
            {
                ++curSize;
                pthread_mutex_unlock(&lock);
                return con;
            }
            else
            {
                pthread_mutex_unlock(&lock);
                return NULL;
            }
        }
        // 当前建立的连接数已经达到最大连接数
        else
        {
            perror("[GetConnection] connections reach the max number.");
            pthread_mutex_unlock(&lock);
            return NULL;
        }
    }
}

// 释放数据库连接,将该连接放回到连接池中
void ConnPool::ReleaseConnection(sql::Connection* conn)
{
    if (conn)
    {
        pthread_mutex_lock(&lock);
        
        connList.push_back(conn);
        
        pthread_mutex_unlock(&lock);
    }
}

// 数据库连接池的析构函数
ConnPool::~ConnPool()
{
    this->DestoryConnPool();
}

// 销毁连接池,需要先销毁连接池的中连接
void ConnPool::DestoryConnPool()
{
    list<Connection*>::iterator itCon;
    pthread_mutex_lock(&lock);
    
    for (itCon = connList.begin(); itCon != connList.end(); ++itCon)
    {
        // 销毁连接池中的连接
        this->DestoryConnection(*itCon);
    }
    curSize = 0;
    // 清空连接池中的连接
    connList.clear();

    pthread_mutex_unlock(&lock);
}

// 销毁数据库连接
void ConnPool::DestoryConnection(Connection* conn)
{
    if (conn)
    {
        try
        {
            // 关闭连接
            conn->close();
        }
        catch(sql::SQLException& e)
        {
            perror(e.what());
        }
        catch(std::exception& e)
        {
            perror(e.what());
        }
        // 删除连接
        delete conn;
    }
}

数据库连接池测试代码(test_dbpool.cpp):

#include "connection_pool.h"

//初始化连接池
ConnPool *connpool = ConnPool::GetInstance();

int main(int argc, char* argv[])
{
    Connection *con;
    Statement *state;
    ResultSet *result;
    
    // 从连接池中获取连接
    con = connpool->GetConnection();

    for (int i = 0; i < 100; i++)
    {
        state = con->createStatement();
        state->execute("use testdb");

        // 查询数据库
        result = state->executeQuery("select * from roles");
        // 打印数据库查询结果
        cout << "================================" << endl;
        while (result->next())
        {
            int nRoleId = result->getInt("role_id");
            string strOccupation = result->getString("occupation");
            string strCamp = result->getString("camp");
            cout << nRoleId << " , " << strOccupation << " , " << strCamp << endl;
        }
        cout << "i is: " << i << endl;
        cout << "================================" << endl;
    }

    delete result;
    delete state;
    connpool->ReleaseConnection(con);

    return 0;
}

编译上述文件,生成数据库连接池测试程序,如下:

g++ -o test_dbpool test_dbpool.cpp connection_pool.cpp -I /opt/liitdar/mysql-connector-c++-8.0.11-linux-el7-x86-64bit/include/jdbc/ -L /opt/liitdar/mysql-connector-c++-8.0.11-linux-el7-x86-64bit/lib64/ -lmysqlcppconn

执行上面生成的测试程序,命令如下:

./test_dbpool

程序执行(部分)结果如下:

上述结果表明我们编写的数据库连接池正常运行了。

3. 总结

这里对数据库连接池的实现代码进行简单地总结。

3.1 存放空闲连接的容器

 

数据库连接池头文件(connection_pool.h)中定义了一个list容器 connList ,使用 connList 存放空闲的连接。

3.2 线程锁

在对 connList 内的连接进行操作的时候,需要通过加锁来保证程序的安全性,所以头文件中定义了一个线程锁 lock ,通过使用 lock 保证同一时间只能有一个线程对容器 connList 进行操作。

3.3 单例模式

由于连接池类 ConnPool 要统一管理系统中的所有连接,所以在整个系统中只需要维护一个连接池对象。如果系统中定义了多个连接池对象,那么每一个对象都可以建立 maxSize 个连接,在这种情况下使用连接池没有任何意义(与不使用连接池效果一样),也破环了通过连接池统一管理系统中连接的初衷,所以数据库连接池需要使用单例模式编写连接池类:单例模式确保一个类只有一个实例,该类自己进行实例化,并且向整个系统提供这个实例。

在头文件 connection_pool.h 中,我们定义了一个静态的连接池对象 connPool ,连接池类 ConnPool 提供一个静态的公共方法 GetInstance() ,外部程序通过调用这个方法来获得连接池对象。由于把连接池类 ConnPool 的构造函数定义为私有的,所以外部的应用程序不能够通过 new 的方式来实例化连接池类,只能通过 GetInstance() 方法获得连接池对象。在 GetInstance() 方法中,需要判断连接池类中定义的连接池对象 connPool 是否为“NULL”,若为“NULL”则调用私有构造函数实例化 connPool ;若不为“NULL”,则直接返回 connPool ,这样就实现了连接池类的单例模式,从而保证了系统运行过程中只建立一个连接池类的实例对象。

 

3.4 连接池的初始化

在实例化连接池类的对象 connPool 时,要对连接池做一些初始化操作,即建立一定数量的数据库连接。本文的程序通过 void InitConnection(int iInitialSize) 方法对连接池进行初始化,创建 iInitialSize 个连接,并且将这些连接放到连接池中的容器 connList 中,每新建一个连接,当前已建立的连接数 curSize 就加1。

3.5 从连接池中获取连接

当程序进行访问数据库时,需要从连接池中获取一个连接,本文是通过 GetConnection() 方法实现的,大致步骤如下:

1. 首先判断容器中是否还有空闲连接,如果有,则取出容器中的第一个连接,并且将该连接从容器中移除;

 

1.1 判断上一步中获得的连接是否已经关闭,如果已关闭,则回收该连接的内存空间,并且重新创建一个连接,然后判断新创建的连接是否为空,如果为空,则需要将已经建立连接的数量减1,去掉这个空连接(也可以说是前面已经关闭的连接)。

 

2. 如果容器中已经没有空闲连接了,则要判断当前的 curSize 值是否已经达到规定的最大连接数 maxSize ;

 

2.1 如果小于 maxSize ,就建立一个新的连接,同时 ++curSize

2.2 如果不小于 maxSize ,则等待其他数据库访问请求释放数据库连接。

 

 

3.6 将连接放回到连接池中

连接使用完后,需要将该连接放回连接池中,本文通过 void ReleaseConnection(Connection *conn) 方法实现。该方法的具体实现就是将传进来的数据库连接(重新)添加到连接池的容器 connList 中。

3.7 销毁连接池

当程序需要销毁数据库连接池(回收连接池的内存空间)时,需要先关闭、销毁连接池中的连接(回收连接池中所有连接的内存空间),然后再释放连接池对象的内存空间(即容器的 clear 操作)。

 

发布了149 篇原创文章 · 获赞 270 · 访问量 35万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览