一種利用ADO連接池操作MySQL的解決方案（VC++）

 VC++連接MySQL數據庫 常用的方式有三種:ADO、mysql++,mysql API ; 本文只講述ADO的連接方式。

      為什么要使用連接池? 對於簡單的數據庫應用，完全可以先創建一個常連接（此連接永遠不關閉，直接數進程退出），但是這樣做至少會引起兩個問題:(1)資源競爭，多個數據庫請求操作不能同時進行，后一請求必須要等到前一請求完成后才能進行；(2)多線程情況下容易出現混亂，甚至出現資源異常釋放。還有一種方法，就是使用數據庫時創建連接，使用完后關閉連接回收資源。這種方式在數據庫操作頻繁的情況下會出現嚴重的效率問題。

數據庫連接池

     百度百科給出的解釋說明如下:

　　數據庫連接池負責分配、管理和釋放數據庫連接，它允許應用程序重復使用一個現有的數據庫連接，而不是再重新建立一個；釋放空閑時間超過最大空閑時間的數據庫連接來避免因為沒有釋放數據庫連接而引起的數據庫連接遺漏。這項技術能明顯提高對數據庫操作的性能。

   使用數據庫連接池至少帶來以下幾個好處:

  1、資源復用

    數據庫連接得到復用，避免了頻繁創建、釋放引起的系統性能開銷。減少了內存碎片以及數據庫線程（甚至是進程）的數量。

 2、提高系統響應速度

     由於數據庫連接資源得到復用，這毫無疑問會提高系統的整體響應速度。

3、避免資源泄漏

    所有的連接都集中在連接池中統一管理，這可以避免使用單一連接帶來的兩個問題。

實現原理

  一個較為完備的數據庫連接池應具備以下幾個條件：

    (1)實始化時創建一定數據量的連接對象放於連接池中。

    (2)連接池對象要有上限。

    (3)連接使用完畢后要放回連接池而不是直接釋放掉。

    (4)長期處於空閑態的連接要釋放。

最為完整的實現原理請參考百度百科:數據庫連接池。

   下面給出一個簡單的ADO數據庫連接池實現代碼:

   (說明:以下代碼沒有考慮到上述原理的第(4)點，讀者請根據自身需要自行實現之。)

//==================頭文件 =====================//
//定義數據庫連結基本信息結構
typedef struct
{
    char    db_ip[20]; //ip地址
    uint32  db_port;   //端口
    char    db_user[20];//用戶
    char    db_pwd[32];//密碼
    char    db_dbname[32];//數據庫名
}vos_dbxmlinfo_stru;



class CXCADOPOOL
{    
protected:
    CXCADOPOOL();

public:
    virtual ~CXCADOPOOL(void);

    //接口
public:
    void    InitConnection(const int iMin, const int iMax);
    bool    ExcuteSql(_bstr_t bSql, bool bCheck = true);
    bool    GetRecordSet(_bstr_t bSql, _RecordsetPtr& pRecord, long lOption = adCmdText, bool bCheck = true);


    bool    GetItemValue(_RecordsetPtr pRecord, long nIndex, int& nValue);
    bool    GetItemValue(_RecordsetPtr pRecord, long nIndex, UINT64& unValue);
    bool    GetItemValue(_RecordsetPtr pRecord, long nIndex, string& strValue);
    bool    GetItemValue(_RecordsetPtr pRecord, long nIndex, double& fValue);
    bool    GetItemValue(_RecordsetPtr pRecord, long nIndex, float& fValue);
    bool    GetItemValue(_RecordsetPtr pRecord, long nIndex, ULONG & nValue);

    bool    GetItemValue(_RecordsetPtr pRecord, long nIndex, short& nValue);
    bool    GetItemValue(_RecordsetPtr pRecord, long nIndex, unsigned char& nValue);
    bool    GetItemValue(_RecordsetPtr pRecord, string fieldname, string& strValue);

    template<class T>
    bool    GetItemValue(_RecordsetPtr pRecord, string fieldname, T& tValue);

    static CXCADOPOOL *Instance();
    _ConnectionPtr *GetTransConnection();
    void    SendTransCompMsg(_ConnectionPtr *pConptr);
    bool    ExecuteTransSql(_ConnectionPtr *pConptr, _bstr_t bSql);
private:
    bool    CreateDBConnection(_ConnectionPtr & conptr); //返回一個連接 
    void    GetConnectionString(string &strConnect);
    _ConnectionPtr * GetConnectionPtr();
    void    ReleaseConnectionPtr(_ConnectionPtr &conptr);
    void    InitDBConfig();
    bool    ExcuteWithoutCheck(_ConnectionPtr &conptr, _bstr_t bSql);
    bool    GetRecordSetWithoutCheck(_ConnectionPtr &conptr, _bstr_t bSql, _RecordsetPtr& pRecord, long lOption = adCmdText);
    static DWORD WINAPI IdleConnThreadFunc(LPVOID lParam);
private:
    
    queue<_ConnectionPtr *> m_qConn;
    int m_MinConNum;    //最小連接數
    int m_MaxConNum;    //最大連接數
    int m_CurrentNum;    //當前連接數

    HANDLE          m_Mutex;
    HANDLE            m_hEvent;
    HANDLE            m_hThread;
    DWORD            m_dwThreadId;
    HANDLE            m_hThreadEvent;
    string                m_strConnect;
    static CXCADOPOOL* _instance;
public:
    vos_dbxmlinfo_stru    m_stDBInfo;

};

template<class T>
bool CXCADOPOOL::GetItemValue(_RecordsetPtr pRecord, string fieldname, T& tValue)
{
    try
    {
        ASSERT_RECORDSET(pRecord);
        _variant_t vart = pRecord->GetCollect(_variant_t(fieldname.c_str()));
        (tValue = (T)(vart));
    }
    catch (_com_error &)
    {
        return false;
    }
    return true;
}
 extern CXCADOPOOL *pAdoPool;
//===================.CPP文件=====================//

bool CXCADOPOOL::GetItemValue( _RecordsetPtr pRecord, long nIndex, int& nValue )
{
    try
    {
        ASSERT_RECORDSET(pRecord);

        nValue = (int)(pRecord->GetFields()->GetItem(nIndex)->Value);
    }
    catch (_com_error &)
    {
        return false;
    }
    return true;
}

bool  CXCADOPOOL::GetItemValue(_RecordsetPtr pRecord, long nIndex, UINT64& unValue)
{
    try
    {
        ASSERT_RECORDSET(pRecord);

        unValue = (UINT64)pRecord->GetFields()->GetItem(nIndex)->Value;
    }
    catch (_com_error &)
    {
        return false;
    }
    return true;
}


bool CXCADOPOOL::GetItemValue(_RecordsetPtr pRecord, long nIndex, ULONG& nValue)
{

    try
    {
        ASSERT_RECORDSET(pRecord);

        nValue = (ULONG)pRecord->GetFields()->GetItem(nIndex)->Value;
    }
    catch (_com_error &)
    {
        return false;
    }
    return true;

}
bool CXCADOPOOL::GetItemValue(_RecordsetPtr pRecord, long nIndex, string& strValue)
{
    try
    {
        ASSERT_RECORDSET(pRecord);

        _variant_t vart = pRecord->GetFields()->GetItem(nIndex)->Value;
        if (vart.vt == VT_NULL)
            return true;

        strValue = (std::string)(bstr_t)vart;
    }
    catch (_com_error &)
    {
        return false;
    }

    return true;
}

bool CXCADOPOOL::GetItemValue(_RecordsetPtr pRecord, long nIndex, double& fValue)
{
    try
    {
        ASSERT_RECORDSET(pRecord);

        fValue = (double)pRecord->GetFields()->GetItem(nIndex)->Value;
    }
    catch (_com_error &)
    {
        return false;
    }

    return true;

}


bool CXCADOPOOL::GetItemValue(_RecordsetPtr pRecord, long nIndex, float& fValue)
{
    try
    {
        ASSERT_RECORDSET(pRecord);

        fValue = (float)pRecord->GetFields()->GetItem(nIndex)->Value;
    }
    catch (_com_error &)
    {
        return false;
    }
    return true;
}

bool CXCADOPOOL::GetItemValue(_RecordsetPtr pRecord, long nIndex, short &sValue)
{
    try
    {
        ASSERT_RECORDSET(pRecord);
        sValue = (short)pRecord->GetFields()->GetItem(nIndex)->Value;
    }
    catch (_com_error &)
    {
        return false;
    }
    return true;
}

bool CXCADOPOOL::GetItemValue(_RecordsetPtr pRecord, long nIndex, unsigned char& cValue)
{
    try
    {
        ASSERT_RECORDSET(pRecord);
        cValue = (unsigned char)pRecord->GetFields()->GetItem(nIndex)->Value;
    }
    catch (_com_error &)
    {
        return false;
    }
    return true;
}


CXCADOPOOL *pAdoPool = NULL;

CXCADOPOOL *CXCADOPOOL::_instance = NULL;


CXCADOPOOL::CXCADOPOOL()
{

    ::CoInitialize(NULL);

    InitDBConfig();
    GetConnectionString(m_strConnect);
    m_Mutex = ::CreateMutex(NULL, FALSE, NULL);
    m_hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    m_CurrentNum = 0;

    m_hThreadEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
    m_hThread = ::CreateThread(NULL, 0,(LPTHREAD_START_ROUTINE)IdleConnThreadFunc, this, 0, &m_dwThreadId);
    WaitForSingleObject(m_hThreadEvent, INFINITE);
    CloseHandle(m_hThreadEvent);
   
}

CXCADOPOOL::~CXCADOPOOL(void)
{
    ::CoUninitialize();
}

void CXCADOPOOL::InitConnection(const int iMin, const int iMax)
{
    static bool bInitial = true;
    if (bInitial)
    {
        m_MinConNum = iMin;
        m_MaxConNum = iMax;
        for (int i = 0; i < iMin; i++)
        {
            _ConnectionPtr *conptr = new _ConnectionPtr;
            if (CreateDBConnection(*conptr))
            {
                WaitForSingleObject(m_Mutex,INFINITE);
                m_qConn.push(conptr);
                m_CurrentNum++;
                ReleaseMutex(m_Mutex);
            }
        }
        bInitial = false;
    }
}
        
bool CXCADOPOOL::CreateDBConnection(_ConnectionPtr & conptr)
{
    try
    {
        //conptr.CreateInstance("ADODB.Connection");
        conptr.CreateInstance(__uuidof(Connection));
    
        HRESULT hr = conptr->Open(m_strConnect.c_str(), "", "", adModeUnknown);
        if (FAILED(hr))
        {
                        return false;
        }        
    }
    catch (_com_error &e)
    {
                return false;
    }
    return true;
}

void CXCADOPOOL::GetConnectionString(string &strConnect)
{
    USES_CONVERSION;
    CString str;
    str.Format(_T("Driver=MySQL ODBC 5.3 Unicode Driver;SERVER=%s;UID=%s;PWD=%s;DATABASE=%s;PORT=%d"),
        A2T((char*)m_stDBInfo.db_ip), A2T((char*)m_stDBInfo.db_user), A2T((char*)m_stDBInfo.db_pwd), A2T((char*)m_stDBInfo.db_dbname), m_stDBInfo.db_port);
    strConnect = T2A(str);

}

void CXCADOPOOL::InitDBConfig()
{
    GetPrivateProfileStringA("DBInfo", "host", "localhost", m_stDBInfo.db_ip, 20, ".\\DB.ini");
    m_stDBInfo.db_port = GetPrivateProfileIntA("DBInfo", "port", 3306, ".\\DB.ini");
    GetPrivateProfileStringA("DBInfo", "dbname", "", m_stDBInfo.db_dbname, 32, ".\\DB.ini");
    GetPrivateProfileStringA("DBInfo", "user", "", m_stDBInfo.db_user, 20, ".\\DB.ini");

    char pbuf_text[255] = { 0 };
    GetPrivateProfileStringA("DBInfo", "password", "", pbuf_text, 255, ".\\DB.ini");  
}

bool CXCADOPOOL::ExcuteSql(_bstr_t bSql, bool bCheck)
{
 
    _ConnectionPtr *conptr = GetConnectionPtr();
    bool bExec = ExcuteWithoutCheck(*conptr, bSql);
    PostThreadMessage(m_dwThreadId, WM_USER_DB_THREAD_MSG, (WPARAM)conptr,NULL);
    return bExec;
}

_ConnectionPtr *  CXCADOPOOL::GetConnectionPtr()
{
    //找出空閑連接
    while (1)
    {
        WaitForSingleObject(m_Mutex, INFINITE);
        _ConnectionPtr *conptr;
        if (m_qConn.empty())
        {
            if (m_CurrentNum < m_MaxConNum)
            {
                conptr = new _ConnectionPtr;
                if (CreateDBConnection(*conptr))
                {
                    m_CurrentNum++;
                }
            }
            else
            {
                //等待連接釋放
                ResetEvent(m_hEvent);
                ReleaseMutex(m_Mutex);
                WaitForSingleObject(m_hEvent, INFINITE);
                continue;
            }
        }
        else
        {
            conptr = m_qConn.front();
            m_qConn.pop();
        }

        ReleaseMutex(m_Mutex);
        return conptr;
    }
    
    
}

DWORD WINAPI CXCADOPOOL::IdleConnThreadFunc(LPVOID lParam)
{
    MSG msg;
    PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
    CXCADOPOOL *pCXCADOPOOL = static_cast<CXCADOPOOL *>(lParam);
    SetEvent(pCXCADOPOOL->m_hThreadEvent);

    while (1)
    {
        if (GetMessage(&msg, 0, 0, 0))
        {
            switch (msg.message)
            {
            case WM_USER_DB_THREAD_MSG:
            {
                _ConnectionPtr *conptr = (_ConnectionPtr *) (msg.wParam);
            
                WaitForSingleObject(pCXCADOPOOL->m_Mutex,INFINITE);
                pCXCADOPOOL->m_qConn.push(conptr);
                ReleaseMutex(pCXCADOPOOL->m_Mutex);
                SetEvent(pCXCADOPOOL->m_hEvent);
                
            }
            default:
                break;
            }
        }
    }
    return 0;
}

void CXCADOPOOL::ReleaseConnectionPtr(_ConnectionPtr &conptr)
{
    if (conptr != NULL)
    {
        conptr->Close(); //關閉連接
        conptr.Release(); //釋放內存
        conptr = NULL;

    }

}

bool CXCADOPOOL::ExcuteWithoutCheck(_ConnectionPtr &conptr, _bstr_t bSql)
{
    int i = 0;
    while (i < 3)
    {
        try
        {
            if (0 != i)
            {
                ReleaseConnectionPtr(conptr);
                CreateDBConnection(conptr);
            }
            ++i;
            VARIANT nRecordAffected = { 0 };
            conptr->Execute(bSql, &nRecordAffected, adCmdText);
            //ReleaseMutex(m_Mutex);

            if (nRecordAffected.date < 0)
            {
                return false;
            }
            break;
        }
        catch (_com_error&e)
        {
                    }
        catch (...)
        {
                
                 }
    }
    if (i == 3)
    {
       return false;
    }

    return true;
}

bool CXCADOPOOL::GetRecordSet(_bstr_t bSql, _RecordsetPtr& pRecord, long lOption /*= adCmdText*/, bool bCheck)
{     465     _ConnectionPtr *conptr = GetConnectionPtr();
    bool bExec = GetRecordSetWithoutCheck(*conptr, bSql, pRecord,lOption);
    PostThreadMessage(m_dwThreadId, WM_USER_DB_THREAD_MSG, (WPARAM)conptr, NULL);
    return bExec;
}

bool CXCADOPOOL::GetRecordSetWithoutCheck(_ConnectionPtr &conptr, _bstr_t bSql, _RecordsetPtr& pRecord, long lOption /*= adCmdText*/)
{
    for (int i = 0; i < 3; ++i)
    {
        try
        {
            if (0 != i)
            {
                ReleaseConnectionPtr(conptr);
                CreateDBConnection(conptr);
            }
            HRESULT hr = pRecord.CreateInstance(__uuidof(Recordset));
            if (SUCCEEDED(hr))
            {
                pRecord->CursorLocation = adUseClient;
                HRESULT ht = pRecord->Open(bSql, _variant_t((IDispatch *)conptr), adOpenDynamic, adLockOptimistic, lOption);
                return SUCCEEDED(ht);
            }
            return false;
        }
        catch (_com_error&e)
        {        }
        catch (...)
        {
                }
    }
    return false;
}

bool CXCADOPOOL::GetItemValue(_RecordsetPtr pRecord, string fieldname, string& strValue)
{
    try
    {
        ASSERT_RECORDSET(pRecord);
        _variant_t vart = pRecord->GetCollect(_variant_t(fieldname.c_str()));
        strValue = (std::string)(bstr_t)vart;
    }
    catch (_com_error &)
    {
        return false;
    }
    return true;
}

CXCADOPOOL * CXCADOPOOL::Instance()
{
    if (NULL == _instance)
    {
        _instance = new CXCADOPOOL;
    }
    return _instance;
}

_ConnectionPtr * CXCADOPOOL::GetTransConnection()
{
    _ConnectionPtr *pConptr = this->GetConnectionPtr();
    //執行一個查詢語句驗證下確保當前連接可用
    if ((*pConptr)->State != adStateOpen)
    {
        ReleaseConnectionPtr(*pConptr);
        CreateDBConnection(*pConptr);
    }
    return pConptr;
}

void CXCADOPOOL::SendTransCompMsg(_ConnectionPtr *pConptr)
{
    PostThreadMessage(m_dwThreadId, WM_USER_DB_THREAD_MSG, (WPARAM)pConptr, NULL);
}

bool CXCADOPOOL::ExecuteTransSql(_ConnectionPtr *pConptr, _bstr_t bSql)
{
  return ExcuteWithoutCheck(*pConptr, bSql);
}