C++实现的ORM映射工具类介绍(二)

 ================================================================

/*数据库连接对象*/

class Connection{
private:
   string driver;
   void   *pConn;
public:
   Connection();
   ~Connection();
   void * getConnection();
   void   releaseConnection();
   void   commit();
   void   rollback();
};

 

Connection::Connection()
{
 driver=DBManager::getInstance()->getDBConfig()->getDataSouce()->getDriver();
 pConn=NULL;
}

Connection::~Connection()
{
 releaseConnection();
}

void * Connection::getConnection()
{
 if (pConn!=NULL){
  return pConn;
 }else{
  if (driver=="oracle"){
   pConn=(void *)ConnectionPool<otl_connect>::getInstance()->getConnection();
   return pConn;
  }
 }
}

void Connection::releaseConnection()
{
 if (pConn!=NULL){
  if (driver=="oracle"){
   ConnectionPool<otl_connect>::getInstance()->freeConnection((otl_connect *)pConn);
  }
 }
}

void Connection::commit()
{
 if (pConn!=NULL){
  if (driver=="oracle"){
   ((otl_connect *)pConn)->commit();
  }
 }
}

void Connection::rollback()
{
 if (pConn!=NULL){
  if (driver=="oracle"){
   ((otl_connect *)pConn)->rollback();
  }
 }
}

===================================================================

/*数据库连接池*/

template <typename T>
struct ConnectionTraits;

template<>
struct ConnectionTraits<otl_connect>
{
 /*测试数据库连接*/
 static bool isClosed(otl_connect *pOtlConn)
 {
  try{
   otl_stream otlTest;
   otlTest.set_commit(0);
   string testSql="select 1 from dual";
   otlTest.open(5,testSql.c_str(),*pOtlConn);
  }catch(otl_exception& p){
   return true;
  }
  return false;
 }

 /*新的数据库连接*/
 static otl_connect * newConnection(string userName,string passWord,string serverName)
 { 
  otl_connect *pOtlConn=NULL;
  try{
   otl_connect *pOtlConn=new otl_connect();
   string connStr=userName+"/"+passWord+"@"+serverName;
   pOtlConn->rlogon(connStr.c_str());
   pOtlConn->auto_commit_off();
   return pOtlConn;
  }catch(otl_exception& p){
   if (pOtlConn!=NULL){
    delete pOtlConn;
    pOtlConn=NULL;
   }
   return NULL;
  }
 }

 /*释放数据库连接*/
 static void disConnect(otl_connect *pOtlConn)
 {
  pOtlConn->logoff();
 }
};

template <typename T>
class ConnectionPool{
private:
 string userName;
 string passWord;
 string serverName;
 int maxConn;
 int initConn;
 vector<T *> freeConnVector;
 int checkedOut;
 static ConnectionPool<T> *pConnectionPool;
public:
 static ConnectionPool<T> *getInstance()
 {
  if (pConnectionPool==NULL){
   pConnectionPool=new ConnectionPool<T>();
  }
  return pConnectionPool;
 }

 typedef ConnectionTraits<T> ConnectionTraitsTypeDef;

 ConnectionPool()
 {
  this->userName=DBManager::getInstance()->getDBConfig()->getDataSouce()->getUserName();
  this->passWord=DBManager::getInstance()->getDBConfig()->getDataSouce()->getPassward();
  this->serverName=DBManager::getInstance()->getDBConfig()->getDataSouce()->getServerName();
  this->maxConn==DBManager::getInstance()->getDBConfig()->getDataSouce()->getMaxConn();
  this->initConn=DBManager::getInstance()->getDBConfig()->getDataSouce()->getInitConn();
  checkedOut=0;
  freeConnVector.clear();
  init();
  /*只初始化一次*/
  cout<<"ConnectionPool()::init"<<endl;
 }

 ~ConnectionPool()
 {
  release();
 }

 void init()
 {
  for(int i=0;i<initConn;i++){
   T *t=ConnectionTraitsTypeDef::newConnection(userName,passWord,serverName);
   if (t!=NULL){
    freeConnVector.push_back(t);
   }
  }
 }

 /*获得连接*/
 T * getConnection()
 {
  T *t=NULL;
  if (freeConnVector.size()>0){
   vector<T *>::iterator itFirst=freeConnVector.begin();
   t=(T *)(*itFirst);
   freeConnVector.erase(itFirst);
   if (ConnectionTraitsTypeDef::isClosed(t)==true){
    delete t;
    t=NULL;
    t=getConnection();
   }
  }else if(maxConn==0||checkedOut<maxConn){
   t=ConnectionTraitsTypeDef::newConnection(userName,passWord,serverName);
  }
  if (t!=NULL){
   checkedOut++;
  }
  cout<<"T * getConnection() 获得连接结束"<<endl;
  return t;
 }

 /*释放连接*/
 void freeConnection(T *t)
 {
  if (t==NULL){
   return;
  }
  freeConnVector.push_back(t);
  checkedOut--;
  cout<<"freeConnection 释放连接结束"<<endl;
 }

 /*清除连接*/
 void release()
 {
  vector<T *>::iterator iter=freeConnVector.begin();
  while(iter!=freeConnVector.end()){
   T *t=(T *)(*iter);
   ConnectionTraitsTypeDef::disConnect(t);
   delete t;
   t=NULL;
   iter++;
  }
  freeConnVector.clear();
 }
};

template <typename T>
ConnectionPool<T> * ConnectionPool<T>::pConnectionPool=NULL;

===============================================================

/*动态库管理*/

typedef struct{
 string libName;
 string libPath;
 vector<string> classNameVector;
}ModelLib;

class LibraryMgr{
private:
 map<string, void*> libFunctions;
 static LibraryMgr* instance;
public:
 static LibraryMgr* getInstance();
 void   addFunction(const char* name, void* fun);
 void*  getFunction(const string& name);
};

LibraryMgr* LibraryMgr::instance = NULL;

LibraryMgr* LibraryMgr::getInstance()
{
 if(instance==NULL){
  instance = new LibraryMgr();
 }
 return instance;
}

void LibraryMgr::addFunction(const char* name, void* fun)
{
 libFunctions.insert(make_pair(string(name), fun));
}

void* LibraryMgr::getFunction(const string& name)
{
 map<string, void*>::const_iterator it=libFunctions.find(name);
 if( it != libFunctions.end() ){
  return it->second;
 }else{
  return NULL;
 }
}

===================================================================

/*动态库类*/

#ifdef WIN32
   #include <windows.h>
   #define _OPENDLL_(libname) LoadLibrary(libname)
   #define _GETFUNCTION_(libpoint,funname) GetProcAddress(libpoint, funname)
   #define _CLOSEDLL_(libpoint) FreeLibrary(libpoint)
   #define _DLLHANDLE_ HINSTANCE
#else
   #include <dlfcn.h>
   #define _OPENDLL_(libname) dlopen(libname, RTLD_LAZY)
   #define _GETFUNCTION_(libpoint,funname) dlsym(libpoint, funname)
   #define _CLOSEDLL_(libpoint) dlclose(libpoint)
   #define _DLLHANDLE_ void*
#endif

class Library{
private:
 string name;
 string path;
 _DLLHANDLE_ handle;
public:
 Library(const string& name, const string& path);
 ~Library();
 void* getFunction(const string& name);
};
Library::Library(const string& name, const string& path)
{
 this->name=name;
 this->path=path;
 this->handle = _OPENDLL_(path.c_str());
}

Library::~Library(){
 if( this->handle != NULL )
  _CLOSEDLL_(this->handle);
}

void* Library::getFunction(const string& name)
{
 void* pFun = _GETFUNCTION_(this->handle, name.c_str());
    return pFun;
}