在上一篇中，介紹了怎麼樣用動态連結庫去實作COM，但元件對我們來說仍是不透明的，我們需要知道實作元件DLL的位置，必須自己來加載元件的CreateInstance函數來獲得元件的指針.在書中第一篇就曾經提到過：COM元件可以透明地在網絡上（或本地）被重新配置設定位置，而不會影響本地客戶程式.是以，由用戶端來調用DLL并不是什麼好主意.必須有一種更好的辦法讓元件的實作更透明，更靈活！
于是，就引入了類廠的概念.什麼是類廠，類廠也是一個接口，它的職責是幫我們創造元件的對象.并傳回給客戶程式一個接口的指針.每個元件都必須有一個與之相關的類廠，這個類廠知道怎麼樣建立元件.當客戶請求一個元件對象的執行個體時，實際上這個請求交給了類廠，由類廠建立元件執行個體，然後把執行個體指針交給客戶程式。這麼說有點難明白.先看一個僞執行個體.
1.實作二個接口IX，IY (上二節中有詳細介紹)
2.實作一個元件CA，實作了IX，IY接口. （上二節中有詳細介紹）
3.對于這個元件進行注冊，把元件的資訊加入到系統資料庫中.
實作DllRegisterServer和DllUnregisterServer函數.函數具體功能就是把本元件的CLSID,ProgID,DLL的位置放入系統資料庫中.這樣程式就可以通過查詢系統資料庫來獲得元件的位置.
4.建立本元件類廠的執行個體
class CFactory:public IClassFactory
{
virtual HRESULT __stdcall QueryInterface(const IID& iid,void** ppv);
virtual ULONG __stdcall AddRef();
virtual ULONG __stdcall Release();
virtual HRESULT __stdcall CreateInstance(IUnknown* pUnknownOuter,
const IID& iid,
void** ppv);
}
在類廠執行個體中，主要的功能就是CreateInstance了，這個函數就是建立元件的相應執行個體.看它的實作：
HRESULT __stdcall CFactory::CreateInstance(IUnknown* pUnknownOuter,const IID& iid,void** ppv)
{
//...
CA* pA = new CA;
if(pA == NULL)
return E_OUTOFMEMORY;
HRESULT hr = pA->QueryInterface(iid,ppv);
pA->Release();
return hr;
}
5.在這個元件的DLL中導出DllGetClassObject函數.這個函數的功能就是建立類廠的執行個體對象并查詢接口.看其實作：
STDAPI DllGetClassObject(const CLSID& clsid,
const IID& iid,
void** ppv)
{
//....
CFactory* pFactory = new CFactory();
if(pFactory == NULL)
return E_OUTOFMEMORY;
HRESULT hr = pFactory->QueryInterface(iid,ppv);
pFactory->Release();
return hr;
}
元件的實作差不多就這麼多，下面在用戶端怎麼調用元件呢？這就需要用到COM函數庫了，由COM函數庫去查找系統資料庫，調用元件的類廠，建立元件執行個體，傳回接口.如下所示：
IUnknown* pUnk = NULL;
IX* iX = NULL;
CoInitialize(NULL);
CoCreateInstance(CLSID_Component1,CLSCTX_INPROC_SERVER,IID_IUnknown,(void**)&pUnk);
pUnk->QueryInterface(IID_IX,(void**)&iX);
pUnk->Release();
iX->Fx();
iX->Release();
CoUninitialize();
至于客戶是通過CoCreateInstance怎麼獲得元件的類廠，建立元件執行個體的.下面摘錄的一篇文章很清晰的說明了這一切：
-------------------------------------------------------------------------------------
這部分我們将構造一個建立COM元件的最小架構結構，然後看一看其内部處理流程是怎樣的
COM元件的運作機制，即COM是怎麼跑起來的。
IUnknown *pUnk=NULL;
IObject *pObject=NULL;
CoInitialize(NULL);
CoCreateInstance(CLSID_Object, CLSCTX_INPROC_SERVER, NULL, IID_IUnknown, (void**)&pUnk);
pUnk->QueryInterface(IID_IOjbect, (void**)&pObject);
pUnk->Release();
pObject->Func();
pObject->Release();
CoUninitialize();
CoCreateInstance身上，讓我們來看看它内部做了一些什麼事情。以下是它内部實作的一個僞代碼:
CoCreateInstance(....)
{
.......
IClassFactory *pClassFactory=NULL;
CoGetClassObject(CLSID_Object, CLSCTX_INPROC_SERVER, NULL, IID_IClassFactory, (void **)&pClassFactory);
pClassFactory->CreateInstance(NULL, IID_IUnknown, (void**)&pUnk);
pClassFactory->Release();
........
}
這段話的意思就是先得到類廠對象，再通過類廠建立元件進而得到IUnknown指針。
繼續深入一步，看看CoGetClassObject的内部僞碼：
CoGetClassObject(.....)
{
//通過查系統資料庫CLSID_Object，得知元件DLL的位置、檔案名
//裝入DLL庫
//使用函數GetProcAddress(...)得到DLL庫中函數DllGetClassObject的函數指針。
//調用DllGetClassObject
}
DllGetClassObject是幹什麼的，它是用來獲得類廠對象的。隻有先得到類廠才能去建立元件.
下面是DllGetClassObject的僞碼：
DllGetClassObject(...)
{
......
CFactory* pFactory= new CFactory; //類廠對象
pFactory->QueryInterface(IID_IClassFactory, (void**)&pClassFactory);
//查詢IClassFactory指針
pFactory->Release();
......
}
CoGetClassObject的流程已經到此為止，現在傳回CoCreateInstance，看看CreateInstance的僞碼：
CFactory::CreateInstance(.....)
{
...........
CObject *pObject = new CObject; //元件對象
pObject->QueryInterface(IID_IUnknown, (void**)&pUnk);
pObject->Release();
...........
}
下圖是從COM+技術内幕中COPY來的一個例圖，從圖中可以清楚的看到CoCreateInstance的整個流程。
接下來就寫下完全的源代碼，說明類廠的概念：
Component實作：(FacInterFace.dll)
// In FACE.H
#ifndef _IFACE_H
#define _IFACE_H
// interfaces
interface IX:IUnknown
{
virtual void __stdcall Fx() = 0;
};
interface IY: IUnknown
{
virtual void __stdcall Fy() = 0;
};
interface IZ: IUnknown
{
virtual void __stdcall Fz() = 0;
};
// Forward references for GUIDs
extern " C "
{
extern const IID IID_IX;
extern const IID IID_IY;
extern const IID IID_IZ;
extern const CLSID CLSID_Component1;
}
extern " C "
{
// {A33D4226-0F56-4e34-91F3-BF4F85761101}
static const IID IID_IX =
{ 0xa33d4226, 0xf56, 0x4e34,
{ 0x91, 0xf3, 0xbf, 0x4f, 0x85, 0x76, 0x11, 0x1 } };
// {41A5F090-B33A-4ae8-A1BB-EF2D0B4F8B0E}
static const IID IID_IY =
{ 0x41a5f090, 0xb33a, 0x4ae8,
{ 0xa1, 0xbb, 0xef, 0x2d, 0xb, 0x4f, 0x8b, 0xe } };
// {65411881-4E05-4b71-9CB5-943D5E0787C4}
static const IID IID_IZ =
{ 0x65411881, 0x4e05, 0x4b71,
{ 0x9c, 0xb5, 0x94, 0x3d, 0x5e, 0x7, 0x87, 0xc4 } };
}
//元件的CLSID,每個元件都有唯一的CLSID,需要把此CLSID添加到系統資料庫中去.如何添加，見Register.cpp檔案.
// {282D8F98-BC89-43d5-9225-0B1BB479CBDE}
static const CLSID CLSID_Component1 =
{ 0x282d8f98, 0xbc89, 0x43d5,
{ 0x92, 0x25, 0xb, 0x1b, 0xb4, 0x79, 0xcb, 0xde } };
#endif
元件的注冊：
// In Register.h
HRESULT RegisterServer(HMODULE hModule, const CLSID & clsid, const char * szFriendlyName, const char * szVerIndProgID, const char * szProgID);
HRESULT UnRegisterServer( const CLSID & clsid, const char * szVerIndProgID, const char * szProgID);
// In Register.cpp
// 此檔案是如何注冊元件的代碼實作，是把CLSID,ProgID,Version,Dll位置添加到
// HKEY_CLASSES_ROOT/CLSID,HKEY_CLASSES_ROOT的子鍵中去.
#include < objbase.h >
#include < assert.h >
#include " Register.h "
// set the given key and its value;
BOOL setKeyAndValue( const char * pszPath,
const char * szSubkey,
const char * szValue);
// Convert a CLSID into a char string
void CLSIDtochar( const CLSID & clsid,
char * szCLSID,
int length);
// Delete szKeyChild and all of its descendents
LONG recursiveDeleteKey(HKEY hKeyParent, const char * szKeyChild);
// size of a CLSID as a string
const int CLSID_STRING_SIZE = 39 ;
// Register the component in the registry
HRESULT RegisterServer(HMODULE hModule,
const CLSID & clsid,
const char * szFriendlyName,
const char * szVerIndProgID,
const char * szProgID)
{
//Get the Server location
char szModule[512];
DWORD dwResult = ::GetModuleFileName(hModule,szModule,sizeof(szModule)/sizeof(char));
assert(dwResult!=0);
//Convert the CLSID into a char
char szCLSID[CLSID_STRING_SIZE];
CLSIDtochar(clsid,szCLSID,sizeof(szCLSID));
//Build the key CLSID//{}
char szKey[64];
strcpy(szKey,"CLSID//");
strcat(szKey,szCLSID);
//Add the CLSID to the registry
setKeyAndValue(szKey,NULL,szFriendlyName);
//Add the Server filename subkey under the CLSID key
setKeyAndValue(szKey,"InprocServer32",szModule);
setKeyAndValue(szKey,"ProgID",szProgID);
setKeyAndValue(szKey,"VersionIndependentProgID",szVerIndProgID);
//Add the version-independent ProgID subkey under HKEY_CLASSES_ROOT
setKeyAndValue(szVerIndProgID,NULL,szFriendlyName);
setKeyAndValue(szVerIndProgID,"CLSID",szCLSID);
setKeyAndValue(szVerIndProgID,"CurVer",szProgID);
//Add the versioned ProgID subkey under HKEY_CLASSES_ROOT
setKeyAndValue(szProgID,NULL,szFriendlyName);
setKeyAndValue(szProgID,"CLSID",szCLSID);
return S_OK;
}
//
// Remove the component from the register
//
HRESULT UnRegisterServer( const CLSID & clsid, // Class ID
const char * szVerIndProgID, // Programmatic
const char * szProgID) // IDs
{
//Convert the CLSID into a char.
char szCLSID[CLSID_STRING_SIZE];
CLSIDtochar(clsid,szCLSID,sizeof(szCLSID));
//Build the key CLSID//{
}
char szKey[64];
strcpy(szKey,"CLSID//");
strcat(szKey,szCLSID);
//Delete the CLSID key - CLSID/{
}
LONG lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT,szKey);
assert((lResult == ERROR_SUCCESS) || (lResult == ERROR_FILE_NOT_FOUND));
//Delete the version-independent ProgID Key
lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT,szVerIndProgID);
assert((lResult == ERROR_SUCCESS) || (lResult == ERROR_FILE_NOT_FOUND));
//Delete the ProgID key.
lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT,szProgID);
assert((lResult == ERROR_SUCCESS) || (lResult == ERROR_FILE_NOT_FOUND));
return S_OK;
}
// Convert a CLSID to a char string
void CLSIDtochar( const CLSID & clsid,
char * szCLSID,
int length)
{
assert(length>=CLSID_STRING_SIZE);
//Get CLSID
LPOLESTR wszCLSID = NULL;
HRESULT hr = StringFromCLSID(clsid,&wszCLSID);
assert(SUCCEEDED(hr));
//Convert from wide characters to non_wide
wcstombs(szCLSID,wszCLSID,length);
//Free memory
CoTaskMemFree(wszCLSID);
}
//
// Delete a Key and all of its descendents
//
LONG recursiveDeleteKey(HKEY hKeyParent, const char * lpszKeyChild)
{
//Open the child.
HKEY hKeyChild;
LONG lRes = RegOpenKeyEx(hKeyParent,lpszKeyChild,0,KEY_ALL_ACCESS,&hKeyChild);
if(lRes != ERROR_SUCCESS)
return lRes;
//Enumerate all of the decendents of this child
FILETIME time;
char szBuffer[256];
DWORD dwSize = 256 ;
while(RegEnumKeyEx(hKeyChild,0,szBuffer,&dwSize,NULL,
NULL,NULL,&time) == S_OK)
{
//Delete the decendents of this child.
lRes = recursiveDeleteKey(hKeyChild,szBuffer);
if(lRes != ERROR_SUCCESS)
{
RegCloseKey(hKeyChild);
return lRes;
}
dwSize = 256;
}
RegCloseKey(hKeyChild);
return RegDeleteKey(hKeyParent,lpszKeyChild);
}
BOOL setKeyAndValue( const char * szKey,
const char * szSubkey,
const char * szValue)
{
HKEY hKey;
char szKeyBuf[1024];
//Copy keyname into buffer.
strcpy(szKeyBuf,szKey);
//Add subkey name to buffer.
if(szSubkey!=NULL)
{
strcat(szKeyBuf,"//");
strcat(szKeyBuf,szSubkey);
}
// Create and open key and subkey.
long lResult = RegCreateKeyEx(HKEY_CLASSES_ROOT ,
szKeyBuf,
0, NULL, REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS, NULL,
&hKey, NULL) ;
if (lResult != ERROR_SUCCESS)
{
return FALSE ;
}
// Set the Value.
if (szValue != NULL)
{
RegSetValueEx(hKey, NULL, 0, REG_SZ,
(BYTE *)szValue,
strlen(szValue)+1) ;
}
RegCloseKey(hKey) ;
return TRUE ;
}
元件的實作：
// CMPNT.cpp
// 此檔案是元件CA，元件類廠CFactory的實作，CA的實作與前面講述的是一樣的，關鍵在于多引入了
// 一個CFactory，還有一個是全局函數DllGetClassObject,另外，除了要導出DllGetClassObject之
// 外，還要導出三個函數，分别是DllCanUnloadNow / DllRegisterServer / DllUnregisterServer.
// 還有一項工作就是在DllMain中儲存子產品的資訊.
#include < iostream.h >
#include < objbase.h >
#include " ../MYIF2/IFACE.h "
#include " Register.h "
// #ifndef EXPORTAPI
// #define EXPORTAPI extern "C" __declspec(dllexport)
// #endif
void trace( const char * msg)
{cout<<msg<<endl;}
// Gobal variables
static HMODULE g_hModule = NULL ;
static long g_cComponents = 0 ; // Count of active components
static long g_cServerLocks = 0 ; // Count of locks
// Friendly name of component
const char g_szFriendlyName[] = " Inside COM.Chapter 7 Example " ;
// Version-independent ProgID
const char g_szVerIndProgID[] = " InsideCOM.Chap07 " ;
// ProgID
const char g_szProgID[] = " InsideCOM.Chap07.1 " ;
// Component
class CA: public IX, public IY
{
public:
//IUnknown
virtual HRESULT __stdcall QueryInterface(const IID& iid,void** ppv);
virtual ULONG __stdcall AddRef();
virtual ULONG __stdcall Release();
//Interface IX
virtual void __stdcall Fx()
{cout<<"Fx function"<<endl;}
//Interface IY
virtual void __stdcall Fy()
{cout<<"Fy function"<<endl;}
//Constructor
CA();
//Destructor
~CA();
private:
long m_cRef;
} ;
CA::CA():m_cRef( 1 )
{
InterlockedIncrement(&g_cComponents);
}
CA:: ~ CA()
{
InterlockedDecrement(&g_cComponents);
trace("Component:/t/tDestory self");
}
// IUnknown implementation
HRESULT __stdcall CA::QueryInterface( const IID & iid, void ** ppv)
{
if(iid == IID_IUnknown)
{
*ppv = static_cast<IX*>(this);
}
else if(iid == IID_IX)
{
*ppv = static_cast<IX*>(this);
trace("Component:/tReturn pointer to IX.");
}
else if(iid == IID_IY)
{
*ppv = static_cast<IY*>(this);
trace("Component:/tReturn pointer to IY.");
}
else
{
*ppv = NULL;
trace("Component:/tCannot Get pointer to IX/IY");
return E_NOINTERFACE;
}
reinterpret_cast<IUnknown*>(*ppv)->AddRef();
return S_OK;
}
ULONG __stdcall CA::AddRef()
{
return InterlockedIncrement(&m_cRef);
}
ULONG __stdcall CA::Release()
{
if(InterlockedDecrement(&m_cRef)==0)
{
delete this;
return 0;
}
return m_cRef;
}
///
// class factory
///
class CFactory: public IClassFactory
{
public:
//IUnknown
virtual HRESULT __stdcall QueryInterface(const IID& iid,void** ppv);
virtual ULONG __stdcall AddRef();
virtual ULONG __stdcall Release();
//Interface IClassFactory
virtual HRESULT __stdcall CreateInstance(IUnknown* pUnknownOuter,
const IID& iid,
void** ppv);
virtual HRESULT __stdcall LockServer(BOOL bLock);
//Constructor
CFactory():m_cRef(1)
{}
//Destructor
~CFactory()
{trace("Class factory:/t/tDestory self.");}
private:
long m_cRef;
} ;
HRESULT __stdcall CFactory::QueryInterface( const IID & iid, void ** ppv)
{
if((iid == IID_IUnknown) || (iid == IID_IClassFactory))
{
*ppv= static_cast<IClassFactory*>(this);
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
reinterpret_cast<IUnknown*>(*ppv)->AddRef();
return S_OK;
}
ULONG __stdcall CFactory::AddRef()
{
return InterlockedIncrement(&m_cRef);
}
ULONG __stdcall CFactory::Release()
{
if(InterlockedDecrement(&m_cRef)==0)
{
delete this;
return 0;
}
else
return m_cRef;
}
HRESULT __stdcall CFactory::CreateInstance(IUnknown * pUnknownOuter, const IID & iid, void ** ppv)
{
trace("Class factory:/t/tCreate component.");
// Cannot aggregate.
if (pUnknownOuter != NULL)
{
return CLASS_E_NOAGGREGATION ;
}
//if(pUnknownOuter!=NULL)
// return CLASS_E_NOA
CA* pA = new CA;
if(pA == NULL)
return E_OUTOFMEMORY;
//Get the request interface
HRESULT hr = pA->QueryInterface(iid,ppv);
pA->Release();
return hr;
}
// LockServer
HRESULT __stdcall CFactory::LockServer(BOOL bLock)
{
if(bLock)
{
InterlockedIncrement(&g_cServerLocks);
}
else
InterlockedDecrement(&g_cServerLocks);
return S_OK;
}
// Can Dll unload now?
int AddNum( int a, int b)
{
return a+b;
}
STDAPI DllCanUnloadNow()
{
if((g_cComponents ==0 ) && (g_cServerLocks==0))
return S_OK;
else
return S_FALSE;
}
STDAPI DllGetClassObject( const CLSID & clsid,
const IID & iid,
void ** ppv)
{
trace("DllGetClassObject:/tCreate Class factory");
if(clsid != CLSID_Component1)
{
return CLASS_E_CLASSNOTAVAILABLE;
}
CFactory* pFactory = new CFactory();
if(pFactory == NULL)
return E_OUTOFMEMORY;
//Get request interfaces
HRESULT hr = pFactory->QueryInterface(iid,ppv);
pFactory->Release();
return hr;
}
// Server registration
STDAPI DllRegisterServer()
{
return RegisterServer(g_hModule,CLSID_Component1,g_szFriendlyName,
g_szVerIndProgID,g_szProgID);
}
// Server unregistration
STDAPI DllUnregisterServer()
{
return UnRegisterServer(CLSID_Component1,g_szVerIndProgID,g_szProgID);
}
BOOL APIENTRY DllMain(HANDLE hModule,
DWORD dwReason,
void * lpReserved)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
g_hModule = (HMODULE)hModule ;
}
return TRUE ;
}
以上是元件的實作。下面是用戶端的代碼實作：
// In Client.cpp
int main()
{
HRESULT hr;
::CoInitialize(NULL);
trace("Call CoCreateInstance to Create");
trace(" componet and get interface IX");
IX* pIX = NULL;
hr = ::CoCreateInstance(CLSID_Component1,
NULL,
CLSCTX_INPROC_SERVER,
IID_IX,
(void**)&pIX);
if(SUCCEEDED(hr))
{
trace("Succeeded getting IX");
pIX->Fx();
trace("Ask for Interface IY");
IY* pIY = NULL;
hr = pIX->QueryInterface(IID_IY,(void**)&pIY);
if(SUCCEEDED(hr))
{
trace("Succeeded getting IY");
pIY->Fy();
pIY->Release();
trace("Release IY interface");
}
else
{
trace("Could not get interface IY.");
}
pIX->Release();
}
else
cout<<"Client: /t/tCould not create component hr="<<hex<<hr<<endl;
CoUninitialize();
}
再在最後詳述一篇，用戶端調用CoCreateInstance，導緻調用CoGetClassObject，CoGetClassObject通過查找系統資料庫，得知DLL位置，檔案名，然後調用DLL中DllGetClassObject，
DllGetClassObject的功能是傳回CFactory的執行個體.
傳回後，回到CoCreateInstance，通過CFactory的指針，調用
pClassFactory->CreaetInstance()建立元件執行個體.
這樣就傳回了元件執行個體的指針.
CoCreateInstace --> CoGetClassObject --> DllGetClassObject --> Get CFactory*
<-------------------------------------------------------
--> CFactory->CreateInstance(); --> Get IX*
IX->Fx();
來源：http://www.cnblogs.com/shipfi/archive/2007/02/13/649196.html