================================================================
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;
}
};