COM应用软件开发技术

韩冰

蔡倩

主题词： COM ActiveX C++ Builder

+ |& R: T3 l4 r5 ?

1.COM技术概述

6 t: n9 X& q+ p4 F# j( U0 s5 P' S

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

' s* G. M7 l7 j2 @3 V

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

◆用于创建ActiveX控件。

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

: X7 G7 i* `2 }# V5 \, C

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

& a [0 p9 ]% }# n$ {

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

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

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

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

2.建立COM服务程序

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

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

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

6 M% u* c+ a& y: ^6 y/ h

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

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

/ m/ F) z# M6 b3 R2 i( ~% r+ P

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

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

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

% `: S L: F' }0 m: a3 ]" a3 P) \0 p

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

: K" `& ?5 g0 |6 C0 y" u

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

) b6 t z) R u( Z5 a& z

2.2建立COM接口对象

$ J7 N# ^8 [7 V3 ^+ b

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

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

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

" k. J+ K8 t! n) ^4 @$ X# x [

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

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

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

/ |/ g% e. R4 i# \

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

9 @8 E! v: j. O

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

' H3 W8 M0 L2 s' d) o

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

5 L% O8 Z4 }" l- w, ~6 E# n* W

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

5 c+ \0 ]4 R5 z6 X

[id(0x00000001)]

) S' |* ~- ]7 B

A' c. e- z" G5 P$ r

8 I3 H, `3 ], z7 b

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

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

- j% O: T: u9 e7 X; x

PCOMServer.TLB: 类型库文件；

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

$ r$ d6 q: n* b

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

5 O& H6 e% M" B! Z0 ]+ C6 n

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

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

2.4 实现COM接口中的方法

" v5 v/ B8 b. M) C; ` T

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

. S7 J9 l( T5 E' l# X$ O ~

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

( e% y% B5 G* ~0 k) k

{

" O4 h1 e3 k- L9 x/ ~8 M

*ret=x+y;

return S_OK;

* U. x% u) z" N# h8 h6 h" m

}

0 I+ d% [1 U, t7 I) [

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

' Z# k5 N7 E0 W# X& s. _1 P3 k

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

8 W7 a& v7 o& g. ^! \1 J

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

# \/ i' u% P" ~6 n

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

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

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

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

- ]) Y7 W' t# n; \! N5 Y( I1 v

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

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

+ c) y4 X2 Z) `( g9 i/ i& C, T

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

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

3.建立COM客户程序

% O% |* G% m4 s: l$ @

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

; I* c' Y' Q" I6 V! K* C+ y% {

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

% a! ^# H, B3 M4 ^( T

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

- m% W8 U8 ]8 p4 ?2 p8 s8 h

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

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

2 {3 b: Q" C2 b) r

// Helpfile:

% X/ P& z: F" p% \- j

// DepndLst:

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

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

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

6 I+ r9 p3 u6 G

#ifndef __PCOMServer_TLB_h__

#define __PCOMServer_TLB_h__

0 l0 {3 @$ W& D

#pragma option push -b -w-inl

#include <vcl/utilcls.h>

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

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

a; Q, N; H4 L: i- C5 P& G

#endif

# ]: N" ~9 G% L4 c. W/ ^! [& N

#include <olectl.h>

#include <ocidl.h>

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

* P U; W" @7 [( J' x5 D# I- |

#if !defined(__TLB_NO_EVENT_WRAPPERS)

4 B* r. ?7 L8 t1 ^# X

#include <atl/atlmod.h>

#endif

#endif

7 q) D8 T1 P" P5 x

/ D: V3 _, {9 Z* U( r! N$ D

namespace Stdvcl {class IStrings; class IStringsDisp;}

using namespace Stdvcl;

0 i3 Y) @3 y6 w$ B

- \ m1 ]- _' o% e" _

namespace Pcomserver_tlb

. r* v1 @$ X3 O) J

{

) H8 B5 v2 |' s# o t( t) R) k: o- K3 ~

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

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

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

( f$ O: X5 F' Z9 E( {

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

typedef IMyCOM MyCOM;

* T" d" |" N, B, W m7 h+ Q7 l

9 ?' n% [. k* g: N

#define LIBID_OF_MyCOM (&LIBID_PCOMServer)

9 \: n3 p. n; x" a x

interface IMyCOM : public IDispatch

{

public:

3 V7 y% S# y& I( \

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

5 e: H8 g9 c7 ~6 A( ^ p- n4 w% S

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

# A! s& b1 ]8 l) l

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

{

& [6 |' z6 b6 |% G* g) z0 `8 D7 E

int ret;

8 }/ C; }2 v6 j- i* B" [2 O9 e" {

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

0 B5 [& _, k6 Z4 E H0 }) ^

return ret;

* E0 v% E% p1 n. U+ w' d% |4 z" Y

}

#endif // __TLB_NO_INTERFACE_WRAPPERS

4 r' B9 K9 H7 y

};

9 d; N" y7 a5 t/ V/ j* O0 t- Z

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

template <class T /* IMyCOM */ >

* j; _" s) F4 S3 ]2 v2 }7 ^ ^/ N

e& h6 S* `" {& W1 J( R

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

+ _2 x( }% r) ]4 M b

{

public:

TCOMIMyCOMT() {}

3 \; w- p2 N% v( r7 m; _6 L

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

! {# W Z# N4 b; U. ~

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

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

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

7 y. ]+ L$ b6 g

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

: k1 ?( o F" N3 S) p% @

};

typedef TCOMIMyCOMT<IMyCOM> TCOMIMyCOM;

template<class T>

class IMyCOMDispT : public TAutoDriver<IMyCOM>

{

9 O' J8 S& }: Y' {4 h

public:

IMyCOMDispT(){}

IMyCOMDispT(IMyCOM *pintf)

{

TAutoDriver<IMyCOM>::Bind(pintf);

}

. [; F: R$ }3 Y y0 Y

IMyCOMDispT& operator=(IMyCOM *pintf)

{

% v( X( f+ p4 ?/ S9 J( k

TAutoDriver<IMyCOM>::Bind(pintf);

4 N$ h, b: W6 L: _& O

return *this;

8 C7 A/ }7 r1 l2 ` A" U4 a6 B1 u

}

' i! q- e1 F. |/ @

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

, S, ?6 u- U H

{

return OLECHECK(Bind(CLSID_MyCOM));

}

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

{

0 z' `/ ]; T9 c( i

return BindToActive(CLSID_MyCOM);

}

: h% {0 e2 e* s+ X' T( b' K

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

4 K9 A- o. a% Z2 H8 }* B; K3 n

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

};

typedef IMyCOMDispT<IMyCOM> IMyCOMDisp;

9 r: R, Q8 o' v. J

template <class T> HRESULT __fastcall

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

{

) Y$ ^* |) i) t. G

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

; Y0 w) ]- @4 T1 m" C

}

6 R% e& ?3 O$ p) T5 P6 M

template <class T> int __fastcall

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

{

7 X" a: O$ F6 k) o

int ret;

- C Z' P6 g" F7 f1 {/ t

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

$ i: L; l& O8 Q7 B* L: O" o

return ret;

, `; B" M1 {0 b8 T% j- f. _' ]

}

( @' X5 S" D! u$ |+ m- |

2 Z( f% q. {; }2 J

template <class T> HRESULT __fastcall

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

% U4 B& k7 |5 B3 u5 y

{

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

P& W+ h( F/ s) _

TAutoArgs<2> _args;

r" b& \/ _: I8 l. u2 `) N

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

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

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

1 X! b) P0 V5 }

}

* H, J* L+ ~1 \2 S6 b$ |% L; I

template <class T> int __fastcall

* r; f/ M7 x B1 C

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

* z! x* v3 _6 c8 \. s3 u

{

int ret;

1 s/ F/ G1 Z- e5 T$ s- I. B8 b

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

6 J @$ U( }1 z) w5 A o9 Q% n

return ret;

$ ?$ `6 }$ o' R6 n6 _+ X% Y2 [ ]

}

$ Q: p5 F9 M) Y; b! @" B

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

9 e- I. r* W5 f/ u

#endif // __TLB_NO_INTERFACE_WRAPPERS

# Z! o/ j. J3 p

}; // namespace Pcomserver_tlb

#if !defined(NO_IMPLICIT_NAMESPACE_USE)

! A- D3 o4 u+ `" r, b' h3 v: O

using namespace Pcomserver_tlb;

#endif

5 h7 u5 j s3 Z9 F: g* Y J& u# B

#pragma option pop

* ~4 z4 I# c G% l: m

#endif // __PCOMServer_TLB_h__

( w5 A5 ]$ I+ O" G

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

interface IMyCOM : public IDispatch

class TCOMIMyCOMT : public TComInterface<IMyCOM>

class IMyCOMDispT : public TAutoDriver<IMyCOM>

; [5 M% W- Q7 N8 I

class CoMyCOM： public CoClassCreator

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

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

8 a# e1 H' q6 ^' v: I l

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

/ l% d. B, z5 d( T6 G5 m3 {

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

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

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

int x=6,y=6;

TCOMIMyCOM O;

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

6 `1 E, H- \, f; ?

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

9 Y/ Y2 c" J4 Z. h* w" U

Edit1->Text=IntToStr(y);

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

! o: h& R1 X8 A9 K6 V4 u7 q J" H9 {

int x=6,y=6;

IMyCOMDisp app;

3 p5 J8 K- k8 P6 o

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

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

# h3 H/ m6 \; O& o$ A4 z+ f

Edit1->Text=IntToStr(y);

4.小结

( V# y3 I! O; W$ V# J

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

; O/ n o& r, e: e9 H% l

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

9 x: B* v4 Y: v: S