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

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

DBMapping类:

class DBMapping{

private:

map<string,DBTable *> *pTableMap;

void delTabPtrFromMap(map<string,DBTable*> *pMap);

public:

DBMapping();

~DBMapping();

void addTable(string tableName,DBTable* pDBTable);

DBTable * getTable(string tableName);

};

DBMapping::DBMapping()

{

pTableMap=new map<string,DBTable *>;

pTableMap->clear();

}

DBMapping::~DBMapping()

{

delTabPtrFromMap(pTableMap);

delete pTableMap;

pTableMap=NULL;

}

void DBMapping::delTabPtrFromMap(map<string,DBTable*> *pMap)

{

MapOpertor<map<string,DBTable*>,DBTable>::deletePtr(pMap);

}

void DBMapping::addTable(string tableName, DBTable *pDBTable)

{

MapOpertor<map<string,DBTable*>,DBTable>::addPtr(pTableMap,pDBTable,tableName);

}

DBTable * DBMapping::getTable(string tableName)

{

return MapOpertor<map<string,DBTable*>,DBTable>::getPtr(pTableMap,tableName);

}

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

DBManager类:

class DBManager{

private:

DBConfig *pDBConfig;

string globalXmlFile;

void initDataSouce(XMLNode node);

void initModelConfig();

void initModelFile(string fileName);

void initModelLib();

string readXmlFile(string xmlFile);

static DBManager *pDBManager;

vector<ModelLib*> modelLibVector;

vector<string> modleVector;

vector<Library*> libVector;

public:

~DBManager();

DBConfig * getDBConfig();

bool init();

static DBManager * getInstance();

};

#include "DBManager.hpp"

DBManager* DBManager::pDBManager=NULL;

DBManager::~DBManager()

{

if (pDBConfig!=NULL){

delete pDBConfig;

pDBConfig=NULL;

}

for(int i=0;i<modelLibVector.size();i++){

ModelLib* pModelLib=(ModelLib*)modelLibVector[i];

Library* pLibrary=(Library*)libVector[i];

for(int j=0;j<pModelLib->classNameVector.size();j++){

string className=pModelLib->classNameVector[j];

void *ptr=LibraryMgr::getInstance()->getFunction(className.c_str());

typedef void (*fun)(void*);

fun tmpFun;

string objDelName="delete_"+className+"_Proxy";

tmpFun=(fun)pLibrary->getFunction(objDelName);

tmpFun(ptr);

}

if (pModelLib!=NULL){

delete pModelLib;

pModelLib=NULL;

}

if (pLibrary!=NULL){

delete pLibrary;

pLibrary=NULL;

}

}

}

DBConfig * DBManager::getDBConfig()

{

return pDBConfig;

}

DBManager * DBManager::getInstance()

{

if (pDBManager==NULL){

pDBManager=new DBManager();

if (pDBManager->init()==false){

return NULL;

}

}

return pDBManager;

}

string DBManager::readXmlFile(string xmlFile)

{

string lineBuf="",xmlBuf="";

ifstream initFile(xmlFile.c_str(),ios::in );

bool fitstLine=true;

while (getline(initFile,lineBuf,'/n')) {

if (fitstLine==true){

fitstLine=false;

continue;

}

xmlBuf.append(ComFun::trim(string(lineBuf)));

}

//cout<<xmlBuf<<endl;

return xmlBuf;

}

bool DBManager::init()

{

pDBConfig=new DBConfig();

modelLibVector.clear();

modleVector.clear();

libVector.clear();

char xmlFilPath[400];

memset(xmlFilPath,0,400);

strcpy(xmlFilPath,getenv("OrmDao"));

ComFun::trim(xmlFilPath);

string xmlFile=string(xmlFilPath);

string xmlContent=readXmlFile(xmlFile);

XMLNode rootNode=XMLNode::parseString((const char*)xmlContent.c_str(),"global-config");

if (rootNode.isEmpty()){

return false;

}

XMLNode dataSoucetNode=rootNode.getChildNode("datasouce");

if (dataSoucetNode.isEmpty()){

return false;

}

initDataSouce(dataSoucetNode);

XMLNode modelsNode=rootNode.getChildNode("models");

for(int i=0;i<modelsNode.nChildNode();i++){

XMLNode modelNode=modelsNode.getChildNode(i);

if (!modelNode.isEmpty()){

if (modelNode.getAttribute("value")!=NULL){

modleVector.push_back(string(ComFun::trim(modelNode.getAttribute("value"))));

}

}

}

initModelConfig();

initModelLib();

//cout<<"DBManager::init() 结束"<<endl;

return true;

}

void DBManager::initModelLib()

{

for(int i=0;i<modelLibVector.size();i++){

ModelLib* pModelLib=(ModelLib*)modelLibVector[i];

Library *pLibrary=new Library(pModelLib->libName,pModelLib->libPath);

libVector.push_back(pLibrary);

for(int j=0;j<pModelLib->classNameVector.size();j++){

string className=pModelLib->classNameVector[j];

string objCreateName="create_"+className+"_Proxy";

typedef void* creatObj();

creatObj *ptrCreate=(creatObj *)pLibrary->getFunction(objCreateName);

void *pCreateProxy=ptrCreate();

LibraryMgr::getInstance()->addFunction(className.c_str(),pCreateProxy);

}

}

}

void DBManager::initModelConfig()

{

DBMapping *pDBMapping=new DBMapping();

pDBConfig->setDBMapping(pDBMapping);

for(int i=0;i<modleVector.size();i++){

string model=modleVector[i];

initModelFile(model);

}

}

void DBManager::initModelFile(string fileName)

{

string xmlContent=readXmlFile(fileName);

XMLNode modelRootNode=XMLNode::parseString((const char*)xmlContent.c_str(),"model");

if (!modelRootNode.isEmpty()){

ModelLib* pModelLib=new ModelLib();

pModelLib->classNameVector.clear();

if (modelRootNode.getAttribute("name")!=NULL&&modelRootNode.getAttribute("path")!=NULL){

pModelLib->libName=string(modelRootNode.getAttribute("name"));

pModelLib->libPath=string(modelRootNode.getAttribute("path"));

}

XMLNode tablesNode=modelRootNode.getChildNode("tables");

if (!tablesNode.isEmpty()){

for(int i=0;i<tablesNode.nChildNode();i++){

XMLNode tableNode=tablesNode.getChildNode(i);

if (!tableNode.isEmpty()){

if (tableNode.getAttribute("name")!=NULL&&tableNode.getAttribute("catalog")!=NULL

&&tableNode.getAttribute("class")!=NULL){

string className=string(ComFun::trim(tableNode.getAttribute("class")));

pModelLib->classNameVector.push_back(className);

string tableName=ComFun::toUpper(string(ComFun::trim(tableNode.getAttribute("name"))));

string tableCatalog=ComFun::toUpper(string(ComFun::trim(tableNode.getAttribute("catalog"))));

string tableFullName=tableCatalog+"."+tableName;

DBTable *pDBTable=new DBTable();

pDBTable->setName(tableName);

pDBTable->setCatalog(tableCatalog);

pDBTable->setClassName(className);

XMLNode *pPKXMLNode=NULL;

for(int j=0;j<tableNode.nChildNode();j++){

XMLNode node=tableNode.getChildNode(j);

if (!node.isEmpty()){

if (strcmp(node.getName(),"column")==0){

DBField *pDBField=new DBField();

if (node.getAttribute("name")!=NULL&&node.getAttribute("type")!=NULL){

string colName=ComFun::toUpper(string(ComFun::trim(node.getAttribute("name"))));

string sqlType=string(ComFun::trim(node.getAttribute("type")));

pDBField->setName(colName);

pDBField->setSqlType(sqlType);

if (node.getAttribute("length")!=NULL){

pDBField->setLength(atoi(node.getAttribute("length")));

}

pDBTable->addField(colName,pDBField);

}

}else if (strcmp(node.getName(),"primaryKey")==0){

pPKXMLNode=&node;

}

}

}

if (pPKXMLNode!=NULL){

if (pPKXMLNode->getAttribute("columns")!=NULL){

string columns=ComFun::trim(string(pPKXMLNode->getAttribute("columns")));

vector<string> colsVector;

colsVector.clear();

colsVector=ComFun::split(columns,",");

for(int k=0;k<colsVector.size();k++){

string priColumn=ComFun::toUpper(colsVector[k]);

DBField *pkDBField=pDBTable->getField(priColumn);

pDBTable->addFieldPK(priColumn,pkDBField);

}

}

}

pDBConfig->getDBMapping()->addTable(tableFullName,pDBTable);

}

}

}

}

modelLibVector.push_back(pModelLib);

}

}

void DBManager::initDataSouce(XMLNode node)

{

DataSouce *pDataSouce=new DataSouce();

XMLNode tmpNode=node.getChildNode("driver");

if (tmpNode.getText()!=NULL){

pDataSouce->setDriver(string(ComFun::trim(tmpNode.getText())));

}

tmpNode=node.getChildNode("username");

if (tmpNode.getText()!=NULL){

pDataSouce->setUserName(string(ComFun::trim(tmpNode.getText())));

}

tmpNode=node.getChildNode("passward");

if (tmpNode.getText()!=NULL){

pDataSouce->setPassWard(string(ComFun::trim(tmpNode.getText())));

}

tmpNode=node.getChildNode("servername");

if (tmpNode.getText()!=NULL){

pDataSouce->setServerName(string(ComFun::trim(tmpNode.getText())));

}

tmpNode=node.getChildNode("maxconn");

if (tmpNode.getText()!=NULL){

pDataSouce->setMaxConn(atoi(tmpNode.getText()));

}

tmpNode=node.getChildNode("initconn");

if (tmpNode.getText()!=NULL){

pDataSouce->setInitConn(atoi(tmpNode.getText()));

}

tmpNode=node.getChildNode("showsql");

if (tmpNode.getText()!=NULL){

if (strcmp(tmpNode.getText(),"true")==0){

pDataSouce->setShowSql(true);

}else{

pDataSouce->setShowSql(false);

}

}

pDBConfig->setDataSouce(pDataSouce);

}

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

MapOpertor操作模板类:

template <typename T1,typename T2>

class MapOpertor{

public:

static void deletePtr(T1 *pT1)

{

T1::iterator iter = pT1->begin();

while(iter!=pT1->end()){

T2 *pT2=(T2 *)iter->second;

if (pT2!=NULL){

delete pT2;

pT2=NULL;

}

iter++;

}

}

static T2 * getPtr(T1 *pT1,string key)

{

T1::iterator iter = pT1->find(key);

if (iter==pT1->end()){

return NULL;

}

return (T2 *)(iter->second);

}

static void addPtr(T1 *pT1,T2 *pT2,string key)

{

(*pT1)[key]=pT2;

}

};