2.1 PNML+OWL

PNML (Petri Net Markup Language) (Jüngel et al., 2000) stores and describes a Petri net. It is used mainly to solve the problem of sharing Petri nets among different tools. However, due to the dependence on syntaxes, it cannot realize the interoperability of Petri nets.

OWL (Web Ontology Language) (McGuinness & van Harmelen, 2011) is a language system, and its theoretical basis is description logic. It can create ontology by using different attributes, such as an object attribute, data attribute, and domain attribute. Web information with semantic information in OWL is easy for machines to understand. OWL inherits the basic way of stating the fact of RDF (resource description frame) and the hierarchical structure of RDFS (RDF Schema) with classes and properties. By expanding upon these, OWL adds many new words and overcomes the problem of RDF/RDFS not describing concepts and attributes well.

In our related research (Ma & Xu, 2009; Ma & Xie, 2010), web services and their services composition have been modeled with Petri net. To be specific, the transition label in PNML represents the information about web services, such as service name, input and output, etc.; the place label in PNML represents inputs and outputs of web services; the flow label defines the relations between web services and their inputs or outputs. In addition, based on the semantic database, we have added some semantic information into the inputs and outputs of the web services in PNML documents so that the PNML+OWL description of the web services can be acquired.

2.2 XFire

XFire (Codehaus) is the next framework for Java SOAP (Simple Object Access Protocol). It bridges the gap between POJO (Plain Old Java Objects) and SOA (service-oriented architecture). Due to the use of a programming interface and its support for web service standards, XFire has a relatively simple service-oriented development. It simplifies the process of converting a Java application into web services and provides a simple and feasible way for enterprises to build SOA architectures. By building on a low memory model (STAX), it has high performance characteristics.

Based on XFire, web services can be invoked instantly. First, using XFire, we generate the web service clients, and then we invoked the web services by using their methods’ names and input parameters. If the call result from the web services does not belong to the array type, it should be further analyzed; otherwise, it is the desired result.

3.1 Atomic web services

An atomic web service usually refers to a service that has a relatively simple or independent function and provides single interfaces that meet specific requirements. In addition, an atomic web service can be designed and deployed based on general industrial standards or techniques, such as XFire (Codehaus).

3.2 Composite web services

Atomic web services can be “orchestrated” or “choreographed” into a composite web service to meet complex user demands. Composite web services are divided into two types according to the mode of the web service composition, either orchestration or choreography. An orchestration composite web service is considered to be an atomic web service while a choreography composite web service process structure is a part of the web service composition. By default, in the rest of this paper, composite web service refers to a choreography composite service.

During the choreography of composite web services, it is not easy to construct a complex service process depending only on the data association among services. It is also necessary to use control structures such as loop structure and choice. A loop control structure is used to control the execution times of sub-services while a choice control structure affects service selection and execution paths within a chosen structure. The control structure can be designed as a web service.

In our related work (Ma & Xu, 2009; Ma & Xie, 2010), we placed elements of the Petri net corresponding to the input and output of atomic web services or orchestration composite services; the transitional elements correspond to atomic web or orchestration composite services, and the Petri net of a composite web service can be generated with this method.

Definition 1 (Petri net of composite web services) The Petri net of a composite web service is an 8-tuple ∑ = (S, T, CS, CT, F, CF, M, L), where

1. S is the set of places. A place represents the input, output, precondition, or execution effects of sub-services in the composite web services;
2. T is the set of transitions. A transition corresponds to an atomic service or an orchestration composite service;
3. F⊆ (S×T)∪(T×S) is the set of flows;
4. CS is the set of control places. A control place is one input or output of a control condition;
5. CT is the set of control transitions. A control transition represents a loop control condition or a choice control condition;
6. CF⊆ (CS×CT) ∪ (CT×CS) is the set of control flows;
7. M: S∪CS → {0, 1, 2, …} is the number of tokens in places;
8. L: S → D∪{ τ } is the semantic markup function, where D is the set of classes and instances from one domain ontology. τ means an empty semantic.

The foundation of a Petri net of a composite web service is the data associations among sub-services and related structural relationships that determine the basic data flow (F) among services. On the other hand, control structures in composite web services include control places, control transitions, and control flows. The control structures influence the services’ flow direction and co-scheduling in the form of a control flow (CF).

Figure 1 shows the Petri net of a composite web service, where t1-t7 are transitions that represent atomic services. L1 and C1 are control transitions. L1 represents the loop condition, which influences the invocation of t2 and t3. C1 represents the choice condition that determines which web service is to be invoked next.

3.3 Petri net of a web service composition

If we ignore the complex business processes within a composite web service and only regard it as a web service that meets specific functional requirements and has multi-inputs and multi-outputs, then we further abstract and obtain the Petri net of a composite web service. Specifically, the initial input of the web service forms the input place elements in the Petri net, and the users’ end needs become the output place elements while the whole web service body is represented as a transition element. Afterwards, the abstracted Petri net model of the composite web service can be obtained.

Based on an abstraction of the Petri net of a composite web service and the data association among web services, we can get the Petri net and its PNM+OWL description of the web service composition (Xiang et al., 2012; Ma et al., 2013).

Definition 2 (Petri net of web service composition) The Petri net of a web service composition is a 5-tuple ∑ = (S, T, F, M, L), where

1. S is the set of places. A place corresponds to an input, output, precondition, or execution effect of some atomic service or the abstracted composite web services;
2. T is the set of transitions. A transition refers to an atomic service or the abstracted composite web services;
3. F⊆ (S×T)∪(T×S) is the set of flows;
4. M: S∪CS → {0, 1, 2, …} is the number of tokens within places;
5. L: S → D∪{ τ } is a semantic markup function, where D is a set of classes and instances from one domain ontology. τ means empty semantic.

3.4 Layered service composition architecture

From the basic components perspective, based on the abstraction of composite web services, the web service composition system can be treated as 7-layer architecture (Figure 2).

1. Base support layer: this layer supports the deployment, invocation, and registration of the web services;
2. Atomic service layer: this layer contains atomic web services and is the foundation of the design, orchestration, and invocation services;
3. Composite service layer: this layer contains composite web services;
4. Service abstraction layer: composite web services are abstracted in this layer, which is the foundation of the service composition;
5. Service composition layer: web services are composed in this layer according to semantic associations;
6. Service planning layer: the invocation sequence of web services is generated here based on the Petri net of the web service composition;
7. Service invocation layer: web services are sequential invoked in this layer according to the invocation sequence of web service composition.

This layered service architecture does not contain control structures in the service composition layer, which reflects that there are only data associations among the web services based on data flows. However, the composite service layer realizes the integration of the data and control flows based on a concrete service process. In addition, because the Petri nets at the service abstraction layer are abstracted from (composite) services, some control structural relationships may exist. This abstracted model does not reflect a real service’s execution. It only needs to get concrete Petri nets from the composite service layer during the execution of the composite services.

4.1 Prepositive web services and postpositive web services

Definition 3 (Prepositive web services) For a web service composition and its Petri net model ∑ = (S, T, F, M, L) for web service t_i, the prepositive web services can be defined as Pro (t_i) =^• (^•t_i)-{t_i}, i∈{1,2,…,|T|}. If ^•t_i = Ø, then Pro (t_i) = Ø;

Definition 4 (postpositive web services) For a web service composition and its Petri net model ∑ = (S, T, F, M, L) for web service t_i, the postpositive web services can be defined as Post (t_i) = (t_i^•)^•-{t_i}, i∈{1,2,…,|T|}. If t_i^•= Ø, then Post (t_i) = Ø;

Conclusion 1 In web service composition for web service t_i and its prepositive service set Pro(t_i), if ∀ t_j∈Pro(t_i) (i,j∈{1,2,…,|T|},j≠i), then the input-output association between tj and ti can be discovered. Similarly, for the postpositive service set Post(t_i), if ∀ t_j∈Post(t_i) (i,j∈{1,2,…,|T|},j≠i), then the input-output association between t_i and t_j can also be acquired.

4.2 Structural relationships in web service composition

In the Petri nets of web service composition (Chen et al., 2010) or composite web services, it is easy to analyze and acquire three basic structural relationships from the structural view: sequenced relationships (Sequence), concurrent relationships (Concurrence), and selective relationships (Choice). All of these constitute the foundation of structural relationships within a web service composition, shown in Figure 4.

For a Petri net of a web service composition ∑ = (S, T, F, M, L) with a basic structural relationship R belonging to {Sequence, Concurrence, Choice}:

1. Sequenced Relationship
   For two web services t_i, and t_j, the postpositive web service of t_i is a nonempty set Post(t_i), where i, j∈{1,2,…,|T|}, and i≠j. If |Post (t_i)|=1 and t_j∈Post (t_i), then the relationship between t_i and t_j is a sequenced relationship (Sequence), which can be denoted as <t_i, t_j>∈Sequence. If the relationships among t₁,t₂,…,t_n belong to Sequence successively, <t₁,t₂>,<t₂,t₃>,…,<t_k,t_k+1>,…<t_n-1,t_n>∈Sequence, the corresponding expressed sequence of this relationship is t₁t₂…t_n. This is shown as t1 and t2 in Figure 3a.
2. Concurrence Relationship
   For web service t_i,, i ∈{1,2,…,|T|}, the postpositive web service of ti is a nonempty set Post(t_i). If |t_i^•|>1, |Post (t_i)|>1, t_i1 and t_i2∈Post (t_i), ^•t_i1∧^•t_i2 = φ, then the relationship between t_i1 and t_i2 is a Concurrence relationship (Concurrence), which can be denoted as <t_i1,t_i2>∈Concurrence. Similarly, if there exists a web service t that satisfies t₁,t₂,…,t_n∈Post(t) and with the condition that the relationship between the elements of the set {t₁,t₂,…,t_n} is Concurrence, then the corresponding expressed sequence is (t₁&t₂&…&t_n). This is shown as t2 and t3 in Figure 3b.
   In addition, from a general perspective, for multiple web services that meet their input parameter values, if there is no data association among the inputs and outputs of the web services, these web services are independent of each other and can be identified as concurrence.
3. Selective Relationship
   For web service t_i,, i∈{1,2,…,|T|}, the postpositive web services of t_i is a nonempty set Post(t_i). If |t_i^• |=1,|Post(t_i)|>1, and t_i1 and t_i2 all belong to Post(t_i), then the relation between t_i1 and t_i2 is the selective relationship (Choice), which can be denoted as <t_i1,t_i2>∈Choice. Similarly, if there exists a web service t that satisfies t₁,t₂,…,t_n∈Post(t), with the condition that the relationship between the elements of the set {t₁,t₂,…,t_n} is a selective relationship, then the corresponding expressed sequence is (t₁|t₂|…|t_n). This is shown as t2 and t3 in Figure 3c.

4.3 Control structures in composite web services

1. Loop structural relationship, shown in Figure 4
   In the Petri net of a composite web service, the loop controller is L_i, t₁,t₂,…,t_n are web services, and i∈N, L_i refers to a control transition which controls(influences) the loop structure body L(t₁,t₂,…,t_n). In a loop structure body, there exist basic or nested structural relationships. In a Petri net with loop structures, |^•L_i|=|L_i^•|=1. Moreover, we regard the set {t_j | t_j∈Post (L_i)} as the beginning service of the loop and the set {t_k | t_k∈Prot (L_i)} as the ending service of the loop. The corresponding loop expression is represented as Loop(t₁,t₂,…,t_n: L_i) = (L(t₁,t₂,…,t_n):L_i).
2. Selective relationship with choice conditions shown in Figure 5
   Suppose the selection controller (conditions) is C_i and t₁,t₂,…,t_n are web services, i∈N, C_i refers to the control transition that influences the selective execution paths,|^•C_i|=|C_i^•|=1, Post(C_i)={t₁,t₂,…,t_n}, and Pro(C_i) = Ø. The corresponding selection expression is Choice (t₁,t₂,…,t_n: C_i) = (t₁|t₂|…|tn:C_i).

5.1 Invocation sequence of web service composition

When considering the complexity of structures of a Petri net of web service composition and its composite services, it is not easy to achieve an automatic analysis and invocation of web services located in the complex structures. Thus, in order to maintain the structural relationship among the web services and promote automatic analysis and execution, the web services and their structural relationships should be presented in the form of symbol sequences called the invocation sequence of web services.

Definition 5 (Invocation sequence of web services) The invocation sequence of web services can be defined as $\text{S = Seq(WS)=R}\left({\displaystyle \underset{i=1}{\overset{m}{\cup }}Seq(W{S}_i)}\right)$M1 \documentclass[10pt]{article} \usepackage{wasysym} \usepackage[substack]{amsmath} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage[mathscr]{eucal} \usepackage{mathrsfs} \usepackage{pmc} \usepackage[Euler]{upgreek} \pagestyle{empty} \oddsidemargin -1.0in \begin{document} \[ {\rm{S = Seq(WS) = R}}\left( {\bigcup\limits_{i = 1}^m {Seq(W{S_i})} } \right) \] \end{document} , where WS is a web service set{t_i, i=1,2,…,n} and WS_i ⊆ WS. This satisfies ${\displaystyle \underset{i=1}{\overset{m}{\cup }}W{S}_i=}WS$M2 \documentclass[10pt]{article} \usepackage{wasysym} \usepackage[substack]{amsmath} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage[mathscr]{eucal} \usepackage{mathrsfs} \usepackage{pmc} \usepackage[Euler]{upgreek} \pagestyle{empty} \oddsidemargin -1.0in \begin{document} \[ \bigcup\limits_{i = 1}^m {W{S_i} = } {\rm{ }}WS \] \end{document} and ${\displaystyle \underset{i=1}{\overset{m}{\cap }}W{S}_i}=\varnothing$M3 \documentclass[10pt]{article} \usepackage{wasysym} \usepackage[substack]{amsmath} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage[mathscr]{eucal} \usepackage{mathrsfs} \usepackage{pmc} \usepackage[Euler]{upgreek} \pagestyle{empty} \oddsidemargin -1.0in \begin{document} \[ \bigcap\limits_{i = 1}^m {W{S_i}} = {\rm{ }}\emptyset \] \end{document} , where t_i is a web service, Seq(WS) represents the invocation sequence based on WS, and R represents the structural relationships among the web services. If there exists some relationship covering WS_i, namely R(WS_i), then Seq(WS_i) = R(WS_i); otherwise, there must be a web service set $W{S^{\prime }}_i$M4 \documentclass[10pt]{article} \usepackage{wasysym} \usepackage[substack]{amsmath} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage[mathscr]{eucal} \usepackage{mathrsfs} \usepackage{pmc} \usepackage[Euler]{upgreek} \pagestyle{empty} \oddsidemargin -1.0in \begin{document} \[ W{S'_i} \] \end{document} that can be covered by some relationship that satisfies $W{S^{\prime }}_i\subset W{S}_i$M5 \documentclass[10pt]{article} \usepackage{wasysym} \usepackage[substack]{amsmath} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage[mathscr]{eucal} \usepackage{mathrsfs} \usepackage{pmc} \usepackage[Euler]{upgreek} \pagestyle{empty} \oddsidemargin -1.0in \begin{document} \[ W{S'_i} \subset W{S_i} \] \end{document} and $R\left(W{S^{\prime }}_i\right)$M6 \documentclass[10pt]{article} \usepackage{wasysym} \usepackage[substack]{amsmath} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage[mathscr]{eucal} \usepackage{mathrsfs} \usepackage{pmc} \usepackage[Euler]{upgreek} \pagestyle{empty} \oddsidemargin -1.0in \begin{document} \[ R\left( {W{{S'}_i}} \right) \] \end{document} . Then $S_i=\text{Seq(}W{S}_i\text{)=Seq}\left(\text{R(}W{S^{\prime }}_i\text{)}\cup \overline{W{S^{\prime }}_i}\right)$M7 \documentclass[10pt]{article} \usepackage{wasysym} \usepackage[substack]{amsmath} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage[mathscr]{eucal} \usepackage{mathrsfs} \usepackage{pmc} \usepackage[Euler]{upgreek} \pagestyle{empty} \oddsidemargin -1.0in \begin{document} \[ {S_i} = {\rm{Seq(}}W{S_i}{\rm{) = Seq}}\left( {{\rm{R(}}W{{S'}_i}{\rm{)}} \cup \overline {W{{S'}_i}} } \right) \] \end{document} .

The following is an example of the invocation sequence of web services in Figure 1:

1. S₁ = Seq(t₂,t₃) = Loop (t₂,t₃:L₁) = (t₂t₃:L₁);
2. S₂ = Seq(t₁, S₁) = Sequence(t₁, S₁) = t₁S₁;
   =>S₂ = t₁S₁ = (t₂t₃:L₁);
3. S₃ = Seq (S₂,t₄) = Concurrence(S₂,t₄) = (S₂&t₄);
   =>S₃ = (S₂&t₄) = ((t₂t₃:L₁)&t₄);
4. S₄ = Seq (S₃,t₅) = Sequence(S₃, t₅)= S₃t₅;
   =>S₄ = S₃t₅ = ((t₂t₃:L₁)&t₄)t₅
5. S₅ = Seq (t₆,t₇) = Choice (t₆,t₇:C₁) =(t₆|t₇:C₁);
6. S₆ = Seq (S₄, S5) = Sequence (S₄, S5) = S₄S₅;
   =>S₆= S₄S₅= ((t₂t₃:L₁) &t₄) t5 (t₆|t₇:C₁)

After iterating the above six formulas and replacing similar structural relationship expressions, the invocation sequence of the web services is S=Seq(t₁,t₂,t₃,t₄,t₅,t₆,t₇)=(t₁(t₂t₃:L₁)&t₄)t₅(t₆|t₇:C₁). In the invocation sequence of the web services, the priority of structural relationships is regulated as: sequence > concurrence >choice. In addition, the relational structure for the symbol “(“and”)” should be given a higher priority.

In conclusion, the main function of the invocation sequence of web services is to reflect the structural relationship among the web services, describe their execution sequence, and embody the planning results. Moreover, it can also provide a necessary basis for following coordinate scheduling and execution of multiple web services.

5.2 Invocation scheduling of web services

Definition 6 (Relationship identifier) The relationship identifier R={ ti | Ai | Ci | Li, i=1,2,…,n }, where i is an integer, ti represents an atomic web service, Ai represents the concurrence relationship, Ci represents the selective relationship, and Li represents the loop relationship. The invocation scheduling for web services is given as follows:

Step1: Retrieve the input-output associations among the web services from PNML+OWL;

Step2: Simplify the invocation sequence of the web services by relationship identifiers. The purpose of this step is to locate the scope of a certain structural relationship so as to schedule web services in the relationship;

Step3: Extract structural relationships. Based on the specific relationship identifier and the invocation sequence of web services that were generated in Step 2, the web services are further invoked according to their structural relationships.

5.3 Invocation condition of choice sequence

Definition 7 (Choice sequence) If there are N sequences, such as S₁’, S₂’, S_n’, in a selective structure, each sequence is called a choice sequence.

Each first web service t_i1,t_i2,…,t_ik,…,t_in can be extracted from sequences S₁’,S₂’,…,S_n’. Suppose t_pik(k=1,2,…,n) is an input for each first web service, it is associated with the output p_j of web service t_j. In the web service composition, it satisfies ${\text{t}}_{\text{j}}{}^{•}={\displaystyle \underset{m=1}{\overset{n}{\cap }}{}^{•}{t}_{im}}$M8 \documentclass[10pt]{article} \usepackage{wasysym} \usepackage[substack]{amsmath} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage[mathscr]{eucal} \usepackage{mathrsfs} \usepackage{pmc} \usepackage[Euler]{upgreek} \pagestyle{empty} \oddsidemargin -1.0in \begin{document} \[ {{\rm{t}}_{\rm{j}}}^ \bullet = \bigcap\limits_{m = 1}^n {^ \bullet {t_{im}}} \] \end{document} and ${\displaystyle \underset{m=1}{\overset{n}{\cap }}Pro}(t_{im})={\text{ t}}_{\text{j}}$M9 \documentclass[10pt]{article} \usepackage{wasysym} \usepackage[substack]{amsmath} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage[mathscr]{eucal} \usepackage{mathrsfs} \usepackage{pmc} \usepackage[Euler]{upgreek} \pagestyle{empty} \oddsidemargin -1.0in \begin{document} \[ \bigcap\limits_{m = 1}^n {Pro} ({t_{im}}) = {\rm{ }}{{\rm{t}}_{\rm{j}}} \] \end{document} , where Pre (t_im) is the prepositive service set of web service t_im. The semantic association between p_j and p_ik is reasoned and obtained, and then the selection is performed as follows:

1. If the semantic association between p_j and p_ik is a parent-son relationship, an instance-class relationship, or a complete equivalence relationship and p_j and p_ik are of consistent data types, then the input (p_j) of web service p_j can meet the input (p_ik)of web service t_ik, and the sequence S_i’ has been chosen.
2. If the semantic association between p_j and p_ik is a parent-son relationship or an instance-class relationship, then the semantic association between the values of p_j and p_ik should be further judged. Suppose the value of p_j is v_pj only if the semantic association of v_pj and p_ik is a parent-son relationship or an instance-class relationship, then the output p_j of web service t_j can meet the input p_ik of web service t_ik. Thus, the sequence S_i’ has been chosen.

5.4 Invocation policy of structural relationship

Suppose a relationship identifier Ri exists, and its structural relationship is R(t1, t2,…,tj), j ∈N. The invocation of web services can be treated as follows:

1. Atomic web services, that is Ri∈ {ti ; i =1, 2,…,n}. Invoke each web service directly;
2. Concurrence structure relationship, that is Ri∈ {Ai, i = 1, 2, …, n} and R(t1, t2,…,tj) = (t1&t2&…&tj). Invoke web service t1, t2, … tj in concurrent threads;
3. Selective structure relationship, that is Ri∈ {Ci, i = 1, 2,…, n} and R(t1, t2,…,tj) = (t1|t2|…|tj). Screen out the set S of web services that meet the invocation condition of the choice sequence from t₁, t₂,…, t_j, and then invoke each web service of S in concurrent threads;
4. Selective structure relationship with choice conditions, that is Ri∈ {Ci, i = 1, 2,…, n} and R(t1, t2,…,tj) =(t1|t2|…|tj: ck), where ck is a choice condition. Screen out set S of the web services from t1, t2,…, tj to ck and then invoke each web service of S in concurrent threads;
5. Loop structure relationship, that is Ri∈{Li, i = 1, 2,…, n} and R(t1, t2,…,tj) = (L(t1, t2,…,tj) : lk), where L(t1, t2,…,tj) is its loop structure body. Invoke the web services of L(t1, t2,…,tj) first, and then execute the method that published in the service Lk. According to the return value, subsequently re-invoke the web services of L (t1, t2,…,tj) constantly until the value is false.

In practice, there may be a nested structural relationship that contains multiple or different kinds of service structural relationships, just like R (t₁, t2,…,t_j) =(t₁&t₂&…&t_k&R1), where R1 is a relationship identifier of the structural relationship R’(t_k+1…,t_j). Therefore, it is necessary to nest the above invocation policies to deal with this relatively complex structural relationship.

5.5 Web services composition invocation algorithm based on Petri net

Inputs: invocation sequence and PNML+OWL file of web service composition

Outputs: invocation results of web service composition

Step 1: Extract input-output associations between web services. From the flow relation sets (the “arc” label) in PNML+OWL, the input-output associations between web services are analyzed and extracted. Then the data association Hash table (IORelevancyMap) can be further created. Suppose the output p_i of web service t_i is associated with the input p_j of web service t_j, where i and j are integers, then the corresponding storage format of the Hash table is key= “t_i : p_i ”, and value= Hash(key)= “t_j : p_j”.

Step 2: Simplify web service invocation sequence. For the invocation sequence of web services S, the character c can be read from left to right in turn. If c is ‘(‘, c and the following characters are pushed into a stack until the character that is read from S is ‘)’. If c is ‘)’, characters are popped from the stack until the character that pops from the stack is ‘(‘. After this, the popped string (characters) that match ‘(‘ with ’)’ are processed as follows:

1. If the string contains the character ‘&’, the string is denoted as a concurrence structure sequence by the relationship identifier Ai (i=1, 2,…,k). Ai and its corresponding concurrence sequence t₁&t₂&…&t_n are added into the Hash table Concurrent Map. The Hash table Concurrent Map is key = Ai and value= Hash (key)= “t₁&t₂&…&t_n”,
2. If the string contains the character ‘|’ and does not contain the character ‘:’, the string is denoted as a choice structure sequence by the relationship identifier Ci(i=1,2,…,k). Ci and its corresponding choice sequence (t₁|t₂|…|t_n) is added into the Hash table ChoiceMap. The hash table ChoiceMap is key =Ci and value= Hash (key)= “t₁|t₂|…|t_n”;
3. If the string contains the character ‘|’ and character ‘:’, the string is denoted as a selective structure sequence with choice conditions by the relationship identifier Ci(i=1,2,…,k). Ci and its corresponding choice sequence (t­|t₂|…|t_n: c_j) are added into the Hash table ChoiceMap. The Hash table ChoiceMap is key = Ci and value= Hash (key)=”(t₁|t₂|…|t_n : c_j)”;
4. If the string contains character ‘L’, the string is denoted as a loop structure sequence by the relationship identifier Li(i=1,2,…,k). Li and its corresponding loop sequence (L(t₁, t₂,…, t_n) : L_j) are added into the Hash table LoopMap. The hash table LoopMap is key = Li and value= Hash(key)= “(L(t₁, t₂,…, t_n) : L_j)”;
5. If the stack is empty, the character “/”will be appended onto the ending of the extracted string so as to distinguish each invocation sub-sequence of the web service. The invocation sequence is divided into several invocation sub-sequences of web services. The structural relationship among these invocation sub-sequences is the sequenced relation.

Step 3: Invoke web services according to the invocation sequence generated from step 2, and respectively execute each service structure and its corresponding internal web services.

Suppose the simplified invocation sequence is S’, where i and j are integers and i is not equal to j. After traversing S’, the relationship identifier R can be extracted in turn. Now invoke the web services as follows.

1. If R∈{ti,i=1,2,…,n}, then according to the data association Hash table IORelevancyMap, the output p_j of web service t_j will be discovered, which is associated with the input p_i of web service t_i. Then the value of p_j can be obtained from the outcome results of t_j, which is the input parameter of t_i. Afterwards, according to the acquired interface of t_i, the web service t_i can be fully invoked. Meanwhile, the corresponding execution results will be saved.
2. If R∈{Ai,i=1,2,…,n}, according to the Hash table ConcurrentMap, the value(string) corresponding to the key Ai can be acquired. Then the concurrence sequences will be parsed from the value, and the same operation will be repeated as in step 3. Meanwhile, each execution process should be placed into several concurrent threads.
3. If R∈{Ci,i=1,2,…,n}, according to the Hash table ChoiceMap, the value (string) corresponding to the key Ci can be acquired. Then the selective sequences will be parsed from the values, which are S1’,S2’,…,Sn’. First, according to the executable condition of selective sequences, the sequences that satisfy these conditions are added to a set (selectedSet). Second, it is necessary to judge whether Ci has selective conditions. If these exist, it should retrieve the published method of this selective condition, and then the selective result will be written into a set (selectedConSet). Finally, after the intersection between selectedSet and selectedConSet, the same operation will be repeated as in step 3. Meanwhile, each execution process should be placed into several concurrent threads.
4. If R∈{Li,i=1,2,…,n}, according to Hash table LoopMap, the value (string) corresponding to the key Li can be acquired. Then the loop structure body and the loop condition will be parsed from the value. In the following process, the loop structure body will be executed according to step 3, and then the published method of this loop condition will be invoked. The Boolean value of results determines whether to re-execute the loop structure.