CN110619473B

CN110619473B - Method for realizing reverse circulation based on Activiti workflow

Info

Publication number: CN110619473B
Application number: CN201910889622.7A
Authority: CN
Inventors: 黄学雯; 林斌; 翁增仁
Original assignee: Fujian Boss Software Co ltd
Current assignee: Fujian Boss Software Co ltd
Priority date: 2019-09-19
Filing date: 2019-09-19
Publication date: 2022-03-15
Anticipated expiration: 2039-09-19
Also published as: CN110619473A

Abstract

The invention relates to a method for realizing reverse circulation based on an Activiti workflow, which comprises the following steps: s1, determining a backspacing path of a flow; s2, performing object compensation on a convergence gateway on a backspacing path; s3, cutting an execution example of the split gateway parallel to the current node; s4, judging whether the backspacing node is in a concurrent branch or not; and S5, executing the object execution rollback node. The invention aims to provide a method for realizing reverse flow based on an Activiti workflow, which does not depend on the control flow of Activiti and can support node rollback of complex business processes, including business processes with multiple execution paths generated by parallel gateways, inclusive gateways, exclusive gateways and the like. The invention has the advantages that: the service flow is simplified, and a reverse control flow does not need to be additionally configured, so that the drawing of the flow chart is simple; more complex business flow diagrams can be supported.

Description

Method for realizing reverse circulation based on Activiti workflow

Technical Field

The invention relates to a method for realizing reverse circulation based on an Activiti workflow.

Background

Activiti is a lightweight workflow service management platform, always drives service flow to execute downwards in the form of active nodes, and the core of the Activiti is a fast and stable BPMN2.0 engine developed by java. BPMN defines a business process flow diagram that is based on flow diagram technology, while tailoring the graphical model that creates the business process. The model of the business process is a graphical network diagram, which comprises a series of active nodes and a control flow of the operation sequence. Therefore, the trend of the business process in activti needs to be controlled by a control flow, that is, a connection between nodes, and the process cannot realize reverse circulation, that is, return to the previous step or any previous active node, when the process is separated from the control flow.

The existing methods for reverse flow of processes based on activti mainly include the following two methods:

1. the scheme can only support simple business processes, relatively complex processes can cause the follow-up processes to be incapable of normal flow under the scheme, and business processes of multi-branch paths generated by a parallel gateway, a inclusive gateway, an exclusive gateway and the like do not support the reverse flow of the processes.

2. The reverse flow of the process is promoted by the control flow, that is, when the business process diagram is drawn, a connecting line of a specified rollback target node is drawn for all nodes needing rollback operation, and an execution condition is configured on the connecting line to ensure that the control flow is executed under the rollback condition, so that the processing branches of the business can be increased, the complexity of the business process is increased to a certain extent, and inconvenience is brought to the drawing of the business process diagram.

Disclosure of Invention

The invention aims to provide a method for realizing reverse flow based on an Activiti workflow, which does not depend on the control flow of Activiti and can support node rollback of complex business processes, including business processes with multiple execution paths generated by parallel gateways, inclusive gateways, exclusive gateways and the like.

The purpose of the invention is realized by the following technical scheme: a method for realizing reverse circulation based on Activiti workflow comprises the following steps:

s1, determining a rollback path of a process: starting from the current node, performing breadth-first search by taking the backspacing node as a target node to find a backspacing path;

s2, executing object compensation on a convergence gateway on a fallback path: executing stack popping query on the backspacing path, and compensating the convergence gateway for the correct number of execution examples when the convergence gateway is encountered;

s3, cutting an execution example of the split gateway parallel to the current node;

s4, judging whether the backspacing node is in a concurrent branch or not;

s5, executing the object execution rollback node: if the rollback node is in the main process, setting the process instance to be in an activated state, and executing the rollback node by using the process instance; and if the backspacing node is positioned on the concurrent branch, creating a sub-execution object by using the flow instance, and executing the backspacing node by using the sub-execution object.

Compared with the prior art, the invention has the advantages that: the reverse flow of the flow can be realized under the condition of being separated from the control flow, the business flow is simplified, the business only needs to care about the forward flow, and the reverse control flow does not need to be additionally configured, so that the drawing of the flow chart is simple; the convergence of the concurrent branches and the compensation of the convergence gateway enable the invention to support more complex service flow charts, including complex branch flows generated by nodes such as the parallel gateway, the inclusive gateway, the exclusive gateway and the like.

Drawings

Fig. 1 is an overall flow diagram of a method for implementing reverse circulation based on an Activiti workflow.

Fig. 2 is a flow diagram of convergence gateway compensation.

FIG. 3 is a flow diagram of parallel branch pruning.

Figure 4 is a schematic flow diagram of acquiring a first split gateway.

Fig. 5 is a flow diagram of executing a fallback node.

FIG. 6 is a schematic flow chart of example 1.

Fig. 7 is a schematic flow chart of example 2.

Fig. 8 is a schematic flow chart of example 3.

Fig. 9 is a schematic flow chart of example 4.

Detailed Description

The invention is described in detail below with reference to the drawings and examples of the specification:

fig. 1 to 9 are schematic diagrams illustrating an embodiment of a method for implementing a reverse flow based on an activti workflow according to the present invention.

A method for realizing reverse circulation based on Activiti workflow comprises the following steps:

s1, determining a rollback path of a process: the determination of the rollback path is directly executed through flow definition, and from the current node, the rollback node is taken as a target node to execute breadth-first search to find the rollback path; the return path adopts stack storage, the stack bottom is a return node, and the stack top is a current node.

S2, executing object compensation on a convergence gateway on a fallback path: and executing stack popping query on the backspacing path, and compensating the convergence gateway for the correct number of execution instances when the convergence gateway is encountered.

If the target node of the rollback is in a branch path, if the target node of the rollback is simply executed, the number of execution instances and the number of incoming lines are inconsistent, which may cause a flow interruption when a convergence gateway is encountered subsequently, in order to solve the above problem, the convergence gateway needs to be compensated for the correct number of execution instances, and the specific steps are as follows:

taking the convergence gateway as a starting point, executing depth-first search aiming at each incoming line, and recording as a non-compensation incoming line if the depth-first search can reach a backspacing node;

subtracting the number of uncompensated incoming lines from the number of defined incoming lines of the convergence gateway to obtain the number of execution examples needing to be compensated by the gateway;

and using the process instance to create a sub execution object corresponding to the compensation number, setting the created sub execution object to be in a frozen state and enabling the active node to be the convergence gateway.

when the current node of the flow is in the branch path, if the node is directly executed to return, the sibling node of the current node generates the task again when the split gateway is encountered subsequently, and a new execution instance is added to the node, so that the execution instance of the split gateway parallel to the current node needs to be cut for the situation.

The cutting starting point of the execution example is the nearest gateway to be cut away from the backspacing node, and the step of obtaining the cutting starting point is as follows:

traversing the fallback path stack from the stack bottom to the stack top, if a split gateway is encountered, performing depth-first search on all outgoing lines of the split gateway, and setting a termination node as a current node or an end node;

if all outgoing lines of the split gateway can reach the current node through depth-first search, the current node does not need to be pruned; otherwise, the split gateway is the gateway to be cut, and the traversal is stopped.

The clipping steps of the implementation example are as follows:

starting from the gateway to be cut, executing breadth-first search, and searching to obtain all node IDs starting from the gateway to be cut;

acquiring an execution instance ID set of the executed nodes by using the node ID and the process instance ID lookup table act _ hi _ act;

and removing the process instance from the execution instance ID set, and executing remove method call on the executive Entity of the rest set.

S4, judging whether the backspacing node is in a concurrent branch or not;

executing a rollback node, wherein whether a target node needing to be rolled back is in a concurrent branch or not is firstly confirmed, and the judging steps are as follows:

performing depth-first traversal by taking the process starting node as a starting point and the back-off node as a target node to obtain the shortest path from the starting node to the back-off node, and storing the traversal result by using a stack;

traversing a shortest path stack from the stack bottom, if the node is a split gateway, pressing the node into a temporary stack, and if the node is a convergence gateway, popping a stack top element from the temporary stack;

after traversing is finished, if the temporary stack is empty, judging that the backspacing node is positioned on the main flow; and if the temporary stack is not empty, judging that the rollback node is in the concurrent branch, and recording a top stack node of the temporary stack, wherein the node is a first split gateway for prompting the rollback node to be in the concurrent branch.

S5, executing the object execution rollback node: if the rollback node is in the main process, setting the process instance to be in an activated state, and executing the rollback node by using the process instance;

if the backspacing node is on the concurrent branch, using the flow instance to create a sub-execution object, and using the sub-execution object to execute the backspacing node, at this time, if the active node of the flow instance is equal to the current node, setting the active node of the flow instance as the first split gateway which causes the backspacing node to be on the concurrent branch.

Analysis of specific examples:

example 1: both the fallback node and the current node are on the main flow (see fig. 6).

Step S1: starting from the node C, performing breadth-first search by taking the node A as a target node, and confirming a rollback path as follows: C-B-A;

step S2: traversing the fallback path C-B-A without encountering a convergence gateway, and ending the step;

step S3: the step needs to obtain a cutting starting point first, and because no split gateway exists in the backspacing path, no branch needing cutting exists, and the step is finished;

step S4: judging that the rollback node A is positioned on the main process;

step S5: the node a is executed directly using the flow instance.

Example 2: the target node of the fallback is on the branch path (see fig. 7).

Step S1: starting from the node D, performing breadth-first search by taking the node B as a target node, and confirming a fallback path as follows: d-gw 02-B;

step S2: traversing the fallback path D-gw 02-B, encountering the convergence gateway gw02, traversing along 2 incoming lines seq1 and seq2 starting from gw02, wherein seq1 can reach the fallback node B and is recorded as an uncompensated incoming line, seq2 cannot reach the fallback node B and is not an uncompensated incoming line, and therefore the number of execution examples to be compensated by the convergence gateway gw02 is 1. A child execution object is created using the flow instance to be set to the frozen state and the active node is the convergence gateway gw 02.

Step S3: the step needs to obtain a cutting starting point first, and because no split gateway exists in the fallback path, no branch needing cutting exists, and the step is ended.

Step S4: and (3) taking the starting node as a starting point and the node B as a target node to perform depth-first traversal, and obtaining a path: the start nodes-a-gw 01-B. Traversing the path, when traversing to gw01, the node is a split gateway, pushing a temporary stack. After the traversal is finished, at this time, there is a gw01 node in the temporary stack, which indicates that the fallback node B is in a concurrent branch, and records the top-of-stack node gw01 of the temporary stack, and the gw01 node is the first split gateway which causes the node B to be in the concurrent branch.

Step S5: and (3) creating a sub-execution object by using the process instance, and executing the node B by using the sub-execution object, wherein the active node of the process instance is the D node and is the current active node of the process, so that the active node of the process instance is set as the first split gateway, namely the gw01 node, which causes the fallback node B to be positioned on the concurrent branch.

Example 3: the flow currently active node is on a concurrent branch (see fig. 8).

Step S1: starting from the node B, performing breadth-first search by taking the node A as a target node, and confirming a fallback path as follows: b-gw 01-A;

step S2: traversing the fallback path B-gw 01-A without encountering a convergence gateway, and ending the step;

step S3: traversing the fallback path B-gw 01-A, when traversing to gw01, which is a split gateway, only seq1 of two outgoing lines seq1 and seq2 of gw01 can reach the node B, so gw01 is a clipping starting point.

Traversing from gw01 to obtain nodes B, C, gw02 and D, and only data exists in nodes B and C (only executed nodes will exist data, and gw02 and D nodes are not executed and will not exist data), so executing remove method to delete data in executionentitycorresponding to nodes B and C.

Step S4: and (3) performing depth-first traversal by taking the starting node as a starting point and the node A as a target node to obtain a path: the start node-a. Traversing the path, because there is neither a split gateway nor a convergence gateway, there is no node in the temporary stack, so node a is on the main flow.

Step S5: the node a is executed using the flow instance.

Example 4: flow both the current node and the fallback node are in branches (see fig. 9).

Step S1: starting from the G node, executing breadth-first search by taking the C node as a target node, and confirming a rollback path as follows: g-gw 07-gw 06-E-gw 05-gw 04-C;

step S2: the method comprises the steps of executing a stack popping query (namely starting from a node C) on a fallback path G-gw 07-gw 06-E-gw 05-gw 04-C, encountering a convergence gateway gw04, terminating the stack popping query, and then starting from gw04, executing a depth-first search on each incoming line seq1 and seq2, finding that seq1 can reach the fallback node C and is marked as an uncompensated incoming line, and seq2 cannot reach the node C, so that the number of execution examples needing compensation by gw04 is 2-1. Finally, 1 child execution object is created using the process instance, the created child execution object is set to the frozen state and the active node is gw 04.

Step S3: traversing the fallback path stack from the bottom of the stack to the top of the stack (i.e. starting from the C node), encountering the split gateway gw05, all outgoing lines seq3 and seq4 of gw05 can reach the G node through depth-first traversal, so gw05 is not the start point of clipping; and continuing traversing, and encountering the split gateway gw07, only seq5 can reach the G node by all outgoing lines seq5 and seq6 of gw07, so gw07 is a node which should be clipped, and traversing is finished.

Traversing by taking gw07 as a starting point to obtain a node set: g, H, gw 08; gw08 has not yet been executed, and cannot query data, so only the execution remove method of the executionentities of G and H need to be deleted.

Step S4: firstly, taking a process starting node as a starting point and taking a C node as a target node to perform depth-first traversal, and obtaining a shortest path from the starting node to the C node: the start nodes-gw 01-a-gw 02-gw 03-C. Traversing the path: when the gw01 is a split gateway, pushing gw01 into a temporary stack; encountering gw02 as a convergence gateway, so the top of stack element is popped from the temporary stack (i.e., gw01 in the temporary stack is removed from the stack); when the gw03 is a split gateway, pushing gw03 into a temporary stack; and finally, ending the traversal to the C node. The top stack node of the temporary stack at this time is gw03, so node C is on the branch path, and gw03 is recorded as the first split gateway to cause the rollback node to be on a concurrent branch.

Step S5: since the C node is on the branch path, a child execution object is created using the flow instance, and the C node is executed with the child execution object. The active node of the flow instance is equal to the current node, so the active node of the flow instance is set to gw 03.

Claims

1. A method for realizing reverse circulation based on an Activiti workflow is characterized by comprising the following steps:

s4, judging whether the backspacing node is in a concurrent branch or not;

s5, executing the object execution rollback node: if the rollback node is in the main process, setting the process instance to be in an activated state, and executing the rollback node by using the process instance; if the backspacing node is positioned on the concurrent branch, a sub-execution object is created by using the flow instance, and the backspacing node is executed by using the sub-execution object;

the execution example compensation method of the convergence gateway in step S2 is as follows:

2. The method of claim 1 for implementing reverse flow based on activit workflow, wherein: the clipping starting point of the execution instance in step S3 is the nearest gateway to be clipped from the back-off node, and the step of obtaining the clipping starting point is as follows:

3. The method of claim 2 for implementing reverse flow based on activit workflow, wherein: the clipping step of the execution instance in step S3 is as follows:

4. The method of claim 1 for implementing reverse flow based on activit workflow, wherein: the specific process of step S4 is as follows: