COM组件模型基础

一年又一年，已经又过了一年了。我VC的生涯已经两岁了。可以相当地庆贺一下哟。回顾这一年的学习(唉，还没有工作实践呢。这年头，工作不好找哇。),还学了不少的好东西。其中，最重要的就是COM组件模型，我个人觉得这个几乎是Windows的核心。许多先进的技术(比如微软著名的DirectX,ADO,没有人会不知道吧)都以COM组件的形式发布的。现在，我瞄上了另一个好东东，就是泛型编程技术。它能够编写出清晰、灵活、高度可重用的代码，在ATL中就可以依稀看出它的影子(现在网上ATL文章有很多,我以后也会谈到它)。好了，关于泛型编程的事今后再谈。

按照我以前的计划，我应该谈谈我对COM组件模型的认识了。一来可以对自己的学习状况进行总结。二来，请教高手，可以帮忙指出错漏之处。三来，说不定会对初学者们有所帮助。请各位高手多多指正啊.在这里先谢了。

一、动态链接库:

动态链态库是大部分COM组件的承载对象(不要在意ocx,它同样也是dll,只不过改了一下后缀而已)。当然Exe同样也是可以的(TTS中的TextToSpeech对象就是一个例证)，只不过在事实上要少得多。
在Windows初期，动态链态库的出现是一场革命。它改变了Windows的一生，也为当今Windows操作系统的霸主地位打下一块坚实的基石。(关于Windows的历史问题，我一直没有弄得太清楚。请VCKBASE的有关史学家们尽快写出一篇文章来吧^_^)。

微软对动态链接库就是这样解释的:

动态链接库 (DLL) 是作为共享函数库的可执行文件。动态链接提供了一种方法，使进程可以调用不属于其可执行代码的函数。函数的可执行代码位于一个 DLL 中，该 DLL 包含一个或多个已被编译、链接并与使用它们的进程分开存储的函数。DLL 还有助于共享数据和资源。多个应用程序可同时访问内存中单个 DLL 副本的内容。

嗯,讲得很清楚。动态链接库首先是一个可执行文件(微软解释说,exe叫做起直接可执行文件)，它里面包含着一组需要共享的函数。当使用时，动态链接库(和Windows系统)会提供一个方法来使我们的应用程序可以调用其中的函数。此外，动态链接库还会包含一些资源(如:图标、对话框模板等等)。在MFC中，微软在现有动态链接库的基础上施用了一些技巧来提供一些另外功能，如MFC类的导出。

动态链接库的链接方式大致分为两类: 静态链接和动态链接.

静态链接又叫隐式链接，这种链接方式使我们在代码中不用语句来指示系统中，我们的应用程序要加载哪些动态链接库。其静态链接声明是放在工程属性中的(或者使用#pragma comment(lib,"XXX.lib")，这个可以和#include放在一起)。在指定时，只需要输入其动态链接库相应的导入库文件(.lib)。然后，你就可以在程序的任何地方像调用普通函数一样调用该动态链接库中存在的函数了(当然，你需要包含其相应的头文件。一般情况下，头文件会和LIB文件一块给出)。通过这种方法生成的程序在运行初始化的时候(具体到什么时候不太清楚。但我可以肯定是在WinMain函数之前了^_^)，会自动将动态链接库加载在系统环境中，并将其映射到我们应用程序的进程当中去。当我们调用一个我们进程没有定义的函数时，VC运行库会通过查找LIB文件的相关信息找到相应动态链接库的函数并调用它。进程结束时，系统会缷载动态链接库。

动态链接又叫显式链接，顾名思义这种方式让我们必需在代码通过调用API来显式地加载动态链接库。COM组件模型全部都是采用这种方式来加载进程内组件模块(就是Dll)的。(我觉得微软的专业术语有些混乱耶)。这个方式有许多好处。它可以在运行时决定具体要加载哪个链接库，要调用哪个函数…这才叫动态链接呢。

要使用动态链接库并不难，首先要调用LoadLibrary,其原型如下:

HMODULE LoadLibrary(
  LPCTSTR lpFileName // file name of module
)

参数lpFileName是要加载的动态链接库的文件名。如果加载成功的话，就返回其句柄。否则的，返回NULL。

与这个API相配对的是FreeLibrary,其原型如下:

BOOL FreeLibrary(
  HMODULE hModule // handle to DLL module
)

这个就不用我多说了吧。

当动态链接库被LoadLibrary所加载时，C运行库通过_DllMainCRTStartup来完成动态链接库的初始化,如全局对象(变量)、静态成员变量的生成以及赋初值。最重要的是它还会调用DllMain函数。每一个动态链接库都必须有这个函数，就像应用程序必须有main或WinMain一样。它的原型是:

BOOL WINAPI DllMain(
  HINSTANCE hinstDLL, // handle to the DLL module
  DWORD fdwReason, // reason for calling function
  LPVOID lpvReserved // reserved
)

你可以通过DllMain函数来完成你的动态链接库中的环境初始化和析构操作。啊，事情是这样的:

DllMain被调用有四种情况，这四种情况可以从fdwReason参数来分别出来:

它们分别是

1. DLL_PROCESS_ATTACH，当动态链接库被加载到进程时，调用DllMain。

2. DLL_THREAD_ATTACH，当进程建立一个新线程时，进程会调用所以已加载了的动态链接库的DllMain。

3. DLL_THREAD_DETACH，当一个线程结束时，进程会调用所以已加载了的动态链接库的DllMain。

4. DLL_THREAD_DETACH，当动态链接库被缷载或进程结束时，调用DllMain。

这样，通过DllMain函数就可以反应出一个动态链接库的生命周期了。

当加载成功后，我们会得到一个HMODULE句柄。这个句柄的使用与HINSTANCE应用程序实例的句柄很相似(追查定义，HMODULE就是HINSTANCE)。我们可以使用下面一些API函数来使用HMODULE句柄:

LoadBitmap、LoadIcon、LoadString、…、GetProcAddress等等

其中，最重要的就是GetProcAddress。它是用来返回链接库中的某个函数的函数指针，然后我们就可以通过这个函数指针来调用这个链接库函数了。(如果你对函数指针不熟的话，最好再看一看C\C++语法书。我觉得函数指针的声明方法很怪异)其原型如下:

FARPROC GetProcAddress(
  HMODULE hModule, // handle to DLL module
  LPCSTR lpProcName // function name
)

啊，hModule我就不说了。lpProcName参数是一个字符串，这个字符串写着我们要找的函数的函数名。如果找到了的话，就返回这个函数的指针，否则返回NULL。

举个例子:

比如说有个链接库函数是”int Plus(int nAugend, int nAddend)”,我要调用它。

HMODULE hMathLib = LoadLibrary("Math.dll");
int (*MyProc)(int, int) = NULL;
int x = 1, y = 1;
MyProc = (int(*)(int, int)) GetProcAddress(hMathLib, "Plus");
If (MyProc != NULL)
{
    printf ("%d", (*MyProc)(x, y));
}
FreeLibrary(hMathLib)

如果我以及这个链接库没有问题的话，我想输出结果应该是2。

我仍然认为函数指针的声明很怪异，可读性并不高，所以我一般会换一种写法。

#define DefMathProc(name) int (*name)(int, int)
#define FUNCTION(name) (*name)
DefMathProc(MyProc) = NULL;
MyProc = (DefMathProc()) GetProcAddress(hMathLib, "Plus");
nResult = FUNCTION(MyProc)(x, y)

虽然会出一个警告，但我觉得这样会舒服一些。

嗯，动态链接库的情况就基本如此了。具体动态链接库的编写会和COM组件的编写一块在后续章节里谈及。

二、面向对象的组件模型-COM

Windows系统霸主地位诂计三四年内是不会被动摇的。因此，有n多Windows开发平台出现在我们面前。n多种开发语言是百花齐放啊。于是，我们像圣经里说的那样，操着不同的语言，彼此无法沟通。为改变这一现实，可爱的比尔就站出来了,”偶要改变世界!”。微软公司制定一个基于二进制通用接口规范-Component Object Model(组件对象模型)。但是，一开始COM的解决目标并非是为了通用接口，而是应用于复合文档(OLE)的实现。而今由于语言无关性、进程透明性、可重用性、保密性(除非高手高手高高手，有谁能从汇编码中看出实现技术来)、而且编写并不困难，所以发展成为了一项应用广泛的技术。

1) 组件对象与接口

组件对象、接口是COM的根基。

下面，请允许我用C++对象做一个类比。

组件对象与C++对象的意义是基本相同的。它是一个功能、属性与逻辑的整体。它是一个实体对象，通过对它的接口操作，可以使用它所提供的功能。

接口相当于C++对象中的public成员。它被暴露给外部使用者，使用者只被允许调用这些被暴露在外面的接口来使用对象的功能。与public成员有所不同的是，接口不是一个变量也不是一个函数，而应该是一组函数。在逻辑上，这个组函数应该是功能相关的。一个组件对象可以拥有许多个接口。

我只知道C++的COM实现方法，至于Dephi我就一无所知。

C++实现方法是:由C++类对象来完成组件对象的实现，由C++纯虚类来代表接口。C++类对象通过多重继承多个接口，来的拥有多个接口。

下面，我举一个例子，来说明C++中的组件对象与接口的关系(下面的例子并不是一个COM实现，只是用来表示组件对象与接口的关系)

我如果要做一个人的组件对象的话，我首先要定义一些接口来表示人的外部表现行为。

class physiology
{
public:
        virtual void eat(Food in) = 0;
        virtual void drink(Liquid in) = 0;
        virtual Somethings toilet() = 0;
};
class psychics
{
public:
        virtual Sound laugh() = 0;
        virtual Sound cry() = 0;
        virtual Sound angry() = 0;
};
class dynamics
{
public:
        virtual Speed run() = 0;
        virtual Speed walk() = 0;
        virtual Interval jump() = 0;
}

我将人的行为分成了生理学、心理学和动力学三类，让它们分别表示人不同的行为。那么，这么三组相关函数就是三个接口。C++组件对象的实现就是从这些接口中多重派生，并实现它们。这样，我们就得到一个组件对象(声明啊，本示例只是一个表示概念，真正的COM组件对象还需要加一些东东)。

class human :
        public physiology,
        public psychics,
        public dynamics
{
public:
        void eat(Food in)
{
    cout << "Good! Very delicious!";
}

void drink(Liquid in)
{
    cout << "No! I am not drunk!";
}

Something toilet()
{
    cout << "hum…….";
    return dejecta();
}

Sound laugh()
{
    return Sound("Ha…Ha…Ha");
}

Sound cry()
{
    return Sound("dad!Don’t beat my buns.");
}

Sound angry()
{
    return Sound("where did you go last night? Darling.");
}

Speed run()
{
    cout << "Run, Police come!";
    return 20km/h;
}

Speed walk()
{
    cout << "out. yegg, I am no…not afraid o….of y…you.";
    return 1m/s;
}

Interval jump()
{
    cout << "Yeah….";
    return 4m;
}
}

这样，一个组件对象就定义完了。当使用组件对象时，系统所给予你的一个指针。它是一个组件对象实现了的虚类指针，我们可以使用它来调用组件对象对于这个纯虚类所实现的功能(当然，我们有选择什么虚类指针的权利;只要组件对象支持就可以了)。

总之，一个组件对象外部特征是由不同的接口也就是这些虚类所组成，它们向使用者展现组件所提供的功能。

注:如果你的C++虚函数没学得不太好的话，那么请找一本C++语法书再看一看. 或请参看VCKBASE第12期的《解析动态联编》。

2) 标识符(GUID)

上面，我说过COM组件是基于二进制的。那么要我们使用签名(比如说类名、接口名)来指定一个组件显然是不理想的了(至少在识别方面会有些麻烦)。那么，既然是二进制系统最方便当然就是使用数字标识了。于是，微软定义了这么一个结构标准:

typedef struct _GUID
{
        DOWRD Data1;
        WORD Data2;
        WORD Data3;
        WORD Data4[8];
}GUID

结构用来储存一些数字信息，来表识一个COM对象,接口以及其它COM元素。这个结构体就叫做标识符。

在C++中一个标识符是这么表示的:

extern "C" const GUID CLISID_MYSPELLCHECKER =
{0x54bf6567, 0x1007, 0x11d1, {0xb0, 0xaa, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}}

同样的标识符在其它非C环境中是这么表示的:

{54bf6567-1007-11d1-b0aa-444553540000}

这个标识符代表着一个COM对象，这是因为一个COM对象的标识符名都以CLISID_为前缀。接口名则是以IID_为前缀。不要问我，标识符定义与对象具体有什么关系式。我不知道。它们根本就没有什么关系的。一个COM对象在编写时，我们会使用随机的方法来确定它的标识符(这个工作可以由VC来帮我们搞定)。一旦COM对象得到一个标识符并发布出去的话，那么就不能更改了。另外，不要担心GUID会有所冲突。如果你的高中数学已经及格了的话，那么请算一算128位二进制中，重复的概率会有多少。假如你真的发现了GUID有冲突的话(你要保证这不是人为)，建议你赶去买彩票吧。你离500万不远了。

3) IUnknown接口

COM模式所有接口必须遵守一定规范，这就是IUnknown接口的出处。每个一接口都必须从这个接口继承。在C++中，微软已经为我们把IUnknown定义好了:

typedef GUID IID;
class IUnknown
{
    public:
        virtual HRESULT _stdcall QueryInterface(const IID& iid, void **ppv) = 0;
        virtual ULONG _stdcall AddRef() = 0;
        virtual ULONG _stdcall Release() = 0;
}

注:void *可以指向任何对象。我开始的时候对void*一点都不理解。这里使用的原因是传出与传入指针类型不确定。

QueryInterface函数功能是当我们得到一个接口指针，并且我们想得到另一个接口指针的时候，提供帮助。我们将我们想要得到的接口的标识符传给iid,将把指针的做一个次&来传给ppv。如果QueryInterface成功的话，会返回S_OK。我们指针中就会指向我们想要的接口。

AddRef,Release用于实现引用计数机制。

在二进制系统中，组件对象不像C++环境中对象那样具有明确的生存期。可能会出现这种情况，两个(或者两个以上)的地方(可能是不同的程序之间，也可能是不同的线程之间)同时使用着一个组件对象，如果其中一个地方delete掉了组件对象的话。其它地方不可能会知道，当它们尝试调用这个象的话，轻则导致重伤，重则导致死亡。这不是我们希望看到的。于是，COM模型设制一个引用计数机制。

当一个地方开始使用对象的时候，它必须调用AddRef()一次。当我们使用QueryInterface时候，QueryInterface必须为我们调用一次AddRef()。AddRef()会使组件对象的引用计数增1。当这个地方不再使用对象时，它必须调用Release()一次。Release()会使组件对象的引用计数减1。当组件对象的引用计数变成0,就表明没有人再去使用组件对象了。这时，组件对象应该结束自己的生命。这样，就保证了组件对象生存期间其它程序的安全。

当然，你可以使用自己的引用机制，只要你的行为上支持AddRef和Release。比如说，不设置对象的引用计数，而是为每个接口设置一个引用计数。当所有的接口引用计数都为0时，delete对象。

好了，前面的示例中，我并没有遵守IUknown规范，下面我要遵守它。我把上次同样东西用……省略掉了。

// {6AAF876E-FCED-4ee0-B5D3-63CD6E2242F5}
static const GUID IID_IPhysiology =
{ 0x6aaf876e, 0xfced, 0x4ee0, { 0xb5, 0xd3, 0x63, 0xcd, 0x6e, 0x22, 0x42, 0xf5 } };
class IPhysiology:
        public IUnknown
{
public:
        ……
};

// {183FC7A1-4C27-4c38-B72D-D1326E2E8A7C}
static const GUID IID_IPsychics =
{ 0x183fc7a1, 0x4c27, 0x4c38, { 0xb7, 0x2d, 0xd1, 0x32, 0x6e, 0x2e, 0x8a, 0x7c } };
class IPsychics:
        public IUnknown
{
public:
        ……
};

// {5F144D5C-A20C-42e7-8F91-4D5CAE430B29}
static const GUID IID_IDynamics =
{ 0x5f144d5c, 0xa20c, 0x42e7, { 0x8f, 0x91, 0x4d, 0x5c, 0xae, 0x43, 0xb, 0x29 } };
class IDynamics:
        public IUnknown
{
public:
        ……
};

// {ABFA7022-7E2F-4d0e-8A4F-F58BBCEBB2DA}
static const GUID CLISID_Human =
{ 0xabfa7022, 0x7e2f, 0x4d0e, { 0x8a, 0x4f, 0xf5, 0x8b, 0xbc, 0xeb, 0xb2, 0xda } };
class human :
        public IPhysiology,
        public IPsychics,
        public IDynamics
{
public:
……
human()
{
    m_ulRef = 0;
}

HRESULT QueryInterface(const IID& iid, void **ppv)
{
    if (iid == IID_IUnknown || iid == IID_IPhysiology)
    {
        *ppv = static_cast<IPhysiology*>(this);
        (IPhysiology*)(*this))->AddRef();
    }
    else if (iid == IID_IPsychics)
    {
        *ppv = static_cast<IPsychics*>(this);
        (IPsychics*)(*this))->AddRef();
    }
    else if (iid == IID_IDynamics)
    {
        *ppv = static_cast<IDynamics*>(this);
        (IDynamics*)(*this))->AddRef();
    }
    else
    {
        *ppv = NULL;
        return E_NOTINTERFACE;
    }

    return S_OK;
}

ULONG AddRef()
{
    return ++m_ulRef;
}

ULONG Release()
{
    m_ulRef--;
    if (m_ulRef <= 0)
    {
        m_ulRef = 0;
        delete this;
    }
    return m_ulRef;
}

ULONG m_ulRef;
}

这样我们的组件对象就定义完全了。

下面给出我们这个组件对象的IDL描述和图形描述

#include "olectl.h"
import "oaidl.idl";
import "ocidl.idl";

[
        object,
        uuid(6AAF876E-FCED-4ee0-B5D3-63CD6E2242F5),
        nonextensible,
        helpstring("IPhysiology 接口"),
        pointer_default(unique)
]
interface IPhysiology : IUnknown
{
        void eat(Food in);
        void drink(Liquid in);
        Somethings toilet();
};

[
        object,
        uuid(5F144D5C-A20C-42e7-8F91-4D5CAE430B29),
        nonextensible,
        helpstring("IPsychics 接口"),
        pointer_default(unique)
]
interface IPsychics : IUnknown
{
        Sound laugh();
        Sound cry();
        Sound angry();
};

[
        object,
        uuid(5F144D5C-A20C-42e7-8F91-4D5CAE430B29),
        nonextensible,
        helpstring("IDynamics 接口"),
        pointer_default(unique)
]
interface IDynamics : IUnknown
{
        Speed run() = 0;
        Speed walk() = 0;
        Interval jump() = 0;
};

[
        uuid(6CC7B329-B92F-4A8F-9CDD-1AB6D7E4CF4D),
        version(1.0),
        helpstring("OLEOBJECT 1.0 类型库")
]
library OLEOBJECTLib
{
        importlib("stdole2.tlb");
        [
            uuid(62FD0E39-DA84-4B19-BAB0-960A27AC2B71),
            helpstring("OlePaint Class")
        ]
        coclass OlePaint
        {
            [default] interface IPhysiology,
            interface IPsychics,
            interface IDynamics
        };
}

 

请伃细，观察上面的描述IDL代码和图形。并不是太难吧。

4) COM对象的接口原则

为了规范COM的接口机制，微软向COM开发者发布了COM对象的接口原则。

(1)IUnknown接口的等价性

当我们要等到两个接口指针，我如何判断它们从属于一个对象呢。COM接口原则规定，同一个对象的Queryinterface的IID_IUnknown查询出来的IUnknown指针值应当相等。也就是说，每个对象的IUnknown指是唯一的。我们可以通过判断IUnknown指针是否相等来判断它们是否指向同一个对象。

IUnknown *pUnknown1 = NULL, *pUnknown2 = NULL;
pObjectA->QueryInterface(IID_IUnknown,(void **) &pUnknown1);
pObjectB->QueryInterface(IID_IUnknown,(void **) &pUnknown2);
if (pUnknown1 == pUnknown2)
{
        cout << “I am sure ObjectA is ObjectB.”;
}
else
{
        cout << “I am sure ObjectA is not ObjectB.”;
}

当然，如果查询的不是IUnknown接口，则无此限制。同一对象对非IUnknown接口的查询值可以不同。

(2)接口自反性，对一个接口来说，查询它本身应该是允许的。

设pPsychics是已赋值IPsychics的接口。

那么pPsychics->QueryInterface(IID_IPsychics,(void **) &XXX);应当成功。

(3)接口对称性，当我们从一个接口查询到另一个接口时，那么我们再从结果接口还可以查询到原来的接口。

例如:

IPsychics *pSrcPsychics = …something, *pTarget = NULL;
IDynamics *pDynamics = NULL

如果pSrcPsychics->QueryInterface(IID_IDynamics,(void **) &pDynamics);成功的话。

那么pDynamics->QueryInterface(IID_IPsychics,(void **) &pTarget);也相当成功。

(4)接口传递性。如果我们从第一个接口查询到了第二个接口，又从第二个接口查询到了第三接口。则我们应该能够从第三个接口查询到第一个接口。其它依此类推。

(5)接口查询时间无关性。当我们在某时查询到一个接口，那么在任意时刻也应该查询到这个接口。

嗯，COM的基本知识好像这么多了。好像片篇太长呵。那么COM实现方法留到下一篇吧。

(待续...)