模块间互相调用的一种方法

在程序设计中，需要把程序根据功能划分多个模块，多个模块间免不了互相调用一些服务函数，这样会使模块间剪不断，理还乱！

利用服务中心的思想，可以使各个模块间的关系比较简单。模块间的调用通过中心服务器交换，彼此没有联系，这样模块间可以到达低耦合，高内聚。

实现方法：

中心服务器：

 
 
class BASEFRAME_CLASS CIVMDlgSrvMgr  
{ 
         typedef map<string,CIVMBaseSrv*> SRVMAP; 
         typedef map<string,CIVMBaseSrv*>::iterator SRVMAPPtr; 
         typedef map<CIVMBaseSrv*,CIVMBaseSrv*> DLGMAP; 
         typedef map<CIVMBaseSrv*,CIVMBaseSrv*>::iterator DLGMAPPtr; 
public: 
         CIVMDlgSrvMgr(); 
         virtual ~CIVMDlgSrvMgr(); 
public: 
         static CIVMDlgSrvMgr* Instance(); 
         // 注册一个服务 
         bool RegService( string strSrvName, CIVMBaseSrv* pProvider ); 
         // 注销一个服务 
         void UnRegService( string strSrvName ); 
         // 注销一个服务提供者 
         void UnRegProvider( CIVMBaseSrv* pProvider ); 
         // 请求一个服务 
         bool QueryService( IN CIVMMsg& msg, OUT CIVMMsg& result ); 
         // 注册一个窗口 
         void RegDlg( CIVMBaseSrv* pDlg ); 
         // 注销一个窗口 
         void UnRegDlg( CIVMBaseSrv* pDlg ); 
         // 
         void CloseNoneVideoWnd(); 
         // 
         void DiableAllWnd(); 
         // 
         void EnableAllWnd(); 
         // 
         CIVMBaseSrv* GetRegDlg( string strDlgClassName ); 
protected: 
         SRVMAP m_srvMap; 
         DLGMAP m_dlgMap; 
}; 

 

在程序中，定一个中心服务器单体： 

 
 
CIVMDlgSrvMgr* g_pSrvMgr = NULL; 
CIVMDlgSrvMgr* g_pSrvMgr = NULL;  
 
CIVMDlgSrvMgr::CIVMDlgSrvMgr() 
{ 
} 
 
CIVMDlgSrvMgr::~CIVMDlgSrvMgr() 
{ 
} 
CIVMDlgSrvMgr* CIVMDlgSrvMgr::Instance() 
{ 
         if ( g_pSrvMgr == NULL ) 
         { 
                   g_pSrvMgr = new CIVMDlgSrvMgr(); 
                   ASSERT( g_pSrvMgr ); 
         } 
         return g_pSrvMgr; 
} 
 
// 注册一个服务 
bool CIVMDlgSrvMgr::RegService( string strSrvName, CIVMBaseSrv* pProvider ) 
{ 
         m_srvMap[strSrvName] = pProvider; 
         return true; 
} 
 
// 注销一个服务 
void CIVMDlgSrvMgr::UnRegService( string strSrvName ) 
{ 
         m_srvMap.erase(strSrvName); 
} 
         
// 注销一个服务提供者 
void CIVMDlgSrvMgr::UnRegProvider( CIVMBaseSrv* pProvider ) 
{ 
         SRVMAPPtr itSrv = m_srvMap.begin(); 
         for ( ; itSrv != m_srvMap.end(); itSrv++ ) 
         { 
                   if ( itSrv->second == pProvider ) 
                   { 
                            itSrv = m_srvMap.erase( itSrv ); 
                   } 
         } 
} 
  
// 请求一个服务 
//用户需要调用另外一个模块的服务函数时，调用该函数。前提是：
//另外一个模块提供了这个服务函数，并向中心服务器注册了该函数
//，如何注册，下面会做介绍。 
bool CIVMDlgSrvMgr::QueryService(IN CIVMMsg& msg, OUT CIVMMsg& result) 
{ 
         string strQuerySrvName = msg.GetMsgName(); 
         CIVMBaseSrv* pSrvProvider = m_srvMap[strQuerySrvName]; 
         if ( pSrvProvider == NULL ) 
         { 
                   return false; 
         } 
         return pSrvProvider->OnQueryMsg( msg, result ); 
} 
 
// 注册一个窗口 
void CIVMDlgSrvMgr::RegDlg( CIVMBaseSrv* pDlg ) 
{ 
         m_dlgMap[pDlg] = pDlg; 
} 
 
// 注销一个窗口 
void CIVMDlgSrvMgr::UnRegDlg( CIVMBaseSrv* pDlg ) 
{ 
         DLGMAPPtr itDlg = m_dlgMap.begin(); 
         for ( ; itDlg != m_dlgMap.end(); itDlg++ ) 
         { 
                   if ( itDlg->second == pDlg ) 
                   { 
                            m_dlgMap.erase( itDlg ); 
                            break; 
                   } 
         } 
} 
 
CIVMBaseSrv* CIVMDlgSrvMgr::GetRegDlg( string strDlgClassName ) 
{ 
         CIVMBaseDlg* pDlg = NULL; 
        DLGMAPPtr itDlg = m_dlgMap.begin(); 
         for ( ; itDlg != m_dlgMap.end(); itDlg++ ) 
         { 
                   pDlg = (CIVMBaseDlg*)(itDlg->second); 
                   if ( pDlg && pDlg->m_strDlgName == strDlgClassName ) 
                   { 
                            return pDlg; 
                   } 
         } 
         return NULL; 
} 
void CIVMDlgSrvMgr::DiableAllWnd() 
{ 
         CIVMBaseDlg* pWnd= NULL; 
         DLGMAPPtr itDlg = m_dlgMap.begin(); 
         for ( ; itDlg != m_dlgMap.end(); itDlg++ ) 
         { 
                   pWnd = (CIVMBaseDlg*)itDlg->second; 
                   if ( pWnd && IsWindow(pWnd->m_hWnd) ) 
                   { 
                            pWnd->EnableWindow(FALSE); 
                   } 
         } 
} 
 
void CIVMDlgSrvMgr::EnableAllWnd() 
{ 
         CIVMBaseDlg* pWnd= NULL; 
         DLGMAPPtr itDlg = m_dlgMap.begin(); 
         for ( ; itDlg != m_dlgMap.end(); itDlg++ ) 
         { 
                   pWnd = (CIVMBaseDlg*)itDlg->second; 
                   if ( pWnd && IsWindow(pWnd->m_hWnd) ) 
                   { 
                            pWnd->EnableWindow(TRUE); 
                   } 
         } 
} 
 
// 
void CIVMDlgSrvMgr::CloseNoneVideoWnd() 
{ 
         CIVMBaseDlg* pWnd= NULL; 
         DLGMAPPtr itDlg = m_dlgMap.begin(); 
         for ( ; itDlg != m_dlgMap.end(); itDlg++ ) 
         { 
                   pWnd = (CIVMBaseDlg*)itDlg->second; 
                   if ( pWnd && IsWindow(pWnd->m_hWnd)
 && pWnd->m_strDlgName != "CIVMMonitorDlg") 
                   { 
                            pWnd->SendMessage(WM_CLOSE); 
                   } 
         } 
} 

本站遵循Creative Commons Attribution 3.0 License，所有文章欢迎任何形式的转载，但请注明作者及出处，尊重他人劳动成果！
文章转载自： 罗索工作室 [ http://www.rosoo.net]
本文标题：模块间互相调用的一种方法
本文作者：lovezncu 本文来源:CSDN博客
本文地址： http://www.rosoo.net/a/201103/11021.html