CN104902018A - 基于服务簇的服务组合与替换方法 - Google Patents

Abstract

本发明公开了一种基于服务簇的服务组合与替换方法。本发明借助已有的服务聚簇方法构建服务簇，并基于Petri网提出服务及服务簇的形式化描述方法；将服务的输入输出参数抽象表示，通过参数矩阵来描述服务的输入输出参数；本发明中的服务匹配方法使服务簇中的服务间能够充分共性与个性，通过缩小服务查找范围，从而提高服务发现与组合效率；通过对服务簇模型的改进，提出Web服务组合替换方法；对服务簇内服务的并行组合与串行组合分别进行了描述，在服务簇内实现快速服务组合，进而实现高效率的服务组合替换；本发明中的服务替换方法，不仅能实现服务簇内单一服务替换,而且能实现服务簇内服务组合替换。

Description

基于服务簇的服务组合与替换方法

技术领域

本发明涉及一种基于服务簇的服务组合与替换方法。

背景技术

在全球信息化大潮的推动下，Web服务技术得到迅猛的发展，Web服务的应用尤为常见。随着网络资源的丰富，服务的数量大量增加，这使服务发现与替换面临着巨大的压力。服务簇的提出大大缩小了服务发现的查找范围，使服务发现效率有效提高。而在服务簇中，各个服务具有参数不确定性，需要一种统一的形式化描述方法。在Web服务的形式化描述中，不仅要给出服务自身的特征，还要能够方便在服务簇的描述中给出服务之间的交互特点，这样方便服务的发现与组合，因此，需要给出服务及服务簇的合理规范的形式化描述。由于服务的动态性，在响应用户请求的过程中，可能存在一些服务失效。在传统的服务组合模式中，服务的失效会造成服务流程的中断。在实际应用中，流程的中断可能会造成巨大的损失。

目前，国内外对于服务形式化模型的研究主要基于Petri网、进程代数和有限状态自动机、语义网等几类工具，并且都取得了一定的成果，然而服务替换的研究还处在初级阶段。现有的大多数研究都是围绕解决现有的Web服务替换机制中存在的查准率不高的问题，而很少有在聚类得到的服务集合(即服务簇，Service cluster)层面上建模并进行服务替换的研究，而且对服务的组合替换缺乏考虑。随着Web服务数量的迅速增加，采用传统的服务查找和替换方法，必然会浪费大量时间来处理毫不相关的服务，从而使得效率低下甚至造成服务组合流程的中断，造成巨大损失。

发明内容

针对现有技术中存在的上述技术问题，本发明提出了一种基于服务簇的服务组合与替换方法，其采用如下技术方案：

基于服务簇的服务组合与替换方法，包括如下步骤：

a、构建Web服务和服务簇的形式化模型

定义是一个自然数集合，即而设定且

定义Petri网：

一个Petri网表示为一个四元组PN＝(S,T；F,M0)，其中，

(1)S是一个有限库所集；

(2)T是一个有限变迁集，且

(3)是一个弧集；

(4)dom(F)∪cod(F)＝S∪T，其中，

$\mathrm{dom}\left(F\right)=\{x\∈S\∪T|\∃y\∈S\∪T:(x,y)\∈F\},\mathrm{cod}\left(F\right)=\{y\∈S\∪T|\∃x\∈S\∪T:(x,y)\∈F\};$

(5)M:为网PN的一个标识，其中，

M(s)表示标识M下库所s中的托肯数，M₀是初始标识；

定义输入/输出集：

设PN＝(S,T；F,M₀)为一个Petri网，x∈S∪T为网N的一个元素，记：

^·x＝{y|y∈S∪T∧(y,x)∈F}称为x的输入集；

x^·＝{y|y∈S∪T∧(x,y)∈F}称为x的输出集；

^·x∪x^·称为元素x的外延；

在Petri网中，采用一个圆圈表示一个库所，用一个矩形表示一个变迁；若(x,y)∈F，则x到y的一条有向边表示它们的流关系；

定义引发规则：

设PN＝(S,T；F,M₀)为一个Petri网，则其具有如下的变迁发生规则：

1)对于变迁t∈T，如果则变迁t在标识M有发生权，记为M[t＞；

2)如果M[t＞，则在标识M下，变迁t能够发生，从标识M发生变迁t得到一个新的标识M′，记为

根据上述Petri网的定义，构建Web服务的形式化模型如下：

定义Web服务：

一个Web服务描述为一个四元组WS＝(SF,I,O)，其中：

(1)SF表示服务的功能语义描述；

(2)I、O表示服务的输入、输出参数集，并且其中，

①P.name是输入、输出参数名；

②P.concept是一个输入、输出参数的本体概念，用以表示参数的语义；

定义服务请求：

一个服务请求表示为R＝(SF_r,I_r,O_r)，其中：

(1)SF_r表示服务请求的功能语义描述；

(2)I_r代表服务请求者可提供的输入参数集；

(3)O_r代表服务请求者需要输出的参数集；

定义服务网元：

服务WS＝(SF,I,O)的服务网元定义为SNU＝(t,I_t,O_t,F_t,M)，其中：

(1)t是一个能够完成服务功能的变迁；

(2)I_t＝^·t＝{s_i1,s_i2,s_i3,…,s_in}是变迁t的输入集，代表服务的输入参数集合；O_t＝t^·＝{s_o1,s_o2,s_o3,…,s_on}代表服务的输出参数集合；

(3)F_t＝(I_t×t)∪(t×O_t)是有向弧集合，表示服务的输入、输出参数的流关系；

(4)M是服务网元的标识，M：I_t∪O_t→{0,1}；

(5)变迁t在M下的发生规则为：

①则变迁t在M下有发生权，记为M[t>；

②若M[t>，则t在标识M下能够发生并得到一个新的标识，记作M[t>M′，对于

定义服务簇：

对于n个服务：ws₁,ws₂,...，SC＝{ws₁,ws₂,...,ws_n}是一个服务簇，其中：

且SF_u和SF_v满足语义相似；

定义服务簇网元：

一个有n个服务的服务簇：SC＝{ws₁,ws₂,...,ws_n}，SNU_k＝(t_k,I_tk,O_tk,F_tk,M_k)，服务簇网元表示为SCNU＝(SU,t_C,I_C,O_C,F_C,M_C)，其中：

(1)SU＝{SNU₁,SNU₂,SNU₃,…,SNU_n}是服务网元的集合；

(2)t_C是服务簇网元的变迁，且能够完成服务簇中各服务的功能；

(3)I_C、O_C分别表示服务的输入、输出参数集，并且 其中：

①P.concept是服务簇中服务输入参数对应的语义概念；

②P.lable是一个n×1的矩阵，其中，n是服务簇中服务的个数，并且P.lable是服务簇中的服务相应P.concept的值；

(4)F_C＝(I_Ct×t_C)∪(t_C×O_Ct)表示服务簇输入、输出参数的流关系；

(5)M_C是服务簇网元的标识；

根据服务簇网元的定义，将一个服务的输入参数值作为服务簇输入矩阵的一行；将该服务的输出参数值作为服务簇输出参数矩阵的对应行；

b、基于服务簇的服务发现、组合与替换

设服务簇k的服务总数为m个，输入参数的总数为n_i个，输出参数总数为n_o个；I_Ck、O_Ck、i_r、o_r分别代表服务簇的输入矩阵、服务簇的输出矩阵、服务请求的输入矩阵、以及服务请求的输出矩阵；其中，I_Ck是一个m×n_i矩阵，O_Ck是一个m×n_o矩阵，i_r是一个1×n_i矩阵，o_r是一个1×n_o矩阵；I_Ck ^p(q)代表输入矩阵的第p行第q列的值；

输入一个服务簇网元模型SCNU_k＝(SU_k,t_Ck,I_Ck,O_Ck,F_Ck,M_Ck)和一个服务请求网元s_r＝{sf_r,i_r,o_r}，基于服务簇的服务匹配输出C_I和C_O，其中，C_I表示输入匹配矩阵，是一个m×n_i矩阵；C_O表示输出匹配矩阵，是一个m×n_o矩阵；

基于服务簇的服务匹配的过程如下：

S1:以I_Ck的首行开始，依次匹配该行的每个值；

S2:若该行中元素的值小于或者等于i_r对应的值，则标记C_I对应位置的值为1；

S3:否则，标记为0；

S4:以O_Ck的首行开始，依次匹配该行的每个值；

S5:若该行中元素的值大于或者等于i_r对应的值，则标记C_I对应位置的值为1；

S6:否则，标记为0；

S7:输出矩阵C_I和矩阵C_O；

其中，服务匹配过程的时间复杂度是m×n_i ²+m×n_o ²；

通过上述服务匹配过程，服务簇输入/输出匹配矩阵将服务簇中的服务按照当前服务请求统一表示服务匹配结果；

通过上述服务匹配过程明确区分各服务输入输出参数是否满足服务请求，提高服务查找效率；

输入一个输入匹配矩阵C_I和一个输出匹配矩阵C_O，基于上述服务匹配过程提出服务发现的过程，进而得到一个服务集合S；

服务发现的具体过程如下：

S1:p＝1,

S2:以C_I的第p行开始，依次匹配该行的每个值；

S3:若该行中所有的值都为1，则跳到S5；

S4:否则p＝p+1，循环这一匹配过程；

S5:依次匹配C_O第p行的各值；

S6:若该行中所有的值都为1，则将该服务合并入集合S中，即S＝S∪{ws_p}；

S7:否则p＝p+1，跳到S2；

S8输出服务集合S；

通过服务发现过程发现服务簇中满足服务请求的服务；服务发现过程输出的服务集合S中，所有服务的输入输出匹配矩阵同为即服务集合S中的每个服务都满足服务请求；服务发现过程的时间复杂度为：m×n_i+m×n；

定义ws_i◇ws_j表示服务ws_i和服务ws_j的并行组合；定义ws_i|ws_j表示服务ws_i和服务ws_j的串行组合；

设α＝[b₁,b₂,…,b_k]是一个1×k矩阵，其中，b_i∈{0,1}，且对于如果b_i＝1，α表示为E，即E＝[1,…,1]；

对于若b_i＝0，α表示为0，即0＝[0,0,…,0]；

其中，α表示Petri网中的一个标识；并且α₁≥α₂表示b_1i≥b_2i；

定义基元素：

设α₁＝[b₁₁,b₁₂,…,b_1k]且α₂＝[b₂₁,b₂₂,…,b_2k]是两个1×k矩阵，其中 and b_2i∈{0,1}，若α₁≥α₂，则称α₂是α₁的一个基元素；

定义基集合：

设C是一个1×k矩阵的集合；如果或者α_q是α_p的一个基元素，且|C”|＞|C’|，则称C’是C的一个基集合；

定义服务组合标志：

用于标记当前服务请求下的服务组合的服务基集合，其初始标志为

根据服务匹配过程提出服务匹配的运算方法如下：

定义匹配运算：

SNU_a＝(t_a,I_ta,O_ta,F_ta,M_a)是一个服务网元，R＝(SF_r,I_r,O_r)是一个服务请求；

匹配运算被定义为：

$\left(1\right)I_r\⊗I_{\mathrm{sa}}=\left[m\left({\mathrm{sr}}_{I1}\right)\⊗m\left({\mathrm{sa}}_{I1}\right),m\left({\mathrm{sr}}_{I2}\right)\⊗m\left({\mathrm{sa}}_{I2}\right),...,m\left({\mathrm{sr}}_{\mathrm{In}}\right)\⊗m\left({\mathrm{sa}}_{\mathrm{In}}\right)\right],$

其中，

$\left(2\right)O_{\mathrm{sa}}\⊗O_r=\left[m\left({\mathrm{sa}}_{O1}\right)\⊗m\left({\mathrm{sr}}_{O1}\right),m\left({\mathrm{sa}}_{O2}\right)\⊗m\left({\mathrm{sr}}_{O2}\right),...,m\left({\mathrm{sa}}_{\mathrm{On}}\right)\⊗m\left({\mathrm{sr}}_{\mathrm{On}}\right)\right],$

其中，

定义服务簇匹配矩阵：

WS_req＝(SF_req,I_req,O_req)是一个服务请求；

SCNU_a＝(SE_a,t_Ca,I_Cta,O_Cta,F_Cta,M_a)是一个服务簇网元；

服务簇的输入/输出匹配矩阵被定义为：

$C_I={[m_{I1},m_{I2},m_{I3},...,m_{\mathrm{Iw}}]}^T=I_{\mathrm{req}}\⊗I_{\mathrm{CSa}}={[I_{\mathrm{req}}\⊗I_{s1},I_{\mathrm{req}}\⊗I_{s2},...,I_{\mathrm{req}}\⊗I_{\mathrm{sw}}]}^T=\left[\begin{array}{cccc}{m}_1\left(s_{I1}\right)& m_1\left(s_{I2}\right)& \·\·\·& m_1\left(s_{\mathrm{In}}\right)\\ m_2\left(s_{I1}\right)& m_2\left(s_{I2}\right)& \·\·\·& m_2\left(s_{\mathrm{In}}\right)\\ \·& \·& & \·\\ \·& \·& & \·\\ \·& \·& & \·\\ m_w\left(s_{I1}\right)& m_w\left(s_{I2}\right)& \·\·\·& m_w\left(s_{\mathrm{In}}\right)\end{array}\right],$

且 $C_O={[m_{O1},m_{O2},m_{O3},...,m_{\mathrm{Ow}}]}^T={[O_{s1}\⊗O_{\mathrm{req}},O_{s2}\⊗O_{\mathrm{req}},...,O_{\mathrm{sw}}\⊗O_{\mathrm{req}}]}^T=\left[\begin{array}{cccc}{m}_1\left(s_{O1}\right)& m_1\left(s_{O2}\right)& \·\·\·& m_1\left(s_{\mathrm{On}}\right)\\ m_2\left(s_{O1}\right)& m_2\left(s_{O2}\right)& \·\·\·& m_2\left(s_{\mathrm{On}}\right)\\ \·& \·& & \·\\ \·& \·& & \·\\ \·& \·& & \·\\ m_w\left(s_{O1}\right)& m_w\left(s_{O2}\right)& \·\·\·& m_w\left(s_{\mathrm{On}}\right)\end{array}\right],$

其中，m_k(s_I(O)j)＝0，1；

C_I和C_O代表了服务簇中的服务匹配服务请求的标识；

输入服务簇网元SCNU＝(SU,t_C,I_C,O_C,F_C,M_C)和服务簇匹配矩阵C_I，C_O；其中， 服务输入、输出参数的个数分别为k，l；输出服务集合B；

则服务串行组合的过程如下：

S1:依次匹配服务的输入、输出参数的参数语义；

S2:若存在I_Ci.concept＝O_Cj.concept，依次匹配C_I(i)；

S3:若C_I ^p(i)＝0，以C_I的首行开始，依次匹配该行的每个值；

S4:若C_I ^q＝[1,1,…,1]，匹配相应的C_O ^q；

S5:若C_O ^q(j)＝1且C_O ^q∪C_O ^p＝[1,1,…,1],则B＝B∪{ws_q}，循环这一过程；

S6:若输出“没有满足条件的串行服务组合”；

S7:输出服务集合B；

SCM表示服务的基集合，通过SCM的过程体现服务簇中服务间的共性与个性，从而用SCM来发现单一替代服务和组合替代服务；

输入服务簇SC＝{ws₁,ws₂,…,ws_n}和服务簇匹配矩阵C_I、C_O，SCM的过程如下：

S1:依次匹配m_Ij，若m_Ij≠[1,1,…,1]，则SCM_j标记为Φ；

S2:匹配m_Ok，若m_Ok＝[1,1,…,1]，SCM_k标记为0；

S3:若m_Ok≠[1,1,…,1],找到所有不为Φ的SCM_p且若则

S4:若A＝Φ，则SCM_k＝Φ；

S5:否则标记SCM_k为A的基集合；

S6:若在所有的SCM中有一列全为1，在所有SCM中删掉这一列；

S7:输出SCM；

定义SCM_km代表SCMk的第m个元素；s_kml是SCM_km的第l列，

定义组合规则：

SC＝{ws₁,ws₂,...,ws_n}是一个服务簇；其中，

SCM_k⊥SCM_p＝SCM_k1⊥SCM_p1⊥SCM_k2⊥SCM_p2⊥…⊥SCM_kn⊥SCM_pn，

其中，SCM_km⊥SCM_pm＝[s₁,s₂,…,s_q]且

输入SC＝{ws₁,ws₂,...,ws_n}和失效服务ws_m，输出替换服务集合A；

则发现单一服务和组合服务的服务替换的过程如下：

S0:A＝Φ；

S1:若失效服务的SCM_m＝Φ或SCM_m＝0；

S1.1:匹配SCM，若则将服务ws_k并入集合A中，A＝A∪{ws_k}；

S1.2:若匹配存在SCM_i，SCM_k，SCM_i⊥SCM_k＝0，则将ws_i和ws_k的组合并入集合A中，即A＝A∪{ws_i◇ws_k}；

S2:否则，若失效服务的SCM_m≠Φ且SCM_m≠0；

S2.1:如果匹配SCM_k＝0，则将服务ws_k并入集合A中，A＝A∪{ws_k}；

S2.2:若匹配存在SCM_kj∈SCM_k,SCM_mh∈SCM_m，且SCM_kj≤SCM_mh，则将服务ws_k并入集合A中，A＝A∪{ws_k}；

S2.3:如果匹配SCM_i，SCM_k,SCM_i⊥SCM_k＝0，则将ws_i和ws_k的组合并入集合A中，A＝A∪{ws_i◇ws_k}；

S3:若A＝Φ；

S3.1:若SCM_m中存在某一列的值为1，而其他服务的在该列的值都不为1，则将这一列在所有的SCM中移除，转到S2；

S3.2:否则，输出“没有满足条件的替换服务”；

S4:输出A，即为满足条件的替换服务集合。

本发明具有如下优点：

(1)本发明借助已有的服务聚簇方法构建服务簇，并基于Petri网提出服务及服务簇的形式化描述方法；将服务的输入输出参数抽象表示，通过参数矩阵来描述服务的输入输出参数；

(2)本发明提出的服务匹配方法使服务簇中的服务间能够充分共性与个性，通过缩小服务查找范围，从而提高服务发现与组合效率；通过对服务簇模型的改进，提出Web服务组合替换方法；对服务簇内服务的并行组合与串行组合分别进行了描述，在服务簇内实现快速服务组合，进而实现高效率的服务组合替换；

(3)本发明提出的服务簇的服务替换方法，不仅能够实现服务簇内单一服务替换,而且能够实现服务簇内服务组合替换。

附图说明

图1为一个简单的Petri网模型示意图；

图2为一个火车票查询服务网元模型示意图；

图3为火车票查询服务网元示意图；

图4为一个火车票查询的服务簇网元示意图；

图5为查询服务簇的服务簇网元模型示意图；

图6为服务簇的输入输出匹配矩阵匹配示意图；

图7为本发明实验中Web服务发现时间比较示意图；

图8为本发明实验中单一服务替换的比较示意图；

图9为本发明实验中组合服务替换的比较示意图。

具体实施方式

下面结合附图以及具体实施方式对本发明作进一步详细说明：

基于服务簇的服务组合与替换方法，包括如下步骤：

1构建Web服务和服务簇的形式化模型

1.1相关技术描述

定义是一个自然数集合，即而设定且

定义Petri网：

一个Petri网表示为一个四元组PN＝(S,T；F,M0)，其中，

(1)S是一个有限库所集；

(2)T是一个有限变迁集，且

(3)是一个弧集；

(4)dom(F)∪cod(F)＝S∪T，其中，

$\mathrm{dom}\left(F\right)=\{x\∈S\∪T|\∃y\∈S\∪T:(x,y)\∈F\},\mathrm{cod}\left(F\right)=\{y\∈S\∪T|\∃x\∈S\∪T:(x,y)\∈F\};$

(5)M:为网PN的一个标识，其中，

M(s)表示标识M下库所s中的托肯数，M₀是初始标识。

定义输入/输出集：

设PN＝(S,T；F,M₀)为一个Petri网，x∈S∪T为网N的一个元素，记

^·x＝{y|y∈S∪T∧(y,x)∈F}称为x的输入集；

x^·＝{y|y∈S∪T∧(x,y)∈F}称为x的输出集；

^·x∪x^·称为元素x的外延。

在Petri网中，通常用一个圆圈表示一个库所，用一个矩形表示一个变迁。若(x,y)∈F，则x到y的一条有向边表示它们的流关系。

如图1给出了一个简单的Petri网模型。

在图1中，有限库所集S＝{s₁,s₂,s₃,s₄}；

有限变迁集T＝{t₁,t₂,t₃,t₄}；

弧集F＝{(s₁,t₂),(s₂,t₁),(s₂,t₄),(s₃,t₃),(s₃,t₄),(s₄,t₃),(t₁,s₁),(t₂,s₂),(t₂,s₃),(t₃,s₁),(t₄,s₄)}；

初始标识M₀＝(1,0,0,0)；

对于库所s₁，它的前集为^·s₁＝{t₁,t₃}，后集为s₁ ^·＝{t₂}；

对于变迁t₂的前集和后集分别为^·t₂＝{s₁}，t₂ ^·＝{s₂,s₃}。

定义引发规则：

设PN＝(S,T；F,M₀)为一个Petri网，则其具有如下的变迁发生规则：

1)对于变迁t∈T，如果则变迁t在标识M有发生权，记为M[t＞；

2)如果M[t＞，则在标识M下，变迁t能够发生，从标识M发生变迁t得到一个新的标识M′(记为M[t＞M′)，

本体(Ontology)是一种起源于哲学领域的概念，主要研究存在本质的哲学问题，上世纪90年代被用于计算机领域。

1997年，W.N.Borst对Guarino的理论进行了扩充，进而把本体定义为“对共享概念模型的形式化的明确说明”，得到广泛的认可。其中体现了四层含义：

(1)概念模型：通过抽象出客观世界中一些现象的相关概念所得的模型；

(2)明确：所使用的概念以及使用此概念的约束都有明确定义；

(3)形式化：是计算机可读的；

(4)共享：体现的是共同认可的知识，反映的是相关领域中公认的概念集合。

领域本体是依据领域来表述特定领域的静态知识。

领域本体通过对特定领域内的概念及概念见的关系的精确描述，成为人机之间、机器和机器之间相互理解的语义基础。

领域本体由对象、对象的属性、对象之间的关系及子领域本体构成，故领域实体对象和实体间的关系都是独立的知识单元，能够把领域本体形式化表示成一个有向无循环图，图中的结点表示概念或单个对象，有向边表示概念之间的关系或关联。现有技术文献基于领域本体的概念，构建了一个层次语义知识库，并提出了一种服务相似度的计算方法：

$\mathrm{Sim}({\mathrm{SF}}_i,{\mathrm{SF}}_j)=e^{-\mathrm{\αl}}\·\frac{e^{\mathrm{\βh}}-e^{-\mathrm{\βh}}}{e^{\mathrm{\βh}}+e^{-\mathrm{\βh}}};$

式中，SF_i,SF_j代表服务ws_i和ws_j的服务功能语义描述；

l是层次语义网中SF_i和SF_j之间的最短路径；

h是在层次语义网中的深度；

α,β是两个参数，择优选择为：α＝0.2andβ＝0.6。

1.2 Web服务

根据上述1.1对于Petri网的概念，构建服务的形式化模型如下：

定义Web服务：

一个Web服务描述为一个四元组WS＝(SF,I,O)，其中：

(1)SF表示服务的功能语义描述；

(2)I、O表示服务的输入、输出参数集，并且

其中，P.name是输入、输出参数名；P.concept是一个输入、输出参数的本体概念，用以表示参数的语义；

定义服务请求：

一个服务请求表示为R＝(SF_r,I_r,O_r)，其中：

(1)SF_r表示服务请求的功能语义描述；

(2)I_r代表服务请求者可提供的输入参数集；

(3)O_r代表服务请求者需要输出的参数集。

定义服务网元：

服务WS＝(SF,I,O)的服务网元定义为SNU＝(t,I_t,O_t,F_t,M)，其中：

(1)t是一个能够完成服务功能的变迁；

(2)I_t＝^·t＝{s_i1,s_i2,s_i3,…,s_in}是变迁t的输入集，代表服务的输入参数集合；O_t＝t^·＝{s_o1,s_o2,s_o3,…,s_on}代表服务的输出参数集合；

(3)F_t＝(I_t×t)∪(t×O_t)是有向弧集合，表示服务的输入、输出参数的流关系；

(4)M是服务网元的标识，M：I_t∪O_t→{0,1}；

(5)变迁t在M下的发生规则为：

(a)则变迁t在M下有发生权，记为M[t>；

(b)若M[t>，则t在标识M下能够发生并得到一个新的标识，记作M[t>M′，对于

$M^{,}\left(p\right)=\left\{\begin{array}{c}M\left(p\right)+1,p\∈O_t-I_t\\ M\left(p\right)-1,p\∈I_t-O_t\mathrm{andM}\left(p\right)=1\\ M\left(p\right),\mathrm{else}\end{array}\right.$

利用服务网元来表示服务，能够有效地将服务的输入输出参数数量化。为了方便模型表示，本发明将服务的输入、输出参数名作为变迁的输入、输出库所名。

例如：一个火车篇查询服务：

WS_tis＝(SF_tis,I_tis,O_tis)；其中，I_tis＝{(i₁,Departure),(i₂,Arrival),(i₃,Date),(i₄,ID)}，并且O_tis＝{(o₁,price),(o₂,Train No),(o₃,time)}。“Departure”,“Arrival”,“Date”,“ID”,“price”,“TrainNo”和“time”分别代表出发地，目的地，日期，身份信息，票价，列车号和出发时间。

根据服务网元的定义，该服务经过模型化后如图2所示。

1.3 服务簇

本发明用基于本体计算服务功能相似度来聚簇。由于本发明主要是在服务聚簇的基础上进行，因此只对服务聚簇进行简单的介绍。

本发明基于现有技术中服务相似度计算方法来确定语义相似，若Sim(X,Y)>＝0.8，则认为概念X与概念Y是语义相似的。

有了上述语义相似的理论基础，根据服务功能的语义相似度将服务聚簇，形成服务簇，下面给出服务簇的定义。

定义服务簇：

对于n个服务：ws₁,ws₂,...，SC＝{ws₁,ws₂,...,ws_n}是一个服务簇，其中：

ws_u＝(SF_u,I_u,O_u,SCM_u)，且SF_u和SF_v满足语义相似。

为了高效的发现和替换服务，服务簇需要模型化。根据服务网元模型的构建方式，将服务的参数数字化，同样，将服务簇中的参数数字化。

由于一个服务簇中的参数较多，本发明引入参数矩阵来表示服务簇的参数。

定义服务簇网元：

一个有n个服务的服务簇：SNU_k＝(t_k,I_tk,O_tk,F_tk,M_k)，服务簇网元被表示为SCNU＝(SU,t_C,I_C,O_C,F_C,M_C)，其中：

(1)SU＝{SNU₁,SNU₂,SNU₃,…,SNU_n}是服务网元的集合；

(2)t_C是服务簇网元的变迁，它能够完成服务簇中各服务的功能；

(3)I_C、O_C表示服务的输入、输出参数集，并且其中：

(a)P.concept是服务簇中服务输入参数对应的语义概念；

(b)P.lable是一个n×1的矩阵，其中n是服务簇中服务的个数，并且P.lable是服务簇中的服务相应P.concept的值；

(4)F_C＝(I_Ct×t_C)∪(t_C×O_Ct)表示服务簇输入、输出参数的流关系；

(5)M_C是服务簇网元的标识；

根据服务簇网元的定义，将一个服务的输入参数值，作为服务簇输入矩阵的一行；将该服务的输出参数值，作为服务簇输出参数矩阵的对应行。

例如：一个火车票查询服务簇包括四个服务：ws₁–ws₄，服务网元模型如图3所示。根据服务网元和服务簇网元的定义，构建出该服务簇的服务簇网元模型如图4所示。

在图4中，I_C和O_C用两个矩阵表示，在下文中分别称这两个矩阵为输入矩阵和输出矩阵。在服务簇中，服务的输入、输出参数被编号。

在输入矩阵中，表示为“1”的，是对应的服务发生时所需要的参数。

在输出矩阵中，表示为“1”的，是对应的服务发生后能够输出的参数。

在输入输出矩阵中，每一行代表一个服务的输入输出参数值，而每一列，代表服务簇中所有服务相应于某一参数的参数值。

2、基于服务簇的服务发现组合与替换分析

服务簇网元模型的建立能够提高服务的查找替换效率。

在服务发现与组合阶段能够快速地筛选与服务请求功能不匹配的服务，进而缩小替换服务的范围，使得服务发现与组合效率大大提高。

下面本发明将提出一种基于服务簇的服务发现与组合算法，更进一步提高效率。

2.1服务发现

在服务发现之前，对服务簇中的服务进行预处理能够有效的减少服务的查找范围，提高服务发现效率。良好的服务匹配算法可以快速排除与服务请求不匹配的服务，然后通过服务发现算法发现服务簇中满足服务请求的服务。

2.11服务匹配算法

在服务发现的过程中，首先需要通过服务匹配服务请求。服务匹配方法在提高服务发现效率方面是至关重要的。因此，本发明首先给出一个服务匹配算法。

在下述算法中，服务簇k的服务总数为m个，输入参数的总数为n_i个，输出参数总数为n_o个。I_Ck,O_Ck,i_r和o_r都分别代表服务簇的输入矩阵，输出矩阵，服务请求的输入矩阵和输出矩阵。I_Ck是一个m×n_i矩阵，Ou_k是一个m×n_o矩阵，i_r是一个1×n_i矩阵，o_r是一个1×n_o矩阵。I_Ck ^p(q)代表输入矩阵的第p行第q列的值。

算法1服务匹配算法：

输入：一个服务簇网元模型SCNU_k＝(SU_k,t_Ck,I_Ck,O_Ck,F_Ck,M_Ck)，一个服务请求网元s_r＝{sf_r,i_r,o_r}；

输出：C_I和C_O,其中，C_I是一个m×n_i矩阵，并且C_O是一个m×n_o矩阵；

S1:以I_Ck的首行开始，依次匹配该行的每个值；

S2:若该行中元素的值小于或者等于i_r对应的值，则标记C_I对应位置的值为1；

S3:否则，标记为0；

S4:以O_Ck的首行开始，依次匹配该行的每个值；

S5:若该行中元素的值大于或者等于i_r对应的值，则标记C_I对应位置的值为1；

S6:否则，标记为0；

S7:输出矩阵C_I和矩阵C_O；

算法1是一种基于服务簇的服务匹配算法，其时间复杂度是m×n_i ²+m×n_o ²。矩阵C_I被称之为输入匹配矩阵，矩阵C_O称之为输出匹配矩阵。C_I ^p1(q₁)＝1表示服务ws_p1可以满足第q₁个参数需求。B^p2(q₂)＝1表示服务ws_p2可以满足第q₂个参数需求。

通过算法1的服务匹配算法，服务簇输入/输出匹配矩阵将服务簇中的服务按照当前服务请求统一表示服务匹配结果。服务输入/输出匹配矩阵中“1”代表对应的服务输入/输出参数可以满足当前服务请求；而服务输入/输出矩阵中“0”代表对应的服务输入/输出参数不能满足当前服务请求。根据这一特点，可以为实现服务发现效率的提高奠定坚实的基础。

算法1的提出可以将服务簇中的服务按照当前服务请求，给出统一的标记。这可以为服务发现算法的提出奠定坚实的基础。根据算法1，下面给出服务发现的匹配定理。

定理1：

服务需求R_eq＝(SF_req,I_req,O_req)，服务WS_b＝(SF_b,I_b,O_b)，服务网元SNU_b＝(t_b,I_tb,O_tb,F_tb,M_b)。矩阵C_I和矩阵C_O分别是服务WS_b相对于服务请求R_eq的输入匹配矩阵和输出匹配矩阵。如果且则服务WS_b可以满足服务输出请求R_eq。

证明：根据服务匹配算法，C_I ^p1(q₁)＝1意味着服务ws_p1可以满足第q₁个参数需求。C_O ^p2(q₂)＝1意味着服务ws_p2可以满足第q₂个参数需求。

进一步说，表示服务ws_b可以满足服务输入请求I_req的每个参数需求；表示服务ws_b可以满足服务输出请求O_req的每个参数需求。

故，如果且则服务WS_b可以满足服务输出请求R_eq，证毕。

2.12 服务发现算法

算法1通过参数矩阵的匹配实现服务簇内快速筛选，从而更一进步缩小服务查找范围。定理1为服务发现算法提供了有力的理论依据。

算法2服务发现算法

输入：输入匹配矩阵C_I、输出匹配矩阵C_O；

输出：S:一个服务集合；

S1:p＝1,

S2:以C_I的第p行开始，依次匹配该行的每个值；

S3:若该行中所有的值都为1，则跳到S5；

S4:否则p＝p+1，循环这一匹配过程；

S5:依次匹配C_O第p行的各值；

S6:若该行中所有的值都为1，则将该服务合并入集合S中，即S＝S∪{ws_p}；

S7:否则p＝p+1，跳到S2；

S8输出S.

通过算法2可以发现服务簇中满足服务请求的服务。算法2输出的服务集合S中，所有服务的输入输出匹配矩阵同为这意味着集合S中的每个服务都可以满足服务请求。服务发现算法的时间复杂度为：m×n_i+m×n。

例如：一个服务请求R_eq＝(SF_req,I_req,O_req),其中I_req＝[1,0,1,0,0,1],O_req＝[0,1,0,0,1,1],服务簇SCNU_k＝(SU_k,t_Ck,I_Ck,O_Ck,F_Ck,M_Ck)中有两个服务WS₁，WS₂。WS_i＝(SF_i,I_i,O_i),i＝1,2。其中I₁＝[1,0,0,1,0,1]，O₁＝[1,1,0,0,1,1]，I₂＝[1,1,1,0,0,1]，O₂＝[0,1,1,0,1,1]。

根据算法1得到服务簇内服务的预处理结果：C_I1＝[1,1,1,0,1,1]，C_I2＝[1,1,1,1,1,1]，并且C_O2＝[1,1,1,1,1,1]，根据算法2得出服务WS₂可以满足服务请求R_eq。

2.2 服务组合

上述算法2可以在海量服务中，完成单个服务的服务发现。

当服务组合体系中，单个服务失效时，可以利用算法2的方法进行服务发现及替换。而在服务簇中，单个的服务可能不能满足服务请求，需要通过多个服务的组合来满足服务请求。

当构成服务组合体系的单个或多个服务失效时，为了提高效率，将损失降到最低，将服务组合模式保持不变。

在服务簇中，选择与其功能相似且参数匹配的服务或服务组合将失效服务替换。其中，服务簇中两个服务的组合包括服务的并行组合和串行组合。

3.21 服务并行组合

基于上述内容，本发明首先对服务并行组合的方法进行描述。

算法1中A^p1(q₁)＝0代表服务ws_p1的输入参数q₁不能满足服务输入请求。换句话说，在当前的服务请求条件下，服务ws_p1不能发生。在服务组合发现的过程中，服务簇中的这些服务可以不予考虑。在下文中，ws_i◇ws_j表示服务ws_i和服务ws_j的并行组合。ws_i|ws_j表示服务ws_i和服务ws_j的串行组合。

本发明提出一种新的概念，用于后文中对服务组合过程的描述。

设α＝[b₁,b₂,…,b_k]是一个1×k矩阵，其中且对于如果b_i＝1,α可以表示为E,即,E＝[1,…,1].对于若b_i＝0,α可以表示为0,即,0＝[0,0,…,0]。

在本发明中，α表示Petri网中的一个标识。并且α₁≥α₂表示b_1i≥b_2i。

定义基元素：

设α₁＝[b₁₁,b₁₂,…,b_1k]且α₂＝[b₂₁,b₂₂,…,b_2k]是两个1×k矩阵，其中 若α₁≥α₂,则称α₂是α₁的一个基元素。

定义基集合：

设C是一个1×k矩阵的集合。如果或者α_q是α_p的一个基元素，且则称C’是C的一个基集合。

在服务簇中，任何服务都是没有编号的，为了标记服务簇中的服务，本发明提出一种独特的方法。

定义服务组合标志(Service Composition Marking,SCM)：

用于标记当前服务请求下的服务组合的服务基集合，其初始标志为

在服务簇中，通过服务与当前服务请求的匹配结果，可以发现服务间的组合关系。根据算法1可以提出服务匹配的运算方法。

定义匹配运算：

SNU_a＝(t_a,I_ta,O_ta,F_ta,M_a)是一个服务网元，R＝(SF_r,I_r,O_r)是一个服务请求。

匹配运算被定义为：

$\left(1\right)I_r\⊗I_{\mathrm{sa}}=\left[m\left({\mathrm{sr}}_{I1}\right)\⊗m\left({\mathrm{sa}}_{I1}\right),m\left({\mathrm{sr}}_{I2}\right)\⊗m\left({\mathrm{sa}}_{I2}\right),...,m\left({\mathrm{sr}}_{\mathrm{In}}\right)\⊗m\left({\mathrm{sa}}_{\mathrm{In}}\right)\right],$ 其中，

$\left(2\right)O_{\mathrm{sa}}\⊗O_r=\left[m\left({\mathrm{sa}}_{O1}\right)\⊗m\left({\mathrm{sr}}_{O1}\right),m\left({\mathrm{sa}}_{O2}\right)\⊗m\left({\mathrm{sr}}_{O2}\right),...,m\left({\mathrm{sa}}_{\mathrm{On}}\right)\⊗m\left({\mathrm{sr}}_{\mathrm{On}}\right)\right],$ 其中

从上述定义可以看出，当单个服务满足服务请求，意味着服务输入请求可以引发服务变迁，并且服务输出标志可以满足服务请求。由定理1可以提出一个新的定理如下：

定理2：

R_eq＝(SF_req,I_req,O_req)是一个服务请求，SNU_b＝(t_b,I_tb,O_tb,F_tb,M_b)是WS_b的一个服务网元，如果且则WS_b满足服务请求R_eq。

证明：由于 $I_{\mathrm{req}}\⊗I_{\mathrm{sb}}=E$ 且 $O_{\mathrm{sb}}\⊗O_{\mathrm{req}}=E,$ 根据匹配运算定义， 根据服务网元的定义，t_b可以被引发，并且O_b可以满足O_req。因此服务WS_b满足服务请求R_eq，证毕。

定义服务簇匹配矩阵：

WS_req＝(SF_req,I_req,O_req)是一个服务请求。SCNU_a＝(SE_a,t_Ca,I_Cta,O_Cta,F_Cta,M_a)是一个服务簇网元。服务簇的输入/输出匹配矩阵被定义为：

$C_I={[m_{I1},m_{I2},m_{I3},...,m_{\mathrm{Iw}}]}^T=I_{\mathrm{req}}\⊗I_{\mathrm{CSa}}={[I_{\mathrm{req}}\⊗I_{s1},I_{\mathrm{req}}\⊗I_{s2},...,I_{\mathrm{req}}\⊗I_{\mathrm{sw}}]}^T=\left[\begin{array}{cccc}{m}_1\left(s_{I1}\right)& m_1\left(s_{I2}\right)& \·\·\·& m_1\left(s_{\mathrm{In}}\right)\\ m_2\left(s_{I1}\right)& m_2\left(s_{I2}\right)& \·\·\·& m_2\left(s_{\mathrm{In}}\right)\\ \·& \·& & \·\\ \·& \·& & \·\\ \·& \·& & \·\\ m_w\left(s_{I1}\right)& m_w\left(s_{I2}\right)& \·\·\·& m_w\left(s_{\mathrm{In}}\right)\end{array}\right],$

且 $C_O={[m_{O1},m_{O2},m_{O3},...,m_{\mathrm{Ow}}]}^T={[O_{s1}\⊗O_{\mathrm{req}},O_{s2}\⊗O_{\mathrm{req}},...,O_{\mathrm{sw}}\⊗O_{\mathrm{req}}]}^T=\left[\begin{array}{cccc}{m}_1\left(s_{O1}\right)& m_1\left(s_{O2}\right)& \·\·\·& m_1\left(s_{\mathrm{On}}\right)\\ m_2\left(s_{O1}\right)& m_2\left(s_{O2}\right)& \·\·\·& m_2\left(s_{\mathrm{On}}\right)\\ \·& \·& & \·\\ \·& \·& & \·\\ \·& \·& & \·\\ m_w\left(s_{O1}\right)& m_w\left(s_{O2}\right)& \·\·\·& m_w\left(s_{\mathrm{On}}\right)\end{array}\right],$

其中，m_k(s_I(O)j)＝0，1。

C_I和C_O代表了服务簇中的服务匹配服务请求的标识。根据算法2，满足服务请求的单个服务可以被发现。然而在服务簇中，单个服务可以不能满足服务请求，而多个服务的组合可能会满足服务请求。因此，下面提出服务组合定理。在下文中，ws_i◇ws_j表示服务ws_i和服务ws_j的服务组合。

定理3：

C_I＝[m_I1,m_I2,m_I3,…,m_In]^T(C_O＝[m_O1,m_O2,m_O3,…,m_On]^T)是服务簇的输入/输出匹配矩阵，其中m_Ij＝[m_j(s_I1),m_j(s_I2),…,m_j(s_Ik)]且m_Oj＝[m_j(s_O1),m_j(s_O2),…,m_j(s_Ok)],若服务组合ws_i◇ws_j可以满足服务请求的充分条件是：

(1)m_Ij＝E且m_Ii＝E；

$\left(2\right)m_{\mathrm{Oi}}\⊕m_{\mathrm{Oj}}=E,\mathrm{where}{m}_{\mathrm{Oj}}\⊕m_{\mathrm{Oi}}=[m_j\left(s_{O1}\right)\⊕m_i\left(s_{O1}\right),m_j\left(s_{O2}\right)\⊕m_i\left(s_{O2}\right),...,m_j\left(s_{\mathrm{Ok}}\right)\⊕m_i\left(s_{\mathrm{Ok}}\right)]$ and

证明：(1)对于m_Ii＝E，根据服务簇匹配矩阵定义，从匹配运算定义可以看出m(sr_Il)>m(si_Il)。因此服务ws_i的输入参数都可以满足服务输入请求，服务簇中的服务ws_i可以发生。相似地，由于m_Ij＝E，可以得出，服务ws_j的输入参数同样都可以满足服务输入请求的所有参数，服务簇中的服务ws_j也有发生权。所以，服务组合ws_i◇ws_j，在当前服务输入请求的条件下，满足发生条件。

(2)因为所以m_j(s_Op)＝1 or m_i(s_Op)＝1.根据服务簇匹配矩阵定义，服务请求的所有输出参数都可以由服务ws_i或ws_j满足。故， 因此，根据服务匹配算法，服务组合ws_i◇ws_j的输出参数可以与服务输出请求参数相匹配。从而，服务组合ws_i◇ws_j可以满足服务的输出请求。综上所述，服务组合ws_i◇ws_j可以满足服务的输入请求，证毕。

3.22服务串行组合

由于本发明中的服务簇是以服务功能相似度来聚簇，所以从服务功能参数上说，当服务簇内发生服务失效时，并行组合替换的成功率相比串行组合更大一些。在服务簇粒度足够小的情况下，串行组合服务替换可以忽略，不予考虑。本发明中的服务簇粒度足够小，串行组合发生率较低，所以，本发明只给出简要的算法思想。在下文中，ws_p||ws_q表示服务ws_p和服务ws_q的串行组合。

定理4：

SCNU＝(SU,t_C,I_C,O_C,F_C,M_C)为一个服务簇网元，其中， 服务输入、输出参数的个数分别为k，l。服务请求R＝(SF_r,I_r,O_r)，服务簇匹配矩阵:C_I，C_O。若C_I ^p≠[1,1,…,1]，且C_I ^p(i)＝0时，ws_q同时满足下面两个条件：

(1)I_Ci.concept＝O_Cj.concept，且C_O ^q(j)＝1；

(2)C_I ^q＝[1,1,…,1]；

则ws_q||ws_p可以满足服务请求R。

证明：因为C_I ^p≠[1,1,…,1]，根据定理1，服务ws_p满足服务输入请求。且根据服务网元定义，时，服务ws_p才能引发。当I_Ci.concept＝O_Cj.concept时，则服务簇中存在输入请求与输出请求语义相同。若C_O ^q(j)＝1则服务ws_p的输出请求可以满足ws_p的输入请求。而C_I ^q＝[1,1,…,1]，根据服务网元定义，服务ws_q可以满足当前服务请求，可以引发。故可以通过先引发ws_q后引发ws_p，来满足服务请求。

综合上述，ws_q||ws_p可以满足服务请求R。

定理4的提出对服务的串行组合提供了理论依据。由定理4可知要想服务簇内发生串行组合，服务簇必须有相同的输入输出语义参数，而这可能需要服务的粒度足够大。根据定理4，下面提出服务串行组合算法：

算法3服务串行组合算法

输入：服务簇网元SCNU＝(SU,t_C,I_C,O_C,F_C,M_C)，其中， 服务簇匹配矩阵:C_I，C_O，服务输入、输出参数的个数分别为k，l。

输出：服务集合B；

S1:依次匹配服务的输入、输出参数的参数语义；

S2:若存在I_Ci.concept＝O_Cj.concept，依次匹配C_I(i)；

S3:若C_I ^p(i)＝0，以C_I的首行开始，依次匹配该行的每个值；

S4:若C_I ^q＝[1,1,…,1]，匹配相应的C_O ^q；

S5:若C_O ^q(j)＝1且C_O ^q∪C_O ^p＝[1,1,…,1],则B＝B∪{ws_q}，循环这一过程；

S6:若输出“没有满足条件的串行服务组合”；

S7:输出集合B。

算法3是在服务簇中查找能与ws_q串行组合的服务，集合B为满足条件的服务集合。

2.3服务替换

服务簇的提出可以大大缩小查找服务的范围，提高查找效率。在同一个服务簇中，体现各个服务共性的同时，需要发现服务的个性，从而快速发现替换服务。因此，需要有一种标记服务的方法。SCM表示了服务的基集合，用SCM来发现单一替代服务和组合替代服务。下面给出SCM的算法。

算法4 服务组合标识算法

输入：服务簇SC＝{ws₁,ws₂,…,ws_n}，服务簇匹配矩阵:C_I，C_O；

输出：SCM

S1:依次匹配m_Ij，若m_Ij≠[1,1,…,1],则SCM_j标记为Φ；

S2:匹配m_Ok，若m_Ok＝[1,1,…,1],SCM_k标记为0；

S3:若m_Ok≠[1,1,…,1],找到所有不为Φ的SCM_p且若则

S4:若A＝Φ,则SCM_k＝Φ；

S5:否则标记SCM_k为A的基集合；

S6:若在所有的SCM中有一列全为“1”,在所有SCM中删掉这一列；

S7:输出SCM。

根据算法4，基于服务簇网元模型可以得到SCM的值。SCM＝Φ代表当前服务簇中没有服务可以满足服务请求。SCM＝0代表单个服务可以满足服务请求。而，如果SCM_k是一个集合，SCM_k中的每个元素都代表着一个或者一组服务，在这组服务中的每一个服务都可以通过与ws_k组合满足当前服务请求。

在服务请求参数中，考虑范围内所有服务都可以满足的请求参数可以人为是可忽略参数。在服务簇输入、输出匹配矩阵中，可忽略参数所对应的那一列，可以认为是可忽略列。

SCM可以将服务簇中的服务分类。若SCM＝Φ，在服务替换过程中，相应的服务可以不必考虑。然而，通常情况下，SCM为一个集合。在这种情况下，不能快速发现对应的组合服务。为了解决这个问题，在算法4中，将SCM中的可忽略列删除。从而方便通过SCM来快速发现可替换的组合服务。

利用SCM发现组合服务时，需要提出一种组合规则。在下文中，SCM_km代表SCMk的第m个元素。s_kml是SCM_km的第l列，一种组合规则被定义如下。

定义组合规则(Composition Rule)：SC＝{ws₁,ws₂,...,ws_n}是一个服务簇；其中， SCM_k⊥SCM_p＝SCM_k1⊥SCM_p1⊥SCM_k2⊥SCM_p2⊥…⊥SCM_kn⊥SCM_pn，其中，SCM_km⊥SCM_pm＝[s₁,s₂,…,s_q]且

根据组合规则定义，可以通过SCM.快速发现可替换的组合服务。为了更好的证实这一结论，下面给出两个定理。

定理5：

假设服务簇SC＝{ws₁,ws₂,...,ws_n}中存在一个失效服务ws_m，R＝(SF_r,I_r,O_r)是服务请求。若ws_k是ws_m的一个替换服务，则ws_k满足下面条件之一：

(1)SCM_k＝0；

(2)SCM_mi，SCM_kj≤SCM_mi,且

证明：(1)若SCM_k＝0，根据服务组合标识算法，可知m_Ik＝E且m_Ok＝E。根据匹配运算定义，根据定理2，可以得出ws_k是ws_m的一个替换服务。

(2)若且SCM_mi∈SCM_m,SCM_kj＝SCM_mi，根据算法4，有一组服务与SCM_kj相关，当然也与SCM_mi相关。假设与SCM_mi相关的服务为ws_g，通过算法4可知，m_Im＝E,m_Ig＝Eand由定理3可以得出ws_g◇ws_m可以满足服务请求R。相似地，ws_g也是与SCM_kj相关的服务，同样m_Ik＝E,m_Ig＝E and因此，服务ws_k是服务ws_m的一个替换服务。

若且SCM_mi∈SCM_m,SCM_kj<SCM_mi，根据服务组合标识算法可知，SCM_k是A的一个基集合。由基元素定义可知，SCM_kj是SCM_mi的一个基元素。假设与SCM_mi相关的一个服务是ws_g，根据定理3可以得到,ws_g◇ws_m可以满足服务请求R。通过算法4可以看出，服务ws_g同样与SCM_kj相关。相似地，ws_g◇ws_k也可以满足服务请求。因此，ws_k是ws_m的一个替换服务。

根据定理5可以发现替换服务，而在服务簇中，组合服务也可替换失效服务。为了发现组合替换服务，可以提出下面定理。

定理6：

一个服务簇SC＝{ws₁,ws₂,...,ws_n}，其中，服务簇中存在一个失效服务ws_m，如果SCM_p⊥SCM_q＝0,则ws_p◇ws_q是ws_m的一个替换服务组合,且

证明：因为SCM_p⊥SCM_q＝0，由组合规则定义首先可以看出，SCM_p≠Φand SCM_q≠Φ。通过服务组合标识算法可知，m_Ip＝E且m_Iq＝E。根据组合规则定义,s_pgl＝0或s_qhl＝0。设与s_pgl相关的那一列标号为m_p(s_Ov)，m_q(s_Ov)。则由算法4可知，m_p(s_Ov)＝1或m_q(s_Ov)＝1。根据定理3，故，ws_p◇ws_q是服务ws_m的一个替换服务组合。

有了上述算法与定理的支撑，提出一种可以发现单一服务和组合服务的服务替换算法：

算法5服务替换算法

输入：SC＝{ws₁,ws₂,...,ws_n},失效服务ws_m；

输出：一个替换服务集合A；

S0:A＝Φ；

S1:若失效服务的SCM_m＝Φ或SCM_m＝0

S1.1:匹配SCM，若则将服务ws_k并入集合A中，A＝A∪{ws_k}；

S1.2:若匹配存在SCM_i，SCM_k,SCM_i⊥SCM_k＝0,则将ws_i和ws_k的组合并入集合A中，即A＝A∪{ws_i◇ws_k}；

S2:否则，若失效服务的SCM_m≠Φ且SCM_m≠0；

S2.1:如果匹配SCM_k＝0,则将服务ws_k并入集合A中，A＝A∪{ws_k}；

S2.2:若匹配存在SCM_kj∈SCM_k,SCM_mh∈SCM_m,且SCM_kj≤SCM_mh,则将服务ws_k并入集合A中，A＝A∪{ws_k}；

S2.3:如果匹配SCM_i，SCM_k,SCM_i⊥SCM_k＝0,则将ws_i和ws_k的组合并入集合A中，A＝A∪{ws_i◇ws_k}；

S3:若A＝Φ；

S3.1:若SCM_m中存在某一列的值为“1”，而其他服务的在该列的值都不为“1”，则将这一列在所有的SCM中移除，转到S2；

S3.2:否则，输出“没有满足条件的替换服务”

S4:输出A，即为满足条件的替换服务集合。

在算法5中，首先发现单个服务是否能替换失效服务，若单个服务不能替换失效服务，考虑组合服务替换。算法5中，在最好情况下的时间复杂度，仅为n。下面通过一个实例来进一步描述这个算法。

3.4火车订票服务簇实例

现有一个火车订票系统包括3个服务簇：一个安全管理(safety detection)服务簇，一个查询(ticket inquiry)服务簇和一个订票(booking)服务簇。

它们的服务簇组合关系是：safety detection→ticket inquiry→booking。在查询服务簇中，有10个服务：ws₁,ws₂,...,ws₁₀。查询服务簇的服务簇网元模型见图5。

在查询服务簇中，现存在一个失效服务，为了确保服务簇组合模型的模式不变，服务簇必须满足一个服务请求。该服务请求为：R_inquiry＝[1 1 1 1 0]→[0 1 0 1 1 1]。

根据匹配运算定义，可以得到服务簇的输入输出匹配矩阵，如图6所示。

由输入输出匹配矩阵可以快速的发现不满足服务输入请求的服务，并予以排除缩小查询范围。

通过算法4可以得到服务簇inquiry中每个服务的SCM值，所得的结果显示如表1：

表1查询服务簇的服务组合标识

Service	SCM
		ws1	{[0 1 0 1],[1 0 0 1],[0 0 1 1]}
ws2	{[1 1 1 0],[1 0 1 1]}
		ws3	Φ
ws4	0
		ws5	Φ
ws6	{[1 1 1 0]}
		ws7	Φ
ws8	{[1 1 1 0],[0 1 0 1]}
		ws9	Φ
ws10	{[1 1 1 0]}

在表1中，每一行显示了服务簇中服务的SCM。

服务簇inquiry中的10个服务可以通过SCM被清楚地分类。如果ws₄为失效服务，服务簇中有SCM₁⊥SCM₈＝0，根据定理6，ws₈是ws₄的一个替换服务。如果ws₂失效，从表1可以看出SCM₂₁＝SCM₆₁，根据定理5，ws₆是ws₂的一个替换服务。

通过算法5，服务簇中各服务失效时，它们的替换服务可以统计为表2：

表2不同失效服务下的替换服务

Failed Service	Candidate Service
		ws1	ws8
ws2	ws6,ws8,ws10
		ws3	ws4,ws1◇ws2,ws1◇ws6,ws1◇ws8,ws1◇ws10,ws1◇ws8
ws4	ws1◇ws2,ws1◇ws6,ws1◇ws8,ws1◇ws10,ws1◇ws8
		ws5	ws1◇ws2,ws1◇ws6,ws1◇ws8,ws1◇ws10,ws1◇ws8
ws6	ws2,ws8,ws10
		ws7	ws1◇ws2,ws1◇ws6,ws1◇ws8,ws1◇ws10,ws1◇ws8
ws8	ws1,ws2,ws6,ws10
		ws9	ws1◇ws2,ws1◇ws6,ws1◇ws8,ws1◇ws10,ws1◇ws8
ws10	ws2,ws6,ws8

从表2中可以看出，服务簇中，不同的服务失效，它们的替换服务也不同，而且替换服务的数量也不相同。有的服务失效通过单一服务替换即可，而有的服务失效，单一服务无法完成替换，需要组合服务来替换。

在火车订票服务簇实例中，只演示了服务簇中单个服务失效时的情形。当服务簇中多个服务失效时，仍然可以通过算法4得到SCM，而定理5和定理6仍然适用。失效服务的替换服务扔可以通过算法5得到，在这里就不再详述。

3实验过程

本发明利用上述相关算法，并采用C#语言编写，可随机生成本体树、随机生成服务簇，并能随机选取服务模拟失效，统计每次查找时间。

设计实验平台自动生成指定数量的服务，根据本发明提出的方法模拟服务发现过程、以及单一服务替换与组合服务替换过程，并记录其响应时间。

在实验设计环节，首先对本发明提出的服务发现算法与传统的服务发现算法进行比较，从而验证本发明提出的服务发现算法的有效性。然后根据本发明的实验设计思路，对本发明提出的服务替换算法与原有的替换算法进行比较。替换算法的比较分为两个方面，一种是考虑单个服务替换效率，一种是考虑服务组合替换效率。

替换算法比较实验中，在服务的替换效率方面，对原有的服务替换算法与本发明基于服务簇的服务替换算法进行了比较分析。由于本发明提出的相关方法是基于服务簇的基础上且鉴于目前没有相关的平台和Web服务库可用，本实验结果也是在服务簇已构建的基本情况下产生。因此，实验中将采用自上而下的方式产生模拟数据。首先，采用了已提出的方法建立领域本体树。然后定义服务簇，标注服务簇的输入/输出参数，并根据服务簇产生簇内的相关服务。本发明采用C#语言编程，并进行仿真模拟实验。算法比较实验设计如下：

①构建领域本体树，生成服务簇并标注相关参数，从而自动生成簇内相关服务和产生服务参数。

②在实验中随机选取服务并模拟服务失效，对所选服务的输入输出参数进行随机指定，从而达到模拟实验的效果。

③单个服务替换查找成功时，计算响应时间仅考虑单个服务的发现时间和替换时间，如果组合服务替换查找，计算响应时间是考虑发现服务时间、组合服务时间以及替换服务时间。

④根据服务发现算法，在服务个数不同的情况下分别记录服务发现的响应时间。

⑤在本发明中，响应时间是多次实验的平均值。

⑥在实验中，服务簇中服务个数分别为100、200、...、500。为了避免偶然数据，本实验重复做100次。

3.1服务发现算法比较

首先根据本发明提出的服务发现算法与传统的服务发现算法进行比较，每次随机生成服务请求100个。与服务替换算法设计相似，分别记录服务簇中服务个数分别为100、200、...、500时的响应时间。得到的实验结果如图7所示。

图7中，横坐标为服务的数量，纵坐标为服务发现的响应时间；带有方形标记线的为本发明中服务发现算法的响应时间，带有圆形标记线的为传统的服务发现算法的响应时间。

从图7中可以得出结论：

本发明中服务发现算法的效率是明显高于传统服务发现算法的；随着服务数量的增多两种服务发现算法的效率有所下降，而相对传统的发现算法，本发明所提出的服务发现算法受服务数量的影响较小。

3.2服务替换算法比较

本实验对服务替换响应时间的比较分析分为两个实验：

实验一：对于服务的单一替换按照设计思路，对两种方法进行实验比较；

实验二：对于组合服务替换按照设计思路，对两种方法进行实验数据比较。

在本发明的实验平台中，经过多次实验，得出实验一的实验结果如图8所示。而实验二的实验结果相关数据如图9所示。

在图8中，横坐标为服务的数量，纵坐标为服务发现的响应时间；带有方形标记线的为本发明中服务替换算法的响应时间，带有圆形标记线的为传统的服务替换算法的响应时间。

在图8中可以看出，两种替换方法的响应时间随着服务数量的增多而增长。然而在响应时间的增长速率上比较，本发明中的服务替换方法的增长速率低于传统的服务替换方法。从曲线走势上看，随着服务数量的增多，两条曲线之间的距离越来越大。从曲线整体上来看，本发明服务替换方法的响应时间稳定低于传统的服务替换方法的响应时间。

图8中，在服务簇内服务相同的基础上，本发明中的服务替换算法平均响应时间占传统服务替换方法的68.8％。

在图9中，横坐标为服务的数量，纵坐标为服务发现的响应时间；带有菱形标记线的为本发明中服务替换算法的响应时间，带有三角形形标记线的为传统的服务替换算法的响应时间。

在图9中，服务簇内服务相同的基础上，本发明提出的服务替换算法平均响应时间占传统服务替换方法的45.6％。

综合图8和图9可以得到实验结论：

第一，两种算法的响应时间都随服务数量增多而增长；

第二，本发明服务替换算法的效率明显低于传统的服务替换算法；

第三，两种替换方法的效率均受服务数量影响，而本发明服务替换算法的效率受服务数量的影响较小。

实验结果证实了本发明所提出的服务替换算法的正确性和有效性，且替换效率特别是组合替换效率有了明显的提高。

通过本发明与传统的服务发现算法、以及服务替换算法的实验比较，验证了本发明所提出的服务发现算法和服务替换算法的有效性和高效性。

本发明在服务簇已建立的基础上实现了服务的发现与替换，利用Petri网定义服务和服务簇的形式化模型，提出了服务匹配方法和服务组合方法，并通过理论证明、实例演示、及仿真实验验证了本发明方法的正确性、实用性及有效性。

当然，以上说明仅仅为本发明的较佳实施例，本发明并不限于列举上述实施例，应当说明的是，任何熟悉本领域的技术人员在本说明书的教导下，所做出的所有等同替代、明显变形形式，均落在本说明书的实质范围之内，理应受到本发明的保护。

Claims (1)

1.基于服务簇的服务组合与替换方法，其特征在于，包括如下步骤：

a、构建Web服务和服务簇的形式化模型

定义是一个自然数集合，即而设定且

定义Petri网：

一个Petri网表示为一个四元组PN＝(S,T；F,M0)，其中，

(1)S是一个有限库所集；

(2)T是一个有限变迁集，且

(3)是一个弧集；

(4)dom(F)∪cod(F)＝S∪T，其中，

$\mathrm{dom}\left(F\right)=\{x\&Element;S\&cup;T|\&Exists;y\&Element;S\&cup;T:(x,y)\&Element;F\},\mathrm{cod}\left(F\right)=\{y\&Element;S\&cup;T|\&Exists;x\&Element;S\&cup;T:(x,y)\&Element;F\};$

(5)为网PN的一个标识，其中，

M(s)表示标识M下库所s中的托肯数，M₀是初始标识；

定义输入/输出集：

设PN＝(S,T；F,M₀)为一个Petri网，x∈S∪T为网N的一个元素，记：

^·x＝{y|y∈S∪T^(y,x)∈F}称为x的输入集；

x^·＝{y|y∈S∪T^(x,y)∈F}称为x的输出集；

^·x∪x^·称为元素x的外延；

在Petri网中，采用一个圆圈表示一个库所，用一个矩形表示一个变迁；若(x,y)∈F，则x到y的一条有向边表示它们的流关系；

定义引发规则：

设PN＝(S,T；F,M₀)为一个Petri网，则其具有如下的变迁发生规则：

1)对于变迁t∈T，如果则变迁t在标识M有发生权，记为M[t＞；

2)如果M[t＞，则在标识M下，变迁t能够发生，从标识M发生变迁t得到一个新的标识M′，记为M[t＞M′，

根据上述Petri网的定义，构建Web服务的形式化模型如下：

定义Web服务：

一个Web服务描述为一个四元组WS＝(SF,I,O)，其中：

(1)SF表示服务的功能语义描述；

(2)I、O表示服务的输入、输出参数集，并且P＝(P.name,P.concept)，其中，

①P.name是输入、输出参数名；

②P.concept是一个输入、输出参数的本体概念，用以表示参数的语义；

定义服务请求：

一个服务请求表示为R＝(SF_r,I_r,O_r)，其中：

(1)SF_r表示服务请求的功能语义描述；

(2)I_r代表服务请求者可提供的输入参数集；

(3)O_r代表服务请求者需要输出的参数集；

定义服务网元：

服务WS＝(SF,I,O)的服务网元定义为SNU＝(t,I_t,O_t,F_t,M)，其中：

(1)t是一个能够完成服务功能的变迁；

(2)I_t＝^·t＝{s_i1,s_i2,s_i3,…,s_in}是变迁t的输入集，代表服务的输入参数集合；O_t＝t^·＝{s_o1,s_o2,s_o3,…,s_on}代表服务的输出参数集合；

(3)F_t＝(I_t×t)∪(t×O_t)是有向弧集合，表示服务的输入、输出参数的流关系；

(4)M是服务网元的标识，M：I_t∪O_t→{0,1}；

(5)变迁t在M下的发生规则为：

①则变迁t在M下有发生权，记为M[t>；

②若M[t>，则t在标识M下能够发生并得到一个新的标识，记作M[t>M′，对于

定义服务簇：

对于n个服务：ws₁,ws₂,...，SC＝{ws₁,ws₂,...,ws_n}是一个服务簇，其中：

ws_u＝(SF_u,I_u,O_u,SCM_u)，且SF_u和SF_v满足语义相似；

定义服务簇网元：

一个有n个服务的服务簇：SC＝{ws₁,ws₂,...,ws_n}，SNU_k＝(t_k,I_tk,O_tk,F_tk,M_k)，服务簇网元表示为SCNU＝(SU,t_C,I_C,O_C,F_C,M_C)，其中：

(1)SU＝{SNU₁,SNU₂,SNU₃,…,SNU_n}是服务网元的集合；

(2)t_C是服务簇网元的变迁，且能够完成服务簇中各服务的功能；

(3)I_C、O_C分别表示服务的输入、输出参数集，并且P＝(P.concept,P.lable)，其中：

①P.concept是服务簇中服务输入参数对应的语义概念；

②P.lable是一个n×1的矩阵，其中，n是服务簇中服务的个数，并且P.lable是服务簇中的服务相应P.concept的值；

(4)F_C＝(I_Ct×t_C)∪(t_C×O_Ct)表示服务簇输入、输出参数的流关系；

(5)M_C是服务簇网元的标识；

根据服务簇网元的定义，将一个服务的输入参数值作为服务簇输入矩阵的一行；将该服务的输出参数值作为服务簇输出参数矩阵的对应行；

b、基于服务簇的服务发现、组合与替换

设服务簇k的服务总数为m个，输入参数的总数为n_i个，输出参数总数为n_o个；I_Ck、O_Ck、i_r、o_r分别代表服务簇的输入矩阵、服务簇的输出矩阵、服务请求的输入矩阵、以及服务请求的输出矩阵；其中，I_Ck是一个m×n_i矩阵，O_Ck是一个m×n_o矩阵，i_r是一个1×n_i矩阵，o_r是一个1×n_o矩阵；I_Ck ^p(q)代表输入矩阵的第p行第q列的值；

输入一个服务簇网元模型SCNU_k＝(SU_k,t_Ck,I_Ck,O_Ck,F_Ck,M_Ck)和一个服务请求网元s_r＝{sf_r,i_r,o_r}，基于服务簇的服务匹配输出C_I和C_O，其中，C_I表示输入匹配矩阵，是一个m×n_i矩阵；C_O表示输出匹配矩阵，是一个m×n_o矩阵；

基于服务簇的服务匹配的过程如下：

S1:以I_Ck的首行开始，依次匹配该行的每个值；

S2:若该行中元素的值小于或者等于i_r对应的值，则标记C_I对应位置的值为1；

S3:否则，标记为0；

S4:以O_Ck的首行开始，依次匹配该行的每个值；

S5:若该行中元素的值大于或者等于i_r对应的值，则标记C_I对应位置的值为1；

S6:否则，标记为0；

S7:输出矩阵C_I和矩阵C_O；

其中，服务匹配的时间复杂度是m×n_i ²+m×n_o ²；

输入矩阵C_I和矩阵C_O，基于上述服务匹配过程提出服务发现的过程，进而得到一个服务集合S；服务发现的具体过程如下：

S1:p＝1,

S2:以C_I的第p行开始，依次匹配该行的每个值；

S3:若该行中所有的值都为1，则跳到S5；

S4:否则p＝p+1，循环这一匹配过程；

S5:依次匹配C_O第p行的各值；

S6:若该行中所有的值都为1，则将该服务合并入集合S中，即S＝S∪{ws_p}；

S7:否则p＝p+1，跳到S2；

S8输出服务集合S；

通过服务发现过程发现服务簇中满足服务请求的服务；服务发现输出的服务集合S中，所有服务的输入输出匹配矩阵同为即服务集合S中的每个服务都满足服务请求；服务发现过程的时间复杂度为：m×n_i+m×n；

定义ws_i◇ws_j表示服务ws_i和服务ws_j的并行组合；定义ws_i|ws_j表示服务ws_i和服务ws_j的串行组合；

设α＝[b₁,b₂,…,b_k]是一个1×k矩阵，其中，b_i∈{0,1}，且对于如果b_i＝1，α表示为E，即E＝[1,…,1]；

对于若b_i＝0，α表示为0，即0＝[0,0,…,0]；

其中，α表示Petri网中的一个标识；并且α₁≥α₂表示b_1i≥b_2i；

定义基元素：

设α₁＝[b₁₁,b₁₂,…,b_1k]且α₂＝[b₂₁,b₂₂,…,b_2k]是两个1×k矩阵，其中 and b_2i∈{0,1}，若α₁≥α₂，则称α₂是α₁的一个基元素；

定义基集合：

设C是一个1×k矩阵的集合；如果α_p∈C’或者α_q是α_p的一个基元素，且|C”|＞|C’|，则称C’是C的一个基集合；

定义服务组合标志：

用于标记当前服务请求下的服务组合的服务基集合，其初始标志为

根据服务匹配过程提出服务匹配的运算方法如下：

定义匹配运算：

SNU_a＝(t_a,I_ta,O_ta,F_ta,M_a)是一个服务网元，R＝(SF_r,I_r,O_r)是一个服务请求；

匹配运算被定义为：

(1) $I_r\&CircleTimes;I_{\mathrm{sa}}=[m\left({\mathrm{sr}}_{I1}\right)\&CircleTimes;m\left({\mathrm{sa}}_{I1}\right),m\left({\mathrm{sr}}_{I2}\right)\&CircleTimes;m\left({\mathrm{sa}}_{I2}\right),...,m\left({\mathrm{sr}}_{\mathrm{In}}\right)\&CircleTimes;m\left({\mathrm{sa}}_{\mathrm{In}}\right)],$

其中，

(2) $O_{\mathrm{sa}}\&CircleTimes;O_r=[m\left({\mathrm{sa}}_{O1}\right)\&CircleTimes;m\left({\mathrm{sr}}_{O1}\right),m\left({\mathrm{sa}}_{O2}\right)\&CircleTimes;m\left({\mathrm{sr}}_{O2}\right),...,m\left({\mathrm{sa}}_{\mathrm{On}}\right)\&CircleTimes;m\left({\mathrm{sr}}_{\mathrm{On}}\right)],$

其中，

定义服务簇匹配矩阵：

WS_req＝(SF_req,I_req,O_req)是一个服务请求；

SCNU_a＝(SE_a,t_Ca,I_Cta,O_Cta,F_Cta,M_a)是一个服务簇网元；

服务簇的输入/输出匹配矩阵被定义为：

$C_I={[m_{I1},m_{I2},m_{I3},...,m_{\mathrm{Iw}}]}^T=I_{\mathrm{req}}\&CircleTimes;I_{\mathrm{CSa}}={[I_{\mathrm{req}}\&CircleTimes;I_{s1},I_{\mathrm{req}}\&CircleTimes;I_{s2},...,I_{\mathrm{req}}\&CircleTimes;I_{\mathrm{sw}}]}^T=\left[\begin{array}{cccc}{m}_1\left(s_{I1}\right)& m_1\left(s_{I2}\right)& ...& m_1\left(s_{\mathrm{In}}\right)\\ m_2\left(s_{I1}\right)& m_2\left(s_{I2}\right)& ...& m_2\left(s_{\mathrm{In}}\right)\\ .& .& & .\\ .& .& & .\\ .& .& & .\\ m_w\left(s_{I1}\right)& m_w\left(s_{I2}\right)& ...& m_w\left(s_{\mathrm{In}}\right)\end{array}\right],$ 且 $C_O={[m_{O1},m_{O2},m_{O3},...,m_{\mathrm{Ow}}]}^T={[O_{s1}\&CircleTimes;O_{\mathrm{req}},O_{s2}\&CircleTimes;O_{\mathrm{req}},...,O_{\mathrm{sw}}\&CircleTimes;O_{\mathrm{req}}]}^T=\left[\begin{array}{cccc}{m}_1\left(s_{O1}\right)& m_1\left(s_{O2}\right)& ...& m_1\left(s_{\mathrm{On}}\right)\\ m_2\left(s_{O1}\right)& m_2\left(s_{O2}\right)& ...& m_2\left(s_{\mathrm{On}}\right)\\ .& .& & .\\ .& .& & .\\ .& .& & .\\ m_w\left(s_{O1}\right)& m_w\left(s_{O2}\right)& ...& m_w\left(s_{\mathrm{On}}\right)\end{array}\right],$

其中，m_k(s_I(O)j)＝0，1；

输入服务簇网元SCNU＝(SU,t_C,I_C,O_C,F_C,M_C)和服务簇的匹配矩阵C_I、C_O，其中，I_C∪O_C，P＝(P.concept,P.lable)，服务输入、输出参数的个数分别为k，l；输出服务集合B；

则服务串行组合的过程如下：

S1:依次匹配服务的输入、输出参数的参数语义；

S2:若存在I_Ci.concept＝O_Cj.concept，依次匹配C_I(i)；

S3:若C_I ^p(i)＝0，以C_I的首行开始，依次匹配该行的每个值；

S4:若C_I ^q＝[1,1,…,1]，匹配相应的C_O ^q；

S5:若C_O ^q(j)＝1且C_O ^q∪C_O ^p＝[1,1,…,1],则B＝B∪{ws_q}，循环这一过程；

S6:若输出“没有满足条件的串行服务组合”；

S7:输出服务集合B；

SCM表示服务的基集合，通过SCM的过程体现服务簇中服务间的共性与个性，从而用SCM来发现单一替代服务和组合替代服务；

输入服务簇SC＝{ws₁,ws₂,…,ws_n}和服务簇的匹配矩阵C_I、C_O，SCM过程如下：

S1:依次匹配m_Ij，若m_Ij≠[1,1,…,1]，则SCM_j标记为Φ；

S2:匹配m_Ok，若m_Ok＝[1,1,…,1]，SCM_k标记为0；

S3:若m_Ok≠[1,1,…,1]，找到所有不为Φ的SCM_p且若则A＝A∪{m_op}，

S4:若A＝Φ，则SCM_k＝Φ；

S5:否则标记SCM_k为A的基集合；

S6:若在所有的SCM中有一列全为1，在所有SCM中删掉这一列；

S7:输出SCM；

定义SCM_km代表SCMk的第m个元素；s_kml是SCM_km的第l列，n，m，定义组合规则：

SC＝{ws₁,ws₂,...,ws_n}是一个服务簇；其中，ws_i＝(SF_i,I_i,O_i,SCM_i)，

SCM_k⊥SCM_p＝SCM_k1⊥SCM_p1⊥SCM_k2⊥SCM_p2⊥…⊥SCM_kn⊥SCM_pn，

其中，SCM_km⊥SCM_pm＝[s₁,s₂,…,s_q]且

输入SC＝{ws₁,ws₂,...,ws_n}和失效服务ws_m，输出替换服务集合A；

则发现单一服务和组合服务的服务替换的过程如下：

S0:A＝Φ；

S1:若失效服务的SCM_m＝Φ或SCM_m＝0；

S1.1:匹配SCM，若则将服务ws_k并入集合A中，A＝A∪{ws_k}；

S1.2:若匹配存在SCM_i，SCM_k，SCM_i⊥SCM_k＝0，则将ws_i和ws_k的组合并入集合A中，即A＝A∪{ws_i◇ws_k}；

S2:否则，若失效服务的SCM_m≠Φ且SCM_m≠0；

S2.1:如果匹配SCM_k＝0，则将服务ws_k并入集合A中，A＝A∪{ws_k}；

S2.2:若匹配存在SCM_kj∈SCM_k，SCM_mh∈SCM_m，且SCM_kj≤SCM_mh，则将服务ws_k并入集合A中，A＝A∪{ws_k}；

S2.3:如果匹配SCM_i，SCM_k，SCM_i⊥SCM_k＝0，则将ws_i和ws_k的组合并入集合A中，A＝A∪{ws_i◇ws_k}；

S3:若A＝Φ；

S3.1:若SCM_m中存在某一列的值为1，而其他服务的在该列的值都不为1，则将这一列在所有的SCM中移除，转到S2；

S3.2:否则，输出“没有满足条件的替换服务”；

S4:输出A，即为满足条件的替换服务集合。