数学建模社区-数学中国

标题: 构件对象模型概览 [打印本页]
作者: 韩冰    时间: 2005-1-26 01:16
标题: 构件对象模型概览

( P A- q+ |( ]9 e. v# q

傅贵

* K9 [2 a1 F5 e

: B }. n& u) u" Q

　构件技术的产生背景

/ x( k6 ]# q3 [- Q

计算机软硬件技术特别是网络技术的飞速发展使得人们可以建造功能更强大、结

. K3 s5 A& Y2 W4 b; @7 Q" D# F

构更复杂的应用。这样的一个结果是在应用系统中硬件越来越“瘦小”，而软件

0 T$ U4 w9 r; K9 {+ T, k4 K

越来越“肥大”。

9 K j& d! g! _* e$ K' U

4 ]- j& {. z$ I1 A! N- |4 i

由于一个应用常常需要异种的计算机硬件平台及其相连的操作系统平台并且其功

6 f2 F' O5 k/ k6 \

能常常需要不断的扩展，大的应用软件常常需要有跨越多个异种平台的能力并且

7 t& M( V# V$ V" J d" c ? _

有开放的系统结构。此外，为了提高开发速度和节省开发费用，需要最大限度地

4 |/ Q( e/ ?1 r0 q+ o# [

重用以有代码。因此，当今的应用软件普遍需要有良好的平台兼容性（互操作性

' B0 i' o6 J1 ^5 R; w9 g

）、结构开放性、规模可变性（可扩展性）及代码重用能力等。

9 g, I# w8 E5 x6 N! S7 d& [: Q

8 L0 ]1 A8 j" {4 F

另一方面，在传统的系统开发技术下，庞大的软件使得开发越来越难、开发周期

8 w( m( s. K* x9 I. O

越来越长、维护费用越来越高并且功能的扩展危险而难行。应用系统严重依赖于

4 s9 n0 V& Y! I( z6 {4 B$ c

操作系统和特定的网络服务因而开放性很差。开发者为每种不同的应用环境（本

- U. J0 V) n5 c8 p; T

地应用、网络应用、不同操作平台的应用）开发不同的代码。如为解决这些问题

7 j# v' x5 _8 w0 `) r: X* z8 |

，国际上成立了许多标准化组织来对系统和处理方式加以标准化,但这只是增强

( t; Z4 y1 M6 u) M8 p- V+ S( N

软件可操作性和重用性的一种权宜之计,并不能彻底解决问题。在这种情况下，

: z% `& h/ _ S& h/ k

出现了具有互操作能力和可重用能力的构件对象设计模式和具有分散和联合处理

5 P: T# ^4 O6 `! e, \, L

能力的开放分布式处理系统。

( q9 f0 X. Y* e# ~

构件技术与构件对象模型基本概念

1 d: j: }) m- ~

; D, ~4 P% F/ U0 d$ f( ]

概述

( ]5 T' d1 E6 d) g. C: O

组合软件模型是新一代软件技术发展的标志，它的提出很自然，为了提高软件生

) a: G/ b! G# b. [+ H

产力、不草率地开发应用程序、设计开发人员应尽可能地利用可重用的软件构件

% o8 Q2 h( R' I4 ~4 r3 A! w7 y4 G, e

、组装构造新的应用软件系统。追根求源，由软件模块构件组织合成软件的思想

/ f3 C$ Q/ O) f- M) z ~

早在70年代就已提出了，函数就是一种构件，函数通过参数来适应不同应用需求

- B$ _2 K8 C( x$ s

的变化，Ada语言的模块package就是一种构件，实现了内部细节掩藏，模块通过

4 Y/ q% l' V9 ?

接口规范说明进行连接和组装，package还提供了类属机制，使模块通过类属参

/ v( O6 @8 _( d: z$ w; J6 }. K

数，适应不同应用需求的变化。但是，传统软件系统结构的局限性，以过程为中

1 F7 X. N6 L4 i7 y" V! j

心设计的功能模块，其扩充和复用的能力都较差，对模块进行应用重组的困难很

) m% L0 @: F' D+ X( M2 \

多。从80年代开始的面向对象技术的研究，使组合软件又萌发出新的生命力。面

: o: z& p2 ^% ~* n0 M7 j

向对象的软件，以数据为中心设计，对象类既具有模块的封装性和类属等特性，

% ~7 p; o3 o" N9 i; _8 f3 `

还具有继承特性，极大地提高了类的可扩充性和可再用能力。对象类较之于传统

- M, `2 o1 S" l2 C

软件的功能模块而另具有的主要优点是：

3 P( _, y2 [/ g

, `4 k6 e1 A$ Z9 {6 H

易于理解，具有完整的语义特征；

: A Z0 d; l! `: p9 Y2 T

易于重用，可方便地被使用到不同的应用中；

/ W3 \& h1 B B- @

良好的封装性和独立性，相互之间的影响小；

( @3 x. N7 K* [/ G4 g

易于扩充和修改，一个对象类的修改不影响其他的对象；

9 r7 j- l( n8 T$ r) Y2 p

易于构造组装，具有规范的外部接口。

8 l3 M5 ]& {/ q$ J. B

最早大量使用面向对象技术的是OO(面向对象)的编程语言，它具有上述前三个优

K4 ?2 R2 x6 @! X

点。但OO中的对象是源代码级的，它没有也不能统一对象间相互作用的工作机制

& S1 D/ `! ^1 Q4 X

。这意味着它不能克服以下的缺点：

7 ~* l2 E; j6 f) F; V

. k/ o- O( z V: z

在OO中只有能提供源代码的对象/类才可被重用, 即它的代码可重用性不能跨越

M3 ~/ p( G! D% V% o' t: \9 z$ G( y

编程语言的限制。因此这对实际应用环境来说是一个十分苛刻的要求,使开发人

. ?2 M& B/ C0 C3 U

员只能利用丰富的软件资源中很少的一部分，并且难以挣脱开发商的束缚。

$ a0 M- J9 c% H# |% g7 |

兼容性限制到代码级的事实意味着OOP不能解决极其重要的软件修改和升级问题

- Y/ ~, [# i0 R: a

。当一个对象被更新或替换时，即使它对外的接口没有被改变，任何使用了该对

3 x4 ?& @! Y) W" U( F' e

象的代码也都需要被重新编译，与此相关的应用程序必须被重新生成并重新发行

0 R/ p0 I% P j/ @' n' q

所有相关的地点。这不仅费时、费钱且容易导致版本交叉的混乱。

5 E! z/ \" ?* d

- M( M7 [; _% q3 V

由于对象没有标准的对外接口，不能使用组装技术来生成应用程序。

# [& y0 g1 N* S/ n! {

与OO编程语言不同,构件技术是一种更高层次的对象技术:它是独立于语言和面向

7 Q6 O5 h7 _, |. P

应用程序的, 它只规定构件的外在表现形式,而不关心其内部实现方法;它既可用

3 U/ u# G5 ^7 d- s" w

OO编程语言实现,也可用非OO的过程语言实现。只要遵循构件技术的规范, 各个

5 F8 y" i/ |; O; e& ~

软件开发商就可以用自己方便的语言去实现可被重用的构件, 应用程序的开发人

" E, M# A! d. U- r' |' c

员就有可能实现在计算机硬件领域早已实现的梦想:挑选构件、组合新的应用软

h# ?. S# s! t; y; o

件。

) | c; i5 o: H7 y* S ?

( v" M$ v: u' }- A

构件模型由构件(Component)与容器(Container)两种主要成份构成。所谓构件是

0 `; Q/ O; y$ Q: f7 R H

指具有某种些功能的独立软件单元，是一种软件“IC”，它的最重要的特性是可

: O7 e+ g' z6 q1 ]7 V' X5 y# Z

重用性。,构件的范围相当广泛,小的构件有像按钮之类的GUI元素,中等规模的有

, a4 `2 f! k- X* [8 c

如具有列表功能的小应用程序(如Applet), 而大的构件可以是浏览器这样的完整

0 h) [* i% u0 H9 r/ C+ u H

的应用系统。构件通过其接口向外界提供功能入口。接口是构件内一组功能的集

5 k8 h% C8 ~, t- {6 w# b9 q0 x R

合，它包含的是功能函数的入口，类似于C++中只有虚函数成员的纯虚类。外界

% d. [; s$ P! Y& s! `2 @) w& a2 ?

通过接口引用或接口指针来调用构件内的功能函数。容器类似于装配车间,是一

+ }9 z" o% ~1 U. b/ F3 R, R: A7 B

种存放相关构件的"器皿",用于安排构件、实现构件间的交互,其形式也是多种多

, d3 Z% ^- }9 j1 ]+ W5 U

样的,如表格(Form)、页面(Page)、框架(Frame)、外壳(Shell)等。另外,容器也

4 D$ m& Z) h9 T7 {8 `; Q

可以作为另一个容器的构件。

! p5 J( N, R1 Q! _: M1 E8 ^8 t

: [4 u# ]) V; U1 r0 {5 N7 {

推动构件技术发展的最大动力之一是软件重用。软件重用就是利用已有的软件成

. Y6 C& p* T; f/ b4 a7 m, l$ }

分来构造新的软件,它可以减少软件开发所需的费用和时间,且有利用提高软件的

* k8 b! ? O$ s" ~& K1 @6 O$ K

可维护性和可靠性。构件软件是目前发展最快的软件重用方式。构件软件解决两

, b" U* k6 Y+ n: b5 o2 x) q

个重要问题: 一是重用,即构件具有通用的特性,所提供的功能能为多种系统使用

/ q! @; e$ W+ F3 X% x$ L

; 二是互操作,即不同来源的构件能相互协调、通信,共同完成更复杂的功能。

9 | v3 b: [6 U, @9 ~& `

; D- B2 L; }0 G j

/ N" Q/ @& b1 V9 L

构件软件技术是一种社会化的软件开发方法, 它使得开发者可将由不同语言、不

. U, w4 p' _) ~9 s) O! A" |" Q

同供应商开发的构件组合在一起来构造软件。构件软件和Internet一起被列为目

3 W% P# ?" N$ c3 R4 A1 x0 S. ^) E: Y9 \

前软件产业两个最重要的增长点, 受到了业界的高度重视。许多大公司都先后开

' _6 n [* K$ S) {( P% A; D: ]

发出了已被广泛使用的构件，如Microsoft的VBX、OCX及ActiveX控件，Borland

6 N6 L ^6 D* q* u. k* L/ M- X

公司的Delphi中数据访问构件等。软件构件的迅速发展使得基本构件装配应用开

8 W; L' y7 h. y: F, l

发模型成为一种深入到软业界的新的应用开发模式与开发环境。

+ T. X, z' f" Z5 H% e- P9 k

' @; A I8 o) l5 x

对象和接口

6 b! z5 s1 ?9 x8 ^9 @$ z8 K

在构件对象模型中，对象是一种功能单元，是一种构件。它既可指对象类又可指

$ N$ L8 l3 i( g2 C1 k& {& M

对象类的实例。但此处的对象类与OOP中的对象类又有很大的不同：它有自己唯

# G/ o1 X8 M$ R4 p) n6 Z( q

一的标识号（如COM/DCOM中的CLSID）。对象常常以独立的DLL或EXE的形式存在

# m6 y/ x- g1 G: K5 _$ B3 j$ \8 b

，对象之间只能通过标准的接口调用来相互作用。

5 L" z: b5 N) e3 ?

# I! ^/ A" t( x

接口是对象中功能相关的一组函数的入口，它类似于C++中只有纯虚成员函数的

. p. {! _0 r& w( M7 D

抽象基类，它的指针或引用指向一接口函数表，该函数表包含着接口的功能函数

- \; f% Z3 n0 V7 r2 N

的入口。如下图所示：

, `( Y+ e! y+ l6 S( M- s* A# z

! O8 G _) d* m' q5 |% Y$ d! J2 {4 ?

$ ^3 Y6 N4 |3 P# z) S

# S) D0 t6 C$ d% m7 V7 F

接口为构件对象模型提供对象间互操作能力。接口的定义也是面向对象或基于对

& z F6 D* e9 G& W' W& c

象的，它具有继承能力、封装性及多态性等OO特性。

" T, R# ^& p, {: J

" {2 f7 ` o5 }* g

对象和接口都有自己唯一的标识。系统通过这两个标识来寻找、识别不同的对象

& K: u' a% E7 I2 W4 [7 j8 ~

及其接口。对象表示必须在系统中进行登记。接口调用由调用者在调用时显式地

0 s, L9 O7 u1 `6 e4 H5 b! N. F* D& D' d9 V

给出，而对象标识则在程序中常常有一个名字映射，调用者在调用对象的接口时

5 d5 K5 h) K7 M5 ?& j, J

给出该对象的名字，系统根据对象登记表索引找到该对象。

, W1 q+ s( o. s6 J+ R1 D

- M3 Z% y h) V; \+ b

接口定义语言（IDL）

! n2 ^" T% f" w3 W' ?# r1 ?% Y

8 b, y* q9 _" Y

接口通常都具有自己的定义语言（Interface Definition Language，简称IDL）

# g! ^- s5 U' Z# q! l$ U$ p

。接口定义语言只是为了接口设计的方便而采用的，它可使设计者容易读懂彼此

/ t; M5 G+ E! R* `$ z: g. n

的接口设计。IDL编辑器编译IDL代码，生成相应编程语言的头文件及客户代理和

+ W: _* ]2 `; }3 B2 P5 y

服务器代理对象。对象及其接口的描述都在IDL头文件中描述。

5 U( @. ^, X9 Y+ |' l/ T# u0 T

% z% @6 [# {& T( {! m& D

　

0 v2 z; K& I) H: H# ?/ u

/ B0 ^8 q" P4 ~0 T6 e I/ X

分布式构件对象模型

- Y: A6 @ p! A7 a

构件的分布式处理系统模型

' B3 c) ?3 Z+ x7 u2 w0 e

; f( Q! x. D0 `% ^0 d! R, ?6 A

全球性网络使线上的所有设备和软件成为全球共享的浩瀚的资源，计算机环境也

# I6 l X* m g- t9 v; y; r& @' g* {

从集中式发展到分布式环境，开放式系统的发展使用户能够透明地应用由不同厂

! A3 L$ K) M; z" W1 z' W

商制造的不同机型不同平台所组成的异构型计算资源，因此，分布式处理和应用

' e. i* h( V6 Z3 @' g* X1 k

集成自然而然地成为人们的共同要求。

7 C' ~) f. W" D% F5 r

& I: K1 D1 N m! d; h. [: d

构件对象模式下的分布式处理是指借助计算机网络将分布在不同地点的构件(即

% I) y' _0 {9 t' e: R

对象)组织在一起,进行信息处理的一种方式。分布式处理中的构件可能由不同的

6 O' q" G1 y' F

厂商开发、生产,因而构件之间可能存在不一致的接口;另外,构件之间的通信也

; f( u% w0 u6 ~* i* h( S

可能使用不同的协议,有延迟和失败的可能。国际上将这种兼容异质成分的分布

6 X: h7 h$ t, r/ C& n% E

式处理,称为开放分布式处理(ODP──Open Distributed Processing)。

; U! h7 U/ P$ y2 k& X& k

& [5 u, s+ {" Q- Z7 K1 P l

概括地讲,开放分布式处理要达到以下几个方面的透明性:

: d" J* u: r w# U. r5 ?7 A+ F

' z# |/ H. H6 n) {( E& `& [

(1)存取透明: 隐藏数据表示和调用机制的异同,使用同样的方式存取数据。

% n- [9 Y) [4 `

+ r. y2 [4 v! `$ A% }: o* z. Q% t

(2)失败透明: 将出错和恢复事件隐藏在对象内部,以达到容错的目的。

* w* s, q. m7 W0 A) m/ G+ ?6 [

% b3 u7 p5 F! W+ R* o8 }/ q/ E4 a$ a

(3)位置透明: 隐藏接口的空间位置,用户不需关心接口是哪里提供的。

# w x4 c! c5 T+ Q+ d/ L

2 ?2 G9 O8 u3 w1 ?1 h- H1 M

(4)迁移透明: 外界不需要知道系统为使资源均衡而改变对象的位置。

4 o* F; T3 u' L4 G5 |5 x6 K

' [9 E! K3 }- t8 r# n

(5)持久性透明: 对象里隐藏着所用资源的变化,如处理器资源、存贮资源的冻结

/ d! d5 `1 p/ j" o. I$ ^1 H

与解冻。

6 s" s8 C; ~, j

1 Z1 B0 R- d! Y; W

(6)重定位透明: 改变一个接口的位置不影响与之编联的其它接口。

4 u$ S$ M, ~$ J3 P6 @+ D6 O; H

( P8 S/ N7 y9 Z/ {( `3 [6 M( j

(7)复制透明: 为提高性能,能同时有多个行为相同的对象支持某一接口, 而用户

) \6 A- ?& a. S }

不需要知道有多个对象存在。

% G0 [, r9 g) E y

; K+ H2 \ R6 v* {$ _

(8)提交透明: 一组对象发生作用的次序不影响结果的一致性。

5 Y7 r& H- Q+ q" w6 @

& C2 [6 F; U0 u5 O2 i1 I+ j8 h; z

挂靠于英国剑桥的APM公司在开放分布式研究方面独执牛耳。他们的"高级网络系

) p: u& z/ h" n/ `

统结构"(Advanced Networked Systems Architecture,简称ANSA 研究项目),受

% j2 X" J, q2 b) V8 q: N6 f9 m7 t

到世界上许多重要公司与研究机构的重视和资助,奠定了开放分布式处理的基础

# m W+ h- b6 j& \4 _

。这项研究独立于各种具体的网络、硬件、操作系统和数据库,着力于设计与构

9 E) E( I1 G) o" v! F$ Q% J

造灵活的分布式应用。其产品Aware是ANSA 体系结构的一个具体实现。

6 O5 c% w8 T+ }2 a1 x

/ k5 F. X* J* \2 Y

为了使开放分布式处理能达到处理异质构件的能力和上述八个方面的透明性, 国

" p- q: K C; W$ x5 q8 ]4 n

际标准化组织(ISO)制订了开放分布式处理的参考模型RM-ODP (Reference Model

5 D$ J! o3 s5 m8 H7 F$ M

Of Open Distributed Processing)，该模型的原型是挂靠在英国剑桥的APM公

2 l0 w- b6 x1 ?& q! d

司的"高级网络系统结构"(Advanced Networked Systems Architecture, 简称

$ c6 J9 z& a( @

ANSA。) 模型分成企业模型、信息处理模型、计算模型、工程模型和技术模型五

- S: U7 m n9 W4 o

类。这五类模型都与分布式系统的设计相关, 而其中的计算模型和工程模型与分

' [$ L# a& I A8 [( B1 L; f

布式系统体系结构的关系更为直接。计算模型主要研究客户/服务器结构及其对

8 o6 R$ _5 s8 o2 z4 [3 l* |. t

象所提供和享用的服务(Service)。 工程模型主要研究系统资源的分配以及如何

* v; D$ d& P( ~ h

用工程模型对象来支持计算模型对象。技术模型被用来实现工程模型对象到计算

) j- g8 L$ J7 |0 P( m# ?

模型对象的映射, 它描述了如何利用各个本地操作系统中的进程映射和进程管理

5 z5 e. l- |! m9 C! C

来具体实现上述映射。

, F" }6 ^; p' _6 T4 W

: w5 Y9 H4 u; N/ C/ Q, ^7 t: E a- Q

1. 计算模型

7 a" ~0 S2 ~& h( @" H+ k

$ A/ g$ G' b( A; f' q

计算模型的核心内容是服务。提供服务和接受服务的双方分别为服务器和客户端

; }( k+ N0 R( L- Z! c9 T# K

, 而对象(或构件)则是服务器和客户端的组成部分。一个对象可能是一个以上服

0 G; g# ^, ]5 x/ }3 g: r( o/ o: o" w

务的提供者或使用者; 对象是经过封装、独立存在的, 一个对象可以被安装、升

% K: T( _: y/ B: F7 j) ^$ v( f! D& G1 l! s5 x

级、替换或重定位, 而与其它对象无关。

+ }; V- r: a4 k1 e- {. k

( E* W0 V% `. A

服务的提供与使用通过接口来体现, 即接口是提供服务的基本单元。

0 [) b6 P% P7 t) L5 `, q

- ~4 N0 E* m! K- A2 f

服务可分为两类, 即应用服务和体系结构服务。前者是系统所要完成的特定的任

& s4 Z8 M# u4 u5 c

务; 后者是指各种任务都要涉及到的服务, 例如, 在一个分布式系统中登记或查

1 @5 B6 \$ z7 ~+ i7 _% v$ _7 ^

询一种应用服务, 对使用权限进行控制以及其它的接口管理服务等。"交易

4 Z5 c6 s3 l* P) c

(Trading)"是最典型的体系结构服务, 它通过系统拥有的目录结构来记录服务器

8 {/ X1 o6 y) S: F5 m, a' P

对象所提供的服务; 另一方面,客户对象也通过"交易"来寻找所需的服务。提供

- a; A% X }( _# o

这种"交易"服务的对象被称为"交易器(Trader)"。

S. q, ^+ B5 h+ L/ B# p4 |0 d

; C/ j% v3 i4 B/ \

对象的通信是通过传递接口引用(Interface Reference)进行的。接口引用对应

& U( }! n8 H9 }2 a6 D" ~# M

用程序来说, 是一个网络指针, 指向提供服务的对象; 从面向对象的角度看, 接

' a$ K3 W- ~! A3 v

口引用就是接口实例的索引。接口引用可由一个程序自由地传给另一个程序,这

* L8 r3 g3 b% k3 o5 b! r" W! ~

也就把使用某种服务的能力传递给了对方。

) D4 y3 X5 f+ z* B5 S0 ?

: G1 z6 T! b. y

一个对象可以在"交易器"中登记它所提供的服务, 也可以从"交易器"中查找所需

0 {3 {, @' h! q2 [4 i

要的服务, 所有的工程模型对象都清楚"交易器"对象的位置,并可以与之连结,这

9 q& F' W2 ?) j X$ C

使得客户端与服务器的对象之间可以实现动态联编(Binding)。

% l' k+ E2 x" c+ S* d6 L

( D% `0 n2 w6 x* c6 ~& z1 g) r/ z6 z

除了登记和查询服务之外, "交易器"还提供了许多设施使管理员可以进行"交易

7 a! \) m) Q. j3 A: L

器"内部的组织。例如,"交易器"提供了撤除接口引用、释放资源和关闭"交易器

Z: |- @3 s& `* R) g! {0 [5 P

"的接口, 它可以给接口引用附加不同的空间位置属性和引用限定, 与接口引用

* x* S" k6 `+ S) Q9 a6 I! b' ?

名称一起提供给应用程序, 以便于接口的使用。"交易器"还可以优化服务, 即在

+ D* @0 H1 w* \% k( I

某个服务对象繁忙的时侯,启动包含相同服务的其它对象来满足客户端的要求。

( A9 h( l+ Z6 U5 `" Z

另外,"交易器"还可以做为其它"交易器"上服务的代理,或与其它"交易器"通过桥

& c5 J) h+ l8 O) _6 x& D$ `. \

接联合成"交易器"群,沟通各个应用领域。

& x2 K$ X. A! f# C9 ~7 L5 X& J

0 V: d \, d4 ]/ V X, r4 k

一个计算模型对象可以有多个接口, 每个接口可称为一种接口类型。不同的接口

+ u6 q0 U- F! f: I

类型提供的操作(或服务)可以相同,也可以不同。它们之间的兼容性可形成父子

- A6 D/ E# x# q( j+ a& p

关系,利用这种关系可以优化服务。是否公布某个接口, 供外界使用完全由应用

/ [6 Z) `$ S4 b) X6 k/ V

程序设计者来决定。

; n! O0 h. o B+ C

: Z; W; B. Z8 Q2 M% |8 G1 ^( W

2. 工程模型

, j) r# C+ j+ r- w1 s8 H$ t% C) x: D" q

* u8 R3 W# I0 @4 @

工程模型中的主要概念是"节点(Node)"、"核(Nucleus)"和"封壳(Capsule)"。

# N f0 F/ V1 O& o& o( K4 c9 \2 o

3 q" G7 r8 D; ~" v7 p) {. F

" h% H$ O& q6 P0 C: [

一个"节点"可以指一台计算机、一个操作系统进程或一台模拟机, 也可以是由分

) S7 q' P( A& N# U( o+ Q

布式操作系统管理的计算机网络, 在不同的场合"节点"有不同的粒度。一个"节

3 F2 f8 Y* w* J0 \: a) g% N

点"的资源由一个称为"核"的工程模型对象来管理, "核"把资源赋于工程模型对

5 Z- D5 a: T. n& I" u& e% m

象, 使工程模型对象成为一个自治的操作单元(或单独的地址空间), 我们称之为

8 C# H% @( ~& e1 r1 ?

"封壳"。因而,一个支持多进程的"节点",如Unix, 可以支持多个"封壳", 而

7 F7 V6 H) h3 O. L7 ^8 j

MS-DOS只有一个"封壳"。

# z0 j F" t* `! K# R

: ?( F* b. y! i* T0 w" \/ W

"核"带给"封壳"的能力包括:

8 P7 }( b, L7 E+ U% ^5 R

6 S2 B8 |, D9 I& j: y3 {

(1)"封壳"是一个受保护的地址空间,其操作即使失败也不会影响到其它的"封壳

% `5 v) Q8 z# C" h- z+ w

"。

4 x) `: q: J0 @' s6 \

, R. v, {" T/ z8 _$ s. Z

(2)允许在"封壳"内对并发活动进行控制。

/ Y0 _0 h4 _9 {. Z+ E8 D

1 C% f- Y) i3 U/ |1 O+ S2 I

(3)可与其它"封壳"进行通信。

4 L& E# Q" y0 P9 D( P

$ P+ h. G! b+ k7 V4 u& E

(4)保留交互中的状态。

% ^+ f* q) V) ^# t! _2 t' A9 k3 {

+ n9 ~2 `2 Y; B2 B1 z$ U# y5 K

(5)构筑其它"封壳"的能力。

1 j' X v! F+ l4 b: K0 Y& p! D4 ]- V

& f% x! P% Z1 q# n2 D1 p9 ?7 O

"核"所提供的资源包括任务(Task)、线程(Thread)、事件同步机制、套接字

6 S5 W( k8 j" h' q) n, K8 ^1 f

(Socket)、接头(Plug)、通道(Channel)、历程(Session)和接口引用等。

6 Y4 W8 K9 R8 w! _3 a9 a! T

8 a5 t, H/ g$ i Q7 A4 \% P; ^# u

任务是"封壳"中由一串操作形成的独立的执行路程; 线程是虚拟的处理器, 它与

5 M0 W6 n W0 C) j

任务编联并为任务提供所需的资源。支持多任务的"封壳"必定支持多线程。事件

% ? K) l8 u. w7 V, J; f) D; A

同步机制包括事件计数器(Event Counter)与顺序器(Sequencer), 用于对多个线

1 H. X7 ~- {$ m3 }+ |

程进行同步。套接字、通道、历程等用于进行"封壳"之间的通信。

, E7 I( U8 `0 K/ N* @: d

1 M1 u: Z( n7 c7 v1 J

一个工程模型对象是可以分布、激活、湮灭、转移的最小单元, 是编译了的计算

6 R9 K6 s0 d' l$ m) i0 Z) Q) ]5 [

模型对象。 由于可以把一个程序编译成一个单元, 也可以就单独的对象分别编

. t" {. E3 E+ L/ l2 S3 ]5 F# f

译, 因此, 一个工程模型对象就是一个或多个运行时的计算模型对象。工程模型

$ c, n1 t2 j+ V4 S: @2 l% }9 m

对象并不具备前面提到的透明性。透明性是在编译计算模型对象, 把透明服务加

0 n' J, J' V0 h/ o {( E' E: Z' M+ j" h

到附加操作与交互状态中而达到的。根据不同的需要可选择不同的透明性。

+ A: h. X9 i# h* w5 D

7 ~9 W8 |) h5 N* [; x x9 O, U$ v

　

/ { L. \/ |5 l0 w {8 K

0 i, U4 q! Z# N$ I; P/ B

构件对象模型系统的典型结构

& i8 r2 X4 w* t6 Q& G

4 i5 P* z( L% ~" ^" T1 ~

一构件对象模型系统的结构常可分为上、中、下三层，或可称之为基本程序结构

6 c/ R. _5 a8 ]* Q6 ^

、远程结构和线路协议（wire protocol）结构。如图所示：

8 h2 b$ C- Y8 L* O0 G. i1 }1 X! v

# U' \# V5 h) G6 l

　

) M- t) F/ s) Z

+ Q/ \; H: g! Z4 h1 M6 M; x

, @* H) A, [4 T8 g2 |

客户代理（Client Proxy）和 对象代理（Object Proxy）是由接口语言定义的

& n0 }# t# ]" s P, I3 a

代码，它们分别居留在客户进程空间和服务器的进程空间，两着都是用来为接口

: G; Z; a- {! t6 }0 M ?! l

参数的传递作准备工作。客户代理被用来按线路协议的要求将对一接口的调用参

8 W5 T9 q- T5 _6 k/ a

数打包（称为marshaling过程）或对调用结果解包（称为unmarshaling过程）；

9 q7 F7 d. A4 W& B9 o7 B- |0 l

对象代理则对接口的调用参数和调用结果分别实施unmarshaling过程和

p, d6 _1 A" S, p$ N/ Y) P4 v

marshaling过程。运行库被用来支持客户与对象间的通信，并为这种通信提供空

4 B$ ]- R* ~4 U/ f& B

间透明性，包括本地进程间的透明和远程透明。线路协议层被用来运载接口调用

2 ]; y( L$ t- ?4 Z9 U5 @# q0 y ^

参数和调用结果。

* ^' h6 Q! C0 w, x

! x' |0 x; k% S: l# J

当客户发出对一对象的接口调用后，客户所在机器的运行库1负责寻找该对象所

5 L- ]1 ^$ P+ i7 g$ {$ C7 B) e

在的位置并将具体实施该调用。当该对象为远程对象时，运行库1通过线路协议

6 i" a! N( R% }

层将调用参数传输到该对象所在机器的构件运行库2，通知运行库2实施本调用，

" c0 w3 V1 l7 u0 Q9 o, J: H# J

运行库2将调用结果返回到运行库1，由运行库1将调用结果送给客户。在此过程

8 h2 ?8 }& r* x

中，如果远程对象处于非活动状态，则运行库2将之激活。

! I, M, M5 P' s( G! \" U" r

% k& B! y |) h4 p) L* i

构件对象模型结构中的客户/服务器模型

! w: O! X& R5 l) ^% F; Y

# D! X7 J& S7 D" h( ^

在接口的调用过程中，调用者（应用程序或对象）充当客户的角色，而被调用的

& } X* ~0 Q1 c1 |; H2 l, O

接口所属的对象则相当于服务器。 客户应用对接口的调用必须经与运行库的参

U1 S4 J: e& v9 i

与，运行库的作用即是三层客户服务器结构中的中间层所起的作用，因此如下图

# {2 G4 I' w3 X; M

所示，客户应用──运行库──服务器组成了三层结构的客户/服务器模型。

+ [* x7 ]' G4 d4 K9 \: I% I- k

$ i @2 b* q4 G" B

　

2 r- _' J# m$ V- y" ~6 R3 {+ F" K+ h

" E ^ ^' C. W& ^; a) d- w$ o6 {

# g% k9 _' T. ~) B! ?

$ b; ^& j/ @6 P& b

构件对象模型的技术规范

% }+ Z) h1 {) |$ Y# z

$ i5 w' q8 N7 I$ J

目前构件与开放分布式系统模型理论已经在实际中得到了越来越广泛的应用。当

9 P8 H8 y! B6 D: Y! g

前应用较多的有以下三种技术规范或体系结构：一曰CORBA(Common Object

Z% N# h. `; |- m

Request Broker Architect)、二为COM/DCOM（Component Object Model /

8 [4 u& s/ G, H; T i; c/ H$ g- P

Distributed Component Object Model）、三称Java Beans。 除这三者之外，

7 i H1 M+ U0 E3 I$ z" _' J! Q

以下规范也可被用来构造分布式构件系统：

- ]( D) b g! D5 W |

1 I' ]* R- X u" P4 n+ T) b

OSF的DCE（Distributed Computing Enviroment）

0 B$ z4 r# R$ c, _& p- h6 n* p8 P7 l

远程过程调用－RPC (remote procedure calls)

$ d8 P# X/ F7 H5 }# \

命名管道（Named Pipe）通讯

; D% f h$ B& y3 ]( W W; y( {8 A

基于共享内存的系统

8 p" j2 b1 u; n( Q9 X* T9 D

套接字（Socket）编程

" F* A0 K. R: Y; x, d3 S! _1 q: D

消息排队（Message Queuing）

# l# r- _6 E2 \* t# [( e' D* i

其他进程间通讯机制

- h* `2 x0 I0 U, U

数据库表、触发器和轮询(polling)

+ W+ H0 e/ V* d6 U; K4 P: {2 y5 F

CORBA是由OMG(Object Management Group)在1989年提出，得到了从IBM、

/ c9 H% }3 a; ]* h- b

Microsoft、Sun、HP、Oracle、 DEC到Iona、Visigenic、VPM等公司的广泛支持

. b, R5 A0 r) ~, z

。COM/DCOM规范是Microsoft在独家发布的构件对象模式技术规范, 而Java

4 n& K6 Z% o" R# g; q! Y' u

Beans则是SUN公司在1994年12月提出的基于Java的构件模型。





欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5