COM应用软件开发技术

韩冰

蔡倩

- B$ K) g8 U9 ~. W B$ s I' P

主题词： COM ActiveX C++ Builder

1.COM技术概述

COM表示Component Object Model(组件对象模型)，它是Microsoft大力推广的软件开发技术。采用COM规范开发的应用软件具有强大的功能，主要有如下几点：

9 z4 t& h( [! T" Z& L" U' N, {

◆COM是二进制编程规范，可以编写被多种语言使用的代码。

◆用于创建ActiveX控件。

7 y" j$ ]) p* ~( X5 [

◆通过OLE Automation 控制其它的程序。

◆与其它机器上的对象或程序进行对话，构成分布式应用程序。

/ K6 U+ V" H, e% E, J

Microsoft推出Windows 98和Windows NT 5.0后，整个操作系统的核心都围绕着COM来建立。我们可以把Windows系统看作是一系列的COM接口，在需要是可以调用这些接口。如DirectX就是一系列的COM接口服务程序，通过它可以进行高性能的Windows图形程序设计。

% Z- `" W' G" A5 p! x* x) Z0 Q* n

用COM技术开发的应用程序从理论上说是客户/服务器模式的程序。程序员可以使用一系列的COM服务程序来构造他们自己的应用程序，这些服务程序可以根据需要随时嵌入到主程序中。在分布式系统中，可以通过网络来访问这些服务程序。将来，操作系统和整个网络可能会被看作是一套以COM对象形式提供的服务集。一部分程序员负责建立这些服务，而另一部分程序员只负责如何调用它们。其目的是实现软件的即插即用。

开发COM应用程序是比较复杂的，通常需采用ActiveX模板库（ATL）来编程。在这里我们推荐采用C++ Builder来开发COM程序，Inprise（Borland）公司的面向对象技术一直处于世界领先水平，C++ Builder采用可视化方法，隐藏了ATL的实现细节，自动生成COM接口所需的代码。

! B2 ~' c' E* z2 C

以下的程序举例采用C++ Builder 4.0 编制,在中文Windows98环境下运行。

2.建立COM服务程序

% p. q( m' n6 M( J1 V

COM服务程序有三种形式，第一种是驻留在本地机器上以DLL形式提供，该服务程序被调用时，嵌入到调用程序的线程中运行；第二种是驻留在本地机器上以EXE形式提供，该服务程序被调用时将占用独立的线程运行；第三种驻留在远端机器上以EXE形式提供，服务程序通过网络被调用，它在远端机器上运行，结果通过网络返回调用者。

1 }& l4 ]8 _0 P

在此采用第一种形式建立COM服务程序，这也是最常用的形式，DirectX就是采用这种形式提供的。

0 q: K( P% R; G

C++ Builder建立COM服务程序的方法如下：

2.1创建支持COM接口对象的动态连接库文件：

- D# p2 b$ I; e- F6 j2 }

◆打开File/New/ActiveX项目页，选择ActiveX Library；

1 [0 ~7 Y9 ?9 X" E1 V

◆选择Save All 将项目以PCOMServer文件名保存；此时C++ Builder 自动生成如下的文件：

+ ?# ^4 r: s) r" L

PCOMServer.bpr：工程的项目文件；

PCOMServer.h,PCOMServer.cpp：支持COM对象的动态连接库源文件，其中有许多函数用于COM接口对象的自动装配，大家不用去编辑它们；

t5 f% g3 b9 ~7 H+ W, E1 R! V# _+ m. m# G

PCOMServer_ATL.h,PCOMServer_ATL.cpp：ATL形式的文件供C++ Builder编译器调用，大家也不要去编辑它们。

◆打开Project/Options/Linker 属性页不选中Use dynamic RTL选项，打开Project/Options/Packages属性页不选中Builder with runtime packages选项，这两步操作可以使开发的COM动态连接库不依赖C++ Builder的VCL动态连接库，有利于独立发行，但在一般情况下还是建议选中这两项。

8 P, ^# B' |3 Z9 N d+ ]

2.2建立COM接口对象

打开File/New/ActiveX属性页,选择Automation Object表示向服务程序中插入一个自动类型的COM对象，我们选择这种类型的COM对象是为了可以自动注册，并且自动支持可以被其他语言调用。此时出现如下的对话框，输入COM类的名字MyCOM即可，对话框中的其它选项用于规定COM对象的性质，可查看帮助信息。

2.3通过类型库编辑器编辑COM对象中相应接口对象的属性和方法

# _ N$ t5 n8 U. w. S

此时自动进入类型库编辑器，类型库用于存储COM对象的说明，是一个可以被多种语言调用的头文件包。在类型库中，可以定义COM对象的接口，定义接口对象的属性和方法等。类型库编辑器如下所示：

可以看出此时自动产生了MyCOM类的一个接口类IMyCOM，在COM应用软件中我们实际上是与接口对象打交道，下面通过类型库编辑器为IMyCOM接口定义方法和属性。

◆单击编辑器顶部的Method按钮；

9 ^8 G+ v- e; x1 y8 _ k

◆在Arributes页面的Name字段中输入方法的名称，本例中是AddInt用于整数加法；

◆在Parameters页面中，单击Add按钮编辑方法中的参数；

x和y是输入的两个整数，ret用于返回运算的结果，必须定义为指针型

◆切换到Flags页面，可以对接口的属性作调整；

4 ]9 }! s6 Y5 }

◆在Text页面中可以检查生成的IDL代码：

; X* B% `; ^! j1 b/ b/ v4 e

[id(0x00000001)]

HRESULT _stdcall AddInt([in] int x, [in] int y, [out, retval] int * ret );

+ D) u& V4 r( L1 t3 h

◆单击Refresh按钮，此时可以关闭类型库编辑器。当需要为接口添加新的属性和方法时，可以通过View/Type Library重新打开编辑器。选择Save All用C++ Builder提供的缺省文件名保存类型库的相关文件如下：

+ I3 x1 g) i4 |5 D1 a$ g! I, n5 V

PCOMServer.TLB: 类型库文件；

PCOMServer_TLB.cpp:包含COM接口和对象的说明，其主要目的是方便访问，在客户程序中需将本文件包含到客户程序的工程中；

, Q+ G! {4 I( z+ S' `2 | O( v2 V

PCOMServer_TLB.h: PCOMServer_TLB.cpp的头文件，通过#include引入到客户程序中。

MyCOMImpl.cpp: 该文件是我们需要编写程序代码的地方，实现类型库定义的接口对象的方法和属性；

8 @ y) J2 A$ @ H

MyCOMImpl.h: MyCOMImpl.cpp的头文件。

) Y E$ d# O& a' w+ X0 {

2.4 实现COM接口中的方法

# u X, j& n, R& k( U* b% [

打开MyCOMImpl.cpp文件会发现我们在类型库编辑器中定义的方法，为该方法编写代码如下：

4 ~) h8 |( a7 x

STDMETHODIMP TMyCOMImpl::AddInt(int x, int y, int* ret)

{

' U1 r1 X1 s* `3 u8 `5 {+ \( S

*ret=x+y;

return S_OK;

}

2.5 生成DLL文件并注册COM对象

0 S( w6 h/ y7 w) f0 x5 c4 D: `7 O

◆选择Project/Builder PCOMServer 生成PCOMServer.DLL文件。

' ?! X2 ]' A4 Z; s# d/ C3 O% S$ d3 r" J

◆打开类型库编辑器，单击Register按钮完成对COM对象的注册。

通过Windows任务栏中的Run菜单运行REGEDIT程序，在Windows注册表的HKEY_CLASSES_ROOT键下查找到PCOMServer.MyCOM子键,PCOMServer为DLL文件的名字,MyCOM为COM对象的名字,在下面可以看到该COM对象的全局唯一描述符CLSID如下:

{59834F03-49F1-11D3-B85B-00E09804A418}

注意:不同的机器生成的描述符不同.

- z& B0 s! e) l2 m

在HKEY_CLASSES_ROOT键下查找到CLSID子键，在它下面找{59834F03-49F1-11D3-B85B-00E09804A418}子键，下面有如下的条目：

. ]6 o8 o3 }& Z. i! _

InprocServer32：存储PCOMServer.DLL的路径目录；

9 o8 h$ \6 {$ \- N: n. B

ProgID：存储COM对象的注册名：PCOMServer.MyCOM；

. U8 P! N! K% _. @0 M! J, g e6 m

Typelib：存储COM对象的CLSID值{59834F03-49F1-11D3-B85B-00E09804A418}。

- N" T @9 `( B- | {6 n

COM对象就是通过在注册表中的纪录实现DLL与客户程序的自动连接。

" R& |) X. {! T8 @' B% E2 r2 H

3.建立COM客户程序

" v( x1 L8 E3 A+ p- @6 N: a

客户程序将访问PCOMServer.DLL服务程序中的MyCOM对象，这些对象的说明保存在前面所述的TLB文件中。我们可以直接将PCOMServer_TLB.cpp加入到客户程序的项目文件中，并在客户程序中引用PCOMServer_TLB.h文件；也可以通过Project/Import Type Library引用PCOMServer_TLB.TLB文件，重新生成.cpp和.h文件,自动完成上述过程。

客户程序的编程重点是实现对服务程序中COM对象的方法的调用，调用的方法有多种，都是通过所谓的代理接口来完成的，这些代理接口在PCOMServer_TLB.h中有详细的定义，从这些定义中可以看出这些代理接口调用对象方法的过程。

6 j0 I8 P7 J, e* o

PCOMServer_TLB.h文件很重要，包含了调用MyCOM对象的各种接口信息，该文件主要内容如下：

3 W5 t* _2 ]8 u1 t' V9 O) G3 V/ U: o4 z

// Type Lib: D:\CAI\com\PCOMServer.tlb

4 Q) r5 Y4 h0 W$ F5 d+ w9 y

// IID\LCID: {5BD378E5-4B57-11D3-B85B-00E09804A418}\0

) A: Y7 O, o' s; [' V# J8 E

// Helpfile:

// DepndLst:

// (1) v2.0 stdole, (C:\WINDOWS\SYSTEM\STDOLE2.TLB)

// (2) v4.0 StdVCL, (C:\WINDOWS\SYSTEM\STDVCL40.DLL)

// ************************************************************************

* \- Z; q8 E( g* I# j

#ifndef __PCOMServer_TLB_h__

9 o! W2 B" x) C/ [! G0 ~

#define __PCOMServer_TLB_h__

#pragma option push -b -w-inl

#include <vcl/utilcls.h>

#if !defined(__UTILCLS_H_VERSION) || (__UTILCLS_H_VERSION < 0x0101)

8 V, B1 F; ^# _* L. l

#error "This file requires an newer version of the header file UTILCLS.H"

* s' t# S# _ Y; b1 Y1 _

#endif

* }# U! \3 L5 ?8 P

#include <olectl.h>

#include <ocidl.h>

#if defined(USING_ATLVCL) || defined(USING_ATL)

( W" C; b2 Y, {8 ^9 r, t

#if !defined(__TLB_NO_EVENT_WRAPPERS)

#include <atl/atlmod.h>

6 b! V4 s, i z7 e# |# `

#endif

#endif

- k# M$ y" q) K# E, Q

1 g1 ]7 R0 n0 f# W6 \. c- I i! \8 F

namespace Stdvcl {class IStrings; class IStringsDisp;}

6 d3 i7 j8 d2 z* |' i: |

using namespace Stdvcl;

namespace Pcomserver_tlb

{

& ]1 X5 F5 {5 Q

DEFINE_GUID(LIBID_PCOMServer, 0x5BD378E5, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18);

, }( U/ ^: C# y; ]. P% M8 M

DEFINE_GUID(IID_IMyCOM, 0x5BD378E6, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18);

7 B6 J9 I5 _1 Z

DEFINE_GUID(CLSID_MyCOM, 0x5BD378E8, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18);

interface DECLSPEC_UUID("{5BD378E6-4B57-11D3-B85B-00E09804A418}") IMyCOM;

/ s7 \' J0 u0 F+ x! @

typedef IMyCOM MyCOM;

1 x. T! g8 D$ E F

#define LIBID_OF_MyCOM (&LIBID_PCOMServer)

interface IMyCOM : public IDispatch

{

: H) D$ R6 R6 G! P# P* K [

public:

( i% u9 g. O7 M3 u9 R, `. ?1 u8 u4 d

virtual HRESULT STDMETHODCALLTYPE AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/) = 0; // [1]

" U# |3 |5 U$ _6 G

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

' z* {4 C- J! ]

int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/)

{

int ret;

OLECHECK(this->AddInt(x, y, &ret));

return ret;

- G9 S# f4 P; }( ]& g, z

}

3 x+ ^9 H1 [1 n* g/ ^3 ?1 I

#endif // __TLB_NO_INTERFACE_WRAPPERS

8 V0 R$ d+ J, _/ x4 v% R3 `

};

8 K1 s7 H" N7 I3 B) G

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

template <class T /* IMyCOM */ >

9 z( z' D9 T' {9 n; [

class TCOMIMyCOMT : public TComInterface<IMyCOM>, public TComInterfaceBase<IUnknown>

2 W9 v9 W2 _5 g0 H" u

{

public:

7 k+ L3 ], x9 x5 U1 b

TCOMIMyCOMT() {}

: }" K; @, _. T

TCOMIMyCOMT(IMyCOM *intf, bool addRef = false) : TComInterface<IMyCOM>(intf, addRef) {}

5 J( P9 v0 E, m3 O) u

TCOMIMyCOMT(const TCOMIMyCOMT& src) : TComInterface<IMyCOM>(src) {}

# w+ K2 ~: f6 L+ c8 d% B8 Z

TCOMIMyCOMT& operator=(const TCOMIMyCOMT& src) { Bind(src, true); return *this;}

5 C9 x/ [& ?4 A7 X; l* G& A9 L

HRESULT __fastcall AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/);

int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/);

};

& t. x1 B& D; {4 X7 G. D, Y

typedef TCOMIMyCOMT<IMyCOM> TCOMIMyCOM;

2 J2 ~: S. ~4 V: ?6 P6 d' O

template<class T>

5 P: i6 F( Y# n2 D- |$ B0 b

class IMyCOMDispT : public TAutoDriver<IMyCOM>

{

; h* H, j: U8 a, h

public:

IMyCOMDispT(){}

8 w! z! b4 ^3 [3 ]7 N4 ^% x

IMyCOMDispT(IMyCOM *pintf)

) V) v `- i2 l0 m/ b1 V

{

1 U; G2 d0 C5 P7 G( y6 U$ @

TAutoDriver<IMyCOM>::Bind(pintf);

}

IMyCOMDispT& operator=(IMyCOM *pintf)

& l9 m, a9 F, \3 D! s H

{

TAutoDriver<IMyCOM>::Bind(pintf);

! L; ]% H0 E. S2 f9 F

return *this;

}

HRESULT BindDefault(/*Binds to new instance of CoClass MyCOM*/)

{

) q4 b- l- d" z& i

return OLECHECK(Bind(CLSID_MyCOM));

}

; g9 R, {' N/ D3 d- S0 e

HRESULT BindRunning(/*Binds to a running instance of CoClass MyCOM*/)

, d! z* e+ U. _0 f

{

return BindToActive(CLSID_MyCOM);

0 R& i% R) q i) w" p) h

}

1 H+ Y2 p8 w Q- o

HRESULT __fastcall AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/);

int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/);

};

8 o" b) S# v! e* C5 q/ |( J

typedef IMyCOMDispT<IMyCOM> IMyCOMDisp;

template <class T> HRESULT __fastcall

" g) H. w- ]" F

TCOMIMyCOMT<T>::AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/)

7 J7 Q% j& Q4 J5 ~: m m

{

" v2 e* i8 Z. `3 n1 p4 J

return (*this)->AddInt(x, y, ret);

- D- Q7 }2 i# W

}

template <class T> int __fastcall

TCOMIMyCOMT<T>::AddInt(int x/*[in]*/, int y/*[in]*/)

{

int ret;

OLECHECK(this->AddInt(x, y, &ret));

% ]3 @5 R4 z" j' R7 Z' R

return ret;

( w o6 O J! `6 u

}

& k! t1 h i: N1 L. d

template <class T> HRESULT __fastcall

. f% I2 G& K9 e/ M$ r

IMyCOMDispT<T>::AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/)

- T- l/ `! _9 ]4 p' m7 ?

{

static _TDispID _dispid(*this, OLETEXT("AddInt"), DISPID(1));

TAutoArgs<2> _args;

_args[1] = x /*[VT_INT:0]*/;

_args[2] = y /*[VT_INT:0]*/;

: K1 j9 Q8 W; {6 {4 F

return OutRetValSetterPtr(ret /*[VT_INT:1]*/, _args, OleFunction(_dispid, _args));

}

$ l! {" E8 t$ D; H

template <class T> int __fastcall

7 ^+ x5 X6 S! Y/ r9 P+ W/ b

IMyCOMDispT<T>::AddInt(int x/*[in]*/, int y/*[in]*/)

{

. }" k6 ?) {" Z$ U

int ret;

$ M; i2 P. I% H1 c- Y$ ^% V

this->AddInt(x, y, &ret);

return ret;

}

7 G/ m( a5 ]& K& Y& {, f2 \. n5 P1 j

typedef TCoClassCreatorT<TCOMIMyCOM, IMyCOM, &CLSID_MyCOM, &IID_IMyCOM> CoMyCOM;

#endif // __TLB_NO_INTERFACE_WRAPPERS

6 q6 e% ~# h s8 _3 N! S( R

}; // namespace Pcomserver_tlb

#if !defined(NO_IMPLICIT_NAMESPACE_USE)

4 G/ K' r' i) p7 G" B

using namespace Pcomserver_tlb;

: K; a% t1 O( s* L) t9 K

#endif

#pragma option pop

#endif // __PCOMServer_TLB_h__

下面是文件中说明的主要对象及其定义：

+ t" J0 ? O- d& z* s

interface IMyCOM : public IDispatch

: C: T4 x- o- }$ }* t( V7 @

class TCOMIMyCOMT : public TComInterface<IMyCOM>

class IMyCOMDispT : public TAutoDriver<IMyCOM>

: D' V( P8 F n" `

class CoMyCOM： public CoClassCreator

9 q, v+ h6 F0 q! K/ f% s

◆IMyCOM：通过IDispatch接口来调用对象的方法，该接口可以使对象被不支持虚拟函数表(VTable)的语言(如Visual Basic)说调用。这是一种很慢很苯的接口调用方式。

◆TCOMIMyCOMT：通过所谓的智能接口来调用对象的方法，既可以实现IDispatch调用，也可以采用VTable进行调用，从而实现最快的调用速度。

◆IMyCOMDispT：通过disp接口来调用对象的方法，可以提高Idispatch接口的访问速度，但还是比不上VTable接口。

# s6 X4 Z3 y' R; ?" k

◆CoMyCOM：通过使用CoClassCreator可以自动产生TCOMIMyCOM代理的实例。

7 W2 Z: z% f& ?7 I+ C

下面介绍一下实现智能接口和Disp接口调用的客户程序。这个客户程序很简单，有两个按钮分别完成两种接口调用的方法，一个编辑框显示结果。

. Y, N, d7 @8 }, ?3 v) A

◆智能接口的VTable调用方法如下：

int x=6,y=6;

TCOMIMyCOM O;

$ b5 j j6 f1 ?0 C5 L6 o% [

O=CoMyCOM::Create(); //通过CoClassCreator完成初始化

- a7 ?, T1 o9 B& l U, z( ^% M5 M; t

O->AddInt(x,y,&y); //Vtable形式调用

! j/ p% c) W7 ]! M$ }; j' S6 t2 `

Edit1->Text=IntToStr(y);

1 P2 k1 w8 M6 X z( H; s

◆DISP接口的调用方法如下：

& V- Y# p6 B4 b+ E- `+ [8 R. }" H

int x=6,y=6;

IMyCOMDisp app;

8 a6 ~& m1 j: f& [

app.BindDefault(); //通过Bind完成初始化

app.AddInt(x,y,&y); //Disp形式调用

Edit1->Text=IntToStr(y);

4.小结

! B- p$ [* C, T5 Q

上面的程序举例是很简单的，但却详细说明了COM应用软件的开发过程。COM技术不是一个编程语言，而是一种编程规范和方法。采用COM技术可以开发功能强大的软件，有利于分布式应用技术的实现，有利于多人合作开发，也可以帮助我们理解Windows系统本身。COM的接口技术是比较复杂的，想进一步了解COM技术可参阅清华大学出版社的《COM技术内幕》一书。

C++ Builder是开发COM应用软件的好工具，它隐含了COM实现的细节，我们只需与它打交道就可以开发完善和强大的COM应用程序。希望有更多的人转到COM应用软件的开发上来，COM技术是软件技术未来的发展方向，是实现软件工程中软件即插即用的有效途径。

. y" Y% |( K$ {) w) B2 j

/ s4 Z; M+ c! W1 O+ n