CN100386724C

CN100386724C - 实现计算机软件系统中的构件动态聚合的方法

Info

Publication number: CN100386724C
Application number: CNB2006100271244A
Authority: CN
Inventors: 苏翼鹏; 陈榕; 黄凯峰
Original assignee: KETAI CENTURY SCIENCE AND TECHNOLOGY Co Ltd SHANGHAI
Current assignee: KETAI CENTURY SCIENCE AND TECHNOLOGY Co Ltd SHANGHAI
Priority date: 2006-05-30
Filing date: 2006-05-30
Publication date: 2008-05-07
Anticipated expiration: 2026-05-30
Also published as: HK1092897A1; CN1851643A

Abstract

本发明涉及一种实现计算机软件系统中的构件动态聚合的方法，其中包括聚合操作和拆卸操作，聚合操作包括分别实例化方面构件和外部构件得到被聚合对象和外部对象、外部对象保存或上一层被聚合对象保存被聚合对象指针、被聚合对象保存外部对象指针或上层被聚合对象指针形成聚合链表并将所有引用计数加载到外部对象，拆卸聚合操作包括外部对象根据需拆卸被聚合对象标识在聚合链表中找出相应的对象指针、在聚合链表中进行摘除并维持剩余的聚合链表、还原其在系统中所有的引用计数。采用该种实现计算机软件系统中的构件动态聚合的方法，提高了构件复用度和复用灵活性，提高了构件接口的查询和执行效率，增强系统运行的性能和稳定性。

Description

实现计算机软件系统中的构件动态聚合的方法

技术领域

本发明涉及计算机软件技术领域，特别涉及计算机构件化软件系统领域，具体是指一种实现计算机软件系统中的构件动态聚合的方法。

背景技术

随着现代构件化计算机软件技术的进一步发展，CAR(Component Assembly Runtime)构件技术是一种面向构件编程(Component Oriented Programming，简称COP)技术，它定义了一套网络编程时代的构件编程模型和编程规范，规定了一组构件间相互调用的标准，使得二进制构件能够自描述，能够在运行时动态链接。

目前，CAR构件技术已在某些先进的嵌入式操作系统上实现，在该嵌入式操作系统的SDK(Software Development Kit)下，用户很容易编写出自己的构件。

CAR构件技术的基础思想来源于微软的COM，但它对微软的COM进行了拓展，并且二者不兼容。CAR构件技术由CAR语言(构件描述语言，描述构件的元数据信息)、CAR编译器、自动代码生成工具以及CAR构件基础库支持。CAR构件技术体现了网络编程时代的特性，编程界面简单。

在COM里，聚合是一种构件的复用技术，请参阅图1所示，当构件对象B聚合了构件对象A，那么对于客户端来说，并不知道有构件对象A的存在，客户端使用构件对象A的服务完全由构件对象B来传替，被聚合对象A的生存周期也完全由对象B控制。(对于被聚合的对象我们有时也称之为内部对象，聚合者则相应称为外部对象)。

然而COM里的聚合模型有着比较大的限制，那就是一旦外部对象聚合了内部对象，那么内部对象其行为和生存周期完全由外部对象控制了，在外部对象的生存周期内，内部对象和外部对象再也不能拆卸，另外，COM的聚合方式只能在对象创建时发生，不能随时随地的聚合。在现实世界里，一个构件对象往往会随着环境改变而表现出(或拥有)不同的特征。比如宠物店的猫(构件对象)，具有宠物和商品两方面的特征(aspect)。但猫刚生下来时却未必是宠物，更不会是商品；而一旦被售出，就不再是商品，但宠物特征却保留了下来。显而易见，让猫进入宠物店就拥有宠物和商品两方面特征，而离开宠物店后就丢弃商品特征，使用COM的聚合模型是实现不了这种现实模型的，因为COM的聚合模型不是一种随时聚合、随时拆卸的动态聚合模型，这样就制约了现代计算机软件技术的进一步发展。

发明内容

本发明的目的是克服了上述现有技术中的缺点，提供一种能够根据软件运行的实际需要动态聚合和动态拆卸、构件对象在不同的运行环境里能够拥有和去除与运行环境相关的特征、提高构件复用的灵活性，降低程序设计的复杂度、能够更好地反映描述现实世界模型的实现计算机软件系统中的构件动态聚合的方法。

为了实现上述的目的，本发明的实现计算机软件系统中的构件动态聚合的方法如下：

该实现计算机软件系统中的构件动态聚合的方法，其主要特点是，所述的方法包括构件动态聚合操作和构件动态拆卸聚合操作，该构件动态聚合操作包括以下步骤：

(1)系统进行初始化操作；

(2)系统实例化方面构件类模型得到当前被聚合对象实例；

(3)系统实例化外部构件得到外部对象实例；

(4)如果该外部对象实例中不存在任何被聚合对象实例，则系统将所述的当前被聚合对象实例的指针传递给外部对象实例，外部对象实例保存该指针；否则，系统将所述的当前被聚合对象实例加入到已存在的被聚合对象实例链表中，并将所述的当前被聚合对象实例的指针传递给新的被聚合对象实例链表中的前一个被聚合对象实例，所述的新的被聚合对象实例链表中的前一个被聚合对象实例保存该指针；

(5)系统将外部对象实例的指针或者已存在的被聚合对象实例链表中的一个被聚合对象实例的指针传递给所述的当前被聚合对象实例；

(6)所述的当前被聚合对象实例保存相应的指针，形成聚合链表，并将所述的当前被聚合对象实例在系统中所有的引用计数全部加载到外部对象实例；

(7)完成动态聚合操作；

该构件动态拆卸聚合操作包括以下步骤：

(1)系统将需要拆卸的被聚合对象实例的对象标识传递给所述的外部对象实例；

(2)该外部对象实例根据该对象标识在聚合链表中找出相应的被聚合对象实例的指针；

(3)该被聚合对象实例在聚合链表中进行摘除自身并维持剩余的聚合链表的处理；

(4)被聚合对象实例从外部对象实例中还原其在系统中所有的引用计数；

(5)完成动态拆卸聚合操作。

所述的构件动态聚合操作中在步骤(4)之前还包括有以下步骤：

(31)系统进行构件添加到聚合链表前的制约处理。

所述的构件动态聚合操作中在步骤(7)之前还包括有以下步骤：

(61)系统进行构件添加到聚合链表后的制约处理。

所述的构件动态聚合操作中在步骤(7)之后还包括有以下步骤：

(71)系统进行构件聚合完成后的制约处理。

所述的构件动态拆卸聚合操作中在步骤(3)之后还包括有以下步骤：

(31)系统进行构件从聚合链表摘除后的制约处理。

所述的构件动态拆卸聚合操作中在步骤(5)之后还包括有以下步骤：

(51)系统进行构件拆卸聚合完成后的制约处理。

所述的方面构件类模型中具有方面接口，该方面接口中包括有接口查询成员方法Querylnterface、添加引用成员方法AddRef、释放成员方法Release和聚合成员方法Aggregate。

所述的被聚合对象实例摘除自身并维持剩余的聚合链表的处理包括以下步骤：

(1)该被聚合对象实例将自身保存的所述的聚合链表中的后一个被聚合对象实例的指针传递给所述的聚合链表中的前一个被聚合对象实例；

(2)所述的聚合链表中的前一个被聚合对象实例保存该指针；

(3)该被聚合对象实例将自身保存的外部对象实例的指针或者已存在的被聚合对象实例链表中的一个被聚合对象实例的指针传递给所述的聚合链表中的后一个被聚合对象实例；

(4)所述的聚合链表中的后一个被聚合对象实例保存该指针。

采用了该发明的实现计算机软件系统中的构件动态聚合的方法，由于通过方面构件模型的对象实例与外部构件的对象实例进行交互操作，最终形成了外部构件对象实例内的聚合链表结构，不仅实现了动态聚合、动态拆卸的聚合模型，而且突破了COM只能在创建时聚合以及聚合之后不能拆卸的限制，可提高构件的复用度以及构件复用的灵活性；不仅如此，本发明的方法能够提高构件接口的查询和执行效率，增强系统运行的性能和稳定性，在构件的复用领域为面向构件编程提供了宽广的空间，为软件工厂化提供了一条简便的途径；并且提高了软件的可扩展性，方便了用户对不同需求的扩展，为构件化软件系统的进一步发展奠定了坚实的基础。

附图说明

图1为现有技术中COM组件对象聚合模型示意图。

图2为本发明的方面构件对象模型示意图。

图3为本发明的方面对象实例在非聚合的情况下接口示意图。

图4为本发明的方面对象实例在聚合的情况下接口示意图。

图5为本发明的方面对象实例在聚合的情况下从客户端角度看聚合的结果的示意图。

图6为本发明的两个对象聚合后的简单状态示意图。

图7为本发明的多个方面对象实例形成聚合链表的聚合模型示意图。

图8为本发明的方面对象实例进行动态拆卸聚合的示意图。

具体实施方式

为了能够更清楚地理解本发明的技术内容，特举以下实施例详细说明。

该实现计算机软件系统中的构件动态聚合的方法，其中，所述的方法包括构件动态聚合操作和构件动态拆卸聚合操作，该构件动态聚合操作包括以下步骤：

(1)系统进行初始化操作；

(2)系统实例化方面构件类模型得到被聚合对象实例；所述的方面构件类模型中具有方面接口，该方面接口中包括有接口查询成员方法QueryInterface、添加引用成员方法AddRef、释放成员方法Release和聚合成员方法Aggregate；

(3)系统实例化外部构件得到外部对象实例；还可以包括有以下步骤：

(31)系统进行构件添加到聚合链表前的制约处理。

(4)如果该外部对象实例中不存在被聚合对象实例，则系统将被聚合对象实例的指针传递给外部对象实例，外部对象实例保存该指针；否则，系统将被聚合对象实例的指针传递给上一层被聚合对象实例，上一层被聚合对象实例保存该指针；

(5)系统将外部对象实例的指针或者上层被聚合对象实例的指针传递给该被聚合对象实例；

(6)被聚合对象实例保存相应的指针，形成聚合链表，并将该被聚合对象实例在系统中所有的引用计数全部加载到外部对象实例；还可以包括有以下步骤：

(61)系统进行构件添加到聚合链表后的制约处理。

(7)完成动态聚合操作；还可以包括有以下步骤：

(71)系统进行构件聚合完成后的制约处理。

该构件动态拆卸聚合操作包括以下步骤：

(3)该被聚合对象实例在聚合链表中进行摘除自身并维持剩余的聚合链表的处理，该处理包括以下步骤：

(a)该被聚合对象实例将自身保存的下一层被聚合对象实例的指针传递给上一层被聚合对象实例；

(b)上一层被聚合对象实例保存该指针；

(c)该被聚合对象实例将自身保存的外部对象实例的指针或者上层被聚合对象实例的指针传递给下一层被聚合对象实例；

(d)下一层被聚合对象实例保存该指针；

还可以包括有以下步骤：

(31)系统进行构件从聚合链表摘除后的制约处理。

(5)完成动态拆卸聚合操作，还可以包括有以下步骤：

(51)系统进行构件拆卸聚合完成后的制约处理。

在实际使用当中，要实现动态的聚合模型，首先要实现类似于COM的聚合模型，也就是说外部对象要聚合内部对象，内部对象必须是可被聚合的。为此在CAR构件技术引入了方面(aspect)构件对象模型，请参阅图2所示。

aspect是一种特殊的构件类实现，aspect对象的特征是可以被其它构件对象聚合，该构件类必须实现IAspect接口，aspect对象就是实现了IAspect接口的构件对象。

在此附带说明一下，在COM里所有接口都是继承IUnknown接口的，在CAR构件体系里，所有接口都是继承于基接口IObject。IObject接口扩展了IUnknown接口，其定义如下：

interface IObject

{

ECODE QueryInterface(

[in]REFIID riid，

[out]IObject **ppObject)；

ULONG AddRef()；

ULONG Release()；

ECODE Aggregate(

[in]AggregateType type，

[in]IObject *pObject)；

}

其中的ECODE是个32位整形的返回值，类似于微软公司的HRESULT。

前三个接口和IUnkown接口基本等价(除了QueryInterface方法的输出参数为IObject^**)，但多了个Aggregate方法，这就与COM不兼容了。

通常情况下，在COM里，可被聚合对象必须实现两个IUnknown接口，委托IUnknown接口和非委托IUnknown接口。在聚合的情况下，委托IUnknown接口把调用传给外部对象，在非聚合的情况下委托IUnknown接口把调用传给非委托IUnknown接口；非委托IUnknown接口是对IUnknown接口的真正实现。

对于每个aspect构件对象，对IAspect实现是真正意义上的IObject实现，而对IObject接口实现只是进行简单的转接。请参阅图3所示，当aspect构件对象作为一个独立的构件对象存在时，对IObject的方法调用将会完全转接到IAspect接口的对应方法上。再请参阅图4所示，如果aspect对象被其它构件对象聚合，对IObject的方法调用则会被委托给外部对象的IObject接口方法，外部对象保存aspect对象的IAspect接口指针，用于aspect对象实现的接口查找(QueryInterface)，这与COM聚合模型的实现非常类似。

请参阅图5所示，一旦aspect对象被外部对象聚合了，那么二者就形成了一个构件对象，而在客户端看来，只知有外部对象的存在，而不知有aspect对象的存在。

在本发明的方法里的aspect对象也具有普通构件对象所具有的功能，也就是说aspect对象不但可被其他普通构件对象聚合，还可以聚合其他的aspect对象。

在本发明的方法里定义一个aspect对象是非常简单的事情，只要如下描述就可以了：

interface IHello

{

Hello()；

}

aspect CHello{

interface IHello；

}

那么CHello构件类就是一个可被聚合的aspect构件类了，被实例化后就是aspect对象。

到此，系统中已经建立了两个普通构件的聚合模型，下面要解决的问题就是怎样达到随时聚合(也就是动态聚合)，并且能够随时拆卸聚合(也就是动态拆卸聚合)。首先是进行动态聚合。

动态聚合就是构件对象随着执行环境(或者说上下文)的变化，在执行时聚合其他的构件对象。COM里的聚合行为只是发生在组件对象创建之时，如对象B聚合对象A，在创建对象A时，将对象B的IUnknown指针作为CoCreateInstance的第二个参数：

LA*ia＝NULL；

HRESULT hr＝CoCreateInstance(CLSID_CA，pb，CTX_SAME_DOMAIN，IID_IA，

(PVOID)&ia)；

...............

上面只是一段示例代码，IA代表对象A实现的接口，IID为IID_IA，CLSID_CA是对象A的CLSID，pb是聚合者对象B的IUnknown接口指针。

在本发明的方法里，聚合行为的发生是对IObject接口中Aggregate方法的调用。只要两个对象都被创建出来了，并且满足了聚合条件，那么聚合行为就可以随时发生。再看上面的例子，如果我们用m_pOuter表示聚合者对象B的指针(可以是对象B的任意一接口指针)，m_pAspect指向被聚合者A的指针(可以是对象A的任意一接口指针)，那么下面对Aggregate方法的调用就完成了聚合：

m_pAspect-＞Aggregate(AggrType_Aggregate，m_pOuter)；

AggregateType类型指定了AggrType_Aggregate，说明函数完成的是聚合行为。

为了语义上更加明了以及使用上更加简便，本发明的方法中的构件基础库还提供了一个专门用于聚合的API函数：

EZAPI EzAggregate(

/*[in]*/POBJECT pAggregator，

/*[in]*/POBJECT pAspect)

其中EZAPI为API函数调用宏，其定义如下：

#define EZAPI extern“c”unsigned int_stcall

这个函数实际上是对上面调用的封装。pAggregator是指向聚合者的指针，pAspect则指向aspect对象指针。

无论是上面哪种形式被调用，都会发生如下聚合过程：

1)外部对象有了指向aspect对象的指针(m_pAspect)；

2)被聚合的aspect对象就有了指向外部对象的指针(m_pOuter)；

3)aspect对象保存外部对象指针并将所有的引用计数全部转嫁到外部对象。

聚合后两个对象的状态请参阅图6所示。

上述的过程只是两个对象的聚合，外部对象只聚合了一个aspect对象，但实际上，往往需要一个对象聚合多个aspect对象，这就是多面聚合。在完成多面聚合时，实现上并没有多大的变化，就是创建多个aspect对象，多次调用EzAggregate方法使一个对象聚合多个aspect对象。请参阅图7所示，其中是多面聚合的结果示意图。

可以看出，构件对象指向下层被聚合的aspect对象指针(m_pAspect)构成了一个单向链表(聚合链)，而链表中每一个aspect对象的m_pOuter指针都指向最外层的外部对象(聚合者)。通过这种方式，QureryInterface调用可以在链表中从头向尾传递，而所有aspect对象的引用计数都委托给了最外层的外部对象。这与前面所介绍的两个对象聚合的情况并没有多大区别。

当然，上图是一种比较理想的聚合情况，在某些情况下，下层aspect对象的m_pOuter指针可能会指向中间的aspect对象，最坏的情况是每一个aspect对象的m_pOuter指针都指向它相邻的上层对象。虽然这样也能正确运行，不影响执行的结果，但运行效率却十分低下。

通过动态聚合和多面聚合，可以随时随地聚合一个或多个aspect对象，接下来就要实现动态拆卸聚合。

请参阅图8所示，其中表示了动态拆卸聚合的过程，即从聚合链中找到要拆卸的aspect对象指针，然后从聚合链里将其剔除。

动态拆卸聚合也是通过对IObject接口中Aggregate方法的调用完成的。

m_pAspect-＞Aggregate(AggrType_Unaggregate，m_pOuter)；

AggregateType类型指定了AggrType_Unaggregate，说明函数完成的是拆卸聚合行为。为了简便，本发明的方法中的构件库提供了EzUnaggregate函数来实现动态拆卸聚合：

EZAPI EzUnaggregate(

/*[in]*/POBJECT pAggregator，

/*[in]*/REFEZCLSID rAspectClsid)

pAggregator为外部对象，rAspectClsid为aspect对象构件类的EZCLSID标识，这个函数实际上就是上面调用的封装，使外部对象动态地拆卸某个已被聚合了的aspect对象，其大致的实现过程如下：

1)外部对象通过要被拆卸的aspect对象标识在聚合链里找出相应的aspect对象IAspect接口指针；

2)与rAspectClsid匹配aspect对象断开自己并维持剩余的聚合链表；

3)还原引用计数。由于在聚合时aspect对象将引用计数完全转嫁到了外部对象，所以在拆卸的时候必须还原，还原的过程就是聚合时转嫁的相反过程。

现实世界里，构件对象在聚合以及拆卸聚合时往往不是那么随意，也就是说，聚合完成以及拆卸聚合的完成需要条件。如一只猫要想成为宠物店里的猫，这只猫必须要为人所喜爱，它才能成为宠物店里具有商品价值的猫(也就是猫可聚合宠物和商品两个特征)；相应地，宠物店里的猫要被卖出，至少需要达到一定的价钱，猫才可被人买走(也就是猫拆卸聚合了商品的特征)。为此本发明的方法在构件类实现时为构件的实现者提供一套可重载的虚函数来实现聚合和拆卸聚合时的制约。

对于本发明方法中的每个构件类(无论是聚合者还是aspect对象)，构件的实现者可重载如下几个函数来实现对该构件类对象在聚合或拆卸聚合时的制约：

virtual CARAPI OnAspectAttaching(POBJECT pAspect)；

virtual CARAPI OnAspectAttached(POBJECT pAspect)；

virtual CARAPI OnAspectDetached(POBJECT pAspect)；

其中CARAPI为宏，其定义如下：

#define CARAPI unsigned int_stdcall

在聚合aspect对象时，在将aspect对象添加到聚合链之前，OnAspectAttaching函数会被触发，当添加结束OnAspectAttached函数会被触发。

在拆卸聚合时，功能是完成从聚合链里摘除被拆卸的aspect对象，在该实现完毕的时候会调用OnAspectDetached函数。

另外，对于aspect对象构件类，不但可重载如上三个虚函数，还可以重载如下两个虚函数：

virtual CARAPI OnAggregated(POBJECT pOuter)；

virtual CARAPI OnUnaggregated(POBJECT pOuter)；

聚合完成时，OnAggregated会被调用，拆卸聚合完成时，OnUnaggregated会被调用。

下面以一个简化了的游戏来示例本发明的构件的动态聚合的方法。

在一些游戏里，游戏角色(Role)在游戏场景里拣到什么样的工具就可以发挥此工具的特性，比如角色见到一把枪，就可以向敌人开火，拣到剑就能施展剑术等等，但是当角色扔掉工具后就不能发挥工具的特性了，没有枪就不能开枪，没有剑就不能施展剑术。在这个例子里我们只考虑一种很简单的情况，那就是角色(Role)拣到了剑就能施展剑术(SwordPlay)，角色扔掉了剑就不能施展剑术。我们将角色和剑术分别设计为构件类CRole和CSwordPlay，这样可以减轻开发角色的负担。可以描述这两个构件类如下：

module

{

interface IActionControl{

GetSword()；

AbandonSword()；

}

interface ISwordFunctionality{

split()；

thrust()；

chop()；

}

class CRole{

interface IActionControl；

}

aspect CSwordPlay{

interface ISwordFunctionality；

}

其中的module描述了表示一个构件模块。我们让CRole和CSwordPlay分别实现IActionControl和ISwordFunctionality接口。CSwordPlay是一个aspect构件类，当Role拣到剑的时候会聚合CSwordPlay对象的ISwordFunctionality接口，扔掉剑的时候会拆卸聚合ISwordFunctionality接口。

上面的描述将其置于一个名为gamesam.car文件里，使用特定的编译器以及自动代码生成工具会生成构件的实现，而用户只需关心自己定义的接口函数的实现，为此会生成CRole和CSwordPlay对各自接口函数的空实现，用户只要填入我们自己的代码就可以了，下面分别是这两个类的cpp以及h文件：

CRole.cpp

#include″CRole.h″

#include″_CRole.cpp″

DECLARE_CLASSOBJECT(CRole)

ECODE CRole::GetSword()

{

m_bSwordPlay＝TRUE；

return NOERROR；

}

ECODE CRole::AbandonSword()

{

m_bSwordPlay＝FALSE；

return NOERROR；

}

ECODE CRole::OnAspectAttaching(POBJECT pObj)

{

if(！m_bSwordPlay)return E_FAIL；

return NOERROR；

}

其中的_CRole.cpp是生成的有关构件对象底层实现代码，普通构件编写者不用关心，在此不做介绍，下面的_CSwordPaly也类似。CAR构件还可以为每个构件类自动生成类产对象，DECLARE_CLASSOBJECT(CRole)宏就是为CRole生成类产对象，下面的DECLARE_CLASSOBJECT(CSwordPlay)是为CSwordplay生成类产对象，再次只是简单说明一下)

CRole.h

#ifndef_CROLE_H_

#define_CROLE_H_

#include″_CRole.h″

class CRole:public_CRole

{

public:

CARAPI GetSword()；

CARAPI AbandonSword()；

CARAPI OnAspectAttaching(POBJECT pAspect)；

private:

//TODO:在这里添加用户自己的私有成员变量

BOOL m_bSwordPlay；

}；

#endif//_CROLE_H_

对于CRole，增加了聚合时的制约，在聚合时如果Role已经得到剑了，那么聚合CSwordPlay对象可以成功，若还没有得到剑就不能聚合CSwordPlay对象。

CSwordPlay.cpp

#include″CSwordPlay.h″

#include″_CSwordPlay.cpp″

#include<stdio.h>

DECLARE_CLASSOBJECT(CSwordPlay)

ECODE CSwordPlay::split()

{

printf(″\nsplit！\n″)；

return NOERROR；

}

ECODE CSwordPlay::thrust()

{

printf(″\nthrust！\n″)；

return NOERROR；

}

ECODE CSwordPlay::chop()

{

printf(″\nchop！\n″)；

return NOERROR；

}

CSwordPlay.h

#ifndef_CSWORDPLAY_H_

#define_CSWORDPLAY_H_

#include″_CSwordPlay.h″

class CSwordPlay:public_CSwordPlay

{

public:

CARAPI split()；

CARAPI thrust()；

CARAPI chop()；

private:

//TODO:Add your private member variables here.

}；

#endif//_CSWORDPLAY_H_

对于类CSwordPlay这里只是简单地打印了剑的几种行为。

下面就是客户端的程序了：

#include<stdio.h>

//引用gamesam.dll

Susing gamesam.dll；

int_cdecl main()

{

ECODE ec；

IActionControl*pActionControl＝NULL；

ISwordFunctionality*pSword＝NULL；

IObject*pSwordPlay＝NULL；

//创建Role对象，得到IActionControl指针pActionControl

ec＝EzCreateObject(

CLSID_CRole，

CTX_SAME_DOMAIN，

IID_IActionControl，

(POBJECT*)&pActionControl)；

if(FAILED(ec))goto ErrorExit；

//创建SwordPlay对象，得到其IObject指针pSwordPlay

ec＝EzCreateInstance(

CLSID_CSwordPlay，

CTX_SAME_DOMAIN，

IID_IObject，

(POBJECT*)&pSwordPlay)；

if(FAILED(ec))goto ErrorExit；

//Role得到剑

pActionControl-＞GetSword()；

//Role得到了剑，可以施展剑术了，于是聚合SwordPlay对象

ec＝EzAggregate((POBJECT)pActionControl，pSwordPlay)；

if(FAILED(ec)){

goto ErrorExit；

}

else{

//Role聚合SwordPlay对象成功，从Role对象里得到ISwordFunctionality指针pSword

ec＝pActionControl-＞QueryInterface(IID_ISwordFunctionality，(POBJECT

*)&pSword)；

if(FAILED(ec))goto ErrorExit；

}

//Role施展剑术，使用剑的功能

pSword-＞split()；

pSword-＞thrust()；

pSword-＞chop()；

pSword-＞Release()；

//Role扔掉剑

pActionControl-＞AbandonSword()；

//Role拆卸聚合SwordPlay对象，Role不能使用剑术

ec＝EzUnaggregate((POBJECT)pActionControl，CLSID_CSwordPlay)；

if(FAILED(ec))goto ErrorExit；

//Role已经扔掉剑再次想拥有剑术，于是聚合SwordPlay对象

ec＝EzAggregate((POBJECT)pActionControl，pSwordPlay)；

if(FAILED(ec)){

//由于Role已经扔掉剑，所以不能施展剑术，所以不能聚合//SwordPlay对象，所以从

//Role对象里查询不到ISwordFunctionality接口

ec＝pActionControl-＞QueryInterface(IID_ISwordFunctionality，(POBJECT

*)&pSword)；

if(FAILED(ec)){

printf(″No sword，No swordplay！\n″)；

}

if(pActionControl)pActionControl-＞Release()；

if(pSwordPlay)pSwordPlay-＞Release()；

if(pSword)pSword-＞Release()；

printf(″Game over！\n″)；

return0；

ErrorExit:

if(pActionControl)pActionControl-＞Release()；

if(pSwordPlay)pSwordPlay-＞Release()；

if(pSword)pSword-＞Release()；

printf(″Exit with error！\n″)；

return 1；

}

上面所列出的源代码在本发明的手机嵌入式操作系统平台下编译开发的，其运行结果如下：

split！

thrust！

chop！

No sword，No swordplay！

Game over！

结果与预期的完全相同。

采用了上述的实现计算机软件系统中的构件动态聚合的方法，由于通过方面构件模型的对象实例与外部构件的对象实例进行交互操作，最终形成了外部构件对象实例内的聚合链表结构，不仅实现了动态聚合、动态拆卸的聚合模型，而且突破了COM只能在创建时聚合以及聚合之后不能拆卸的限制，可提高构件的复用度以及构件复用的灵活性；不仅如此，本发明的方法能够提高构件接口的查询和执行效率，增强系统运行的性能和稳定性，在构件的复用领域为面向构件编程提供了宽广的空间，为软件工厂化提供了一条简便的途径；并且提高了软件的可扩展性，方便了用户对不同需求的扩展，为构件化软件系统的进一步发展奠定了坚实的基础。

Claims

1.一种实现计算机软件系统中的构件动态聚合的方法，其特征在于，所述的方法包括构件运行时动态聚合操作和构件运行时动态拆卸聚合操作，该构件运行时动态聚合操作包括以下步骤：

(1)系统进行初始化操作；

(2)系统实例化方面构件类模型得到当前被聚合对象实例；

(3)系统实例化外部构件得到外部对象实例；

(7)完成运行时动态聚合操作，被聚合至外部构件中的方面构件类对象实例的功能接口对用户可见；

该构件运行时动态拆卸聚合操作包括以下步骤：

(5)完成运行时动态拆卸聚合操作，外部构件中被拆卸掉的方面构件类对象实例的功能接口对用户不可见。

2.根据权利要求1所述的实现计算机软件系统中的构件动态聚合的方法，其特征在于，所述的构件动态聚合操作中在步骤(4)之前还包括有以下步骤：

(31)系统进行构件添加到聚合链表前的制约处理。

3.根据权利要求1所述的实现计算机软件系统中的构件动态聚合的方法，其特征在于，所述的构件动态聚合操作中在步骤(7)之前还包括有以下步骤：

(61)系统进行构件添加到聚合链表后的制约处理。

4.根据权利要求1所述的实现计算机软件系统中的构件动态聚合的方法，其特征在于，所述的构件动态聚合操作中在步骤(7)之后还包括有以下步骤：

(71)系统进行构件聚合完成后的制约处理。

5.根据权利要求1所述的实现计算机软件系统中的构件动态聚合的方法，其特征在于，所述的构件动态拆卸聚合操作中在步骤(3)之后还包括有以下步骤：

(31)系统进行构件从聚合链表摘除后的制约处理。

6.根据权利要求1所述的实现计算机软件系统中的构件动态聚合的方法，其特征在于，所述的构件动态拆卸聚合操作中在步骤(5)之后还包括有以下步骤：

(51)系统进行构件拆卸聚合完成后的制约处理。

7.根据权利要求1至6中任一项所述的实现计算机软件系统中的构件动态聚合的方法，其特征在于，所述的方面构件类模型中具有方面接口，该方面接口中包括有接口查询成员方法QueryInterface、添加引用成员方法AddRef、释放成员方法Release和聚合成员方法Aggregate。

8.根据权利要求1至6中任一项所述的实现计算机软件系统中的构件动态聚合的方法，其特征在于，所述的被聚合对象实例摘除自身并维持剩余的聚合链表的处理包括以下步骤：

(2)所述的聚合链表中的前一个被聚合对象实例保存该指针；

(4)所述的聚合链表中的后一个被聚合对象实例保存该指针。