CN102254233A - Flow driving method and flow driving device - Google Patents

Abstract

The invention discloses a flow driving method and a flow driving device and belongs to the field of computers. The method comprises the following steps of: determining a flow element of a flow to be driven and a flow behavior which corresponds to the flow element; mapping the flow element into a corresponding executable object, and assembling the flow behavior of the flow element into the corresponding executable object; and during external call of the executable object, starting an execution process of the executable object. The invention has the advantages that: by mapping the flow element into the corresponding executable object, starting the execution process of the executable object during the external call of the executable object, and summarizing the behavior characteristics of various kinds of flow languages by the executable object, the flow is driven, flow languages such as blocky flow language and graphic flow language can be supported, the expansibility of the flow driving is improved, and the portability of the flow driving can be improved due to no binding with any specific data storage layer technology and an inversion of control (IOC) container.

Description

Process driving method and device

technical field

The invention relates to the field of computers, in particular to a process driving method and device.

Background technique

With the development of computer technology, there are more and more types of process languages. Although the syntax and format of the process language are different, the problems to be solved are generally the same, and the flow behavior is consistent. Designing a general-purpose drive system that adapts to various process languages is conducive to improving the development efficiency of the BPM (Business Process Management, business process management system) engine; it can make the BPM product line highly scalable; Special requirements for multiple process languages.

The driving system provided by prior art 1 first proposed the concept of PVM (Process Virtual Machine, process virtual machine), and successfully drove BPEL (Business Process Execution Language, business process execution language) and JPDL (Java business processmanagement Process) using this PVM. Definition Language, business process management process definition language). The second prior art has developed the Windows Workflow Foundation (workflow framework) system. Although it is not named "PVM", the design goal of this system is consistent with PVM. This system can drive various process languages similar to BPEL language .

In the process of realizing the present invention, the inventor finds that the prior art has at least the following disadvantages:

The PVM provided by prior art 1 relies heavily on the object-relational mapping framework (Hibernate) of open source code at runtime, and this PVM also has components such as IOC (Inversion of Control, inversion of control) containers, and these components have nothing to do with PVM in essence, On the contrary, this product cannot be integrated with other products, resulting in poor portability; the second prior art is difficult for graphical process languages, such as BPMN (Business Process Modeling Notation, business process modeling annotation), especially for free jump, Retrieval, signing and other required business processes; in addition, due to the heavy dependence on .Net Framework, the scalability is also poor.

Contents of the invention

In order to improve the expansibility and portability of the process-driven, and further improve the practical performance of the process-driven, the embodiments of the present invention provide a process-driven method and device. Described technical scheme is as follows:

In one aspect, a process-driven method is provided, the method comprising:

Determine the process elements of the process to be driven, and the process behavior corresponding to the process elements;

Mapping the process element into a corresponding execution object, and assembling the process behavior of the process element into the corresponding execution object;

The execution process of the execution object is started when the execution object is called externally.

In another aspect, a process driving device is provided, the device comprising:

A determining module, configured to determine the process elements of the process to be driven, and the process behavior corresponding to the process elements;

A mapping module, configured to map the process element to a corresponding execution object, and assemble the process behavior of the process element into the corresponding execution object;

The driving module is used to start the execution process of the execution object when the execution object is called externally.

The beneficial effects of the technical solution provided by the embodiments of the present invention are:

By mapping the process elements to the corresponding execution objects, and starting the execution process of the execution objects when the execution objects are called externally, that is, using the execution objects to summarize the behavior characteristics of various process languages, and realizing the driving of the process, it can not only support blocks Graphical process language can also support graph-like process language well, thereby improving the scalability of process-driven; in addition, because the technical solution provided by the embodiment of the present invention is not bound to any specific data storage layer technology and IOC container , therefore, has high portability.

Description of drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings that need to be used in the description of the embodiments will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present invention. For those skilled in the art, other drawings can also be obtained based on these drawings without creative effort.

FIG. 1 is a flowchart of a process-driven method provided by Embodiment 1 of the present invention;

Fig. 2 is a schematic diagram of the relationship between BPMN2.0 and the process driving device provided by the second embodiment of the present invention;

Fig. 3 is a flow chart of the process driving method provided by Embodiment 2 of the present invention;

FIG. 4 is a schematic diagram of flow elements of BPMN2.0 provided by Embodiment 2 of the present invention;

5 is a schematic diagram of the process behavior of the process elements of BPMN2.0 provided by Embodiment 2 of the present invention;

Fig. 6 is a schematic diagram of various execution objects provided by Embodiment 2 of the present invention;

FIG. 7 is a schematic diagram of the relationship between various execution objects provided by Embodiment 2 of the present invention;

FIG. 8 is a schematic diagram of the execution object structure provided by Embodiment 2 of the present invention;

Fig. 9 is a schematic structural diagram of a process driving device provided by Embodiment 3 of the present invention;

Fig. 10 is a schematic structural diagram of a driving module provided by Embodiment 3 of the present invention;

FIG. 11 is a schematic structural diagram of an execution unit provided by Embodiment 3 of the present invention.

Detailed ways

In order to make the object, technical solution and advantages of the present invention clearer, the implementation manner of the present invention will be further described in detail below in conjunction with the accompanying drawings.

Embodiment one

Referring to FIG. 1, this embodiment provides a process-driven method, and the process of the method is as follows:

101: Determine the process element of the process to be driven, and the process behavior corresponding to the process element;

102: Map the process element to the corresponding execution object, and assemble the process behavior of the process element into the corresponding execution object;

103: Start the execution process of the execution object when the execution object is called externally.

The method provided in this embodiment maps the process elements to the corresponding execution objects, and starts the execution process of the execution objects when the execution objects are called externally, that is, summarizes the behavioral characteristics of various process languages with the execution objects, and realizes the process The driver can not only support the block process language, but also support the graph-like process language, thereby improving the scalability of the process drive; in addition, because the technical solution provided by the embodiment of the present invention is not related to any specific data storage layer Technology and IOC container binding, therefore, has high portability.

Embodiment two

This embodiment provides a method for driving a process. The method maps process elements to corresponding execution objects, and uses the execution objects to summarize the behavioral characteristics of various process languages, so as to drive the process. For ease of description, this embodiment takes the BPMN2.0 process language as an example for illustration, and FIG. 2 is a schematic diagram of the relationship between the BPMN2.0 process engine and the process driving device. Referring to Figure 3, the method flow provided by this embodiment is specifically as follows:

301: Determine the process element of the process to be driven, and the process behavior corresponding to the process element;

For this step, each specific process language includes various process elements, and how to determine the process elements and corresponding process behaviors of the process to be driven is not specifically limited in this embodiment. Taking the BPMN2.0 process language as an example, its process elements are shown in Figure 4, including Process, Activity, Event, SequnceFlow and other process elements, and the corresponding process behavior can be shown in Figure 5.

302: Select a corresponding execution object for the process element;

Specifically, the present embodiment represents the execution object with Executable Object, regards it as a Java Bean with specific behavior, and defines three kinds of processes, namely the execution process execute(), the wake-up process awaken() and the end process complete( ). Among them, execute() is used to execute business logic, which is the business logic carried by the process mapped to the execution object; awake() is used to wake up the execution object, and in actual application, wake up the execution object by performing data recovery ; complete() is called after execute() executes business logic.

Although each execution object has three processes of execute(), awaken(), and complete(), the specific implementation methods of these processes are not necessarily identical. Referring to FIG. 6 , according to different process implementation methods, execution objects can be divided into three types: net (NetInstance), node (NodeInstance) and arc (ArcInstance). Among them, a network can contain several interconnected nodes and arcs; a node can have several input arcs and several output arcs, and each arc must have an input node and an output node; in addition, a network can contain subnetworks, The relationship between various execution objects can be shown in FIG. 7 .

Regarding how to select the corresponding execution object for the process element, this embodiment does not limit the specific selection method, still taking the process element in BPMN2.0 as an example, you can choose to map the Process flow element to the execution object of the Net type, Activity Process elements such as , Event, etc. are mapped to the execution object of Node type, and process elements such as SequnceFlow are mapped to the execution object of Arc type.

303: Map the process element to the corresponding execution object, and assemble the process behavior of the process element into the corresponding execution object;

Among them, after the process behavior of the process element is assembled into the corresponding execution object, all execution objects can be assembled into the kernel manager, and the kernel manager is responsible for managing a series of execution objects with mutual relations, and calling the execution object externally , through which the kernel manager is responsible for invoking the execution process of the execution object.

304: Start the execution process of the execution object when the execution object is called externally.

For this step, since different process definition languages express the carried business logic in different ways, it is impossible for the ExecutableObject to pre-hardcode all situations into the process driver architecture. Therefore, the method provided in this embodiment adopts the design concept of extension points to meet this requirement: 3 extension points are assembled for each ExecutableObject, that is, 3 fixed interfaces are referenced: IncomingLogic, BusinessLogic, and LeavingLogic, as shown in FIG. 8 .

Among them, the canBeFired() object is set in the IncomingLogic interface, which is used to judge whether the business logic meets the execution conditions; the perform() object is set in the BusinessLogic, which is used to execute the real business logic; the determineLeavingStragegy() object is set in the LeavingLogic. Indicates the next operation at the end of the business logic. The next operation may be to execute a new ExecuteObject, or return to the previous ExecuteObject and call its complete() method.

When starting the execution process of the execution object, first call the canBeFired() object set in the IncomingLogic interface, then call the perform() object set in the BusinessLogic, and finally call the determineLeavingStragegy() object set in the LeavingLogic, that is, start the execution object During the implementation process, it specifically includes:

Determine whether the business logic corresponding to the execution object can be triggered;

If yes, execute the business logic and indicate the next action after the execution ends.

Among them, execute business logic, specifically including:

Call the execution process execute() to execute the business logic, and after the execution of the business logic, call the end process complete();

If the business logic needs to be executed for a long time, save the state of the execution object in the storage medium until the execution of the business logic ends, call the wake-up process awake() for data recovery, and call the end process complete() after the data recovery.

The method provided in this embodiment maps the process elements to the corresponding execution objects, and starts the execution process of the execution objects when the execution objects are called externally, that is, summarizes the behavioral characteristics of various process languages with the execution objects, and realizes the process The driver can not only support the block process language, but also support the graph-like process language, thereby improving the scalability of the process drive; in addition, because the technical solution provided by the embodiment of the present invention is not related to any specific data storage layer Technology and IOC container binding, therefore, has high portability.

Embodiment three

Referring to FIG. 9, this embodiment provides a process driving device, which includes:

A determination module 901, configured to determine the process elements of the process to be driven, and the process behavior corresponding to the process elements;

A mapping module 902, configured to map process elements to corresponding execution objects, and assemble process behaviors of process elements into corresponding execution objects;

The driving module 903 is configured to start the execution process of the execution object when the execution object is called externally.

Specifically, referring to FIG. 10, the driving module 903 specifically includes:

Judging unit 9031, configured to judge whether the business logic corresponding to the execution object can be triggered when the execution object is called externally;

The executing unit 9032 is configured to execute the business logic when the judging unit 9031 judges that the business logic can be triggered;

The instructing unit 9033 is configured to instruct the next operation after the executing unit 9032 finishes executing the business logic.

Further, referring to FIG. 11, the execution unit 9032 specifically includes:

The first calling subunit 9032a is used to call the execution process to execute business logic;

The second calling subunit 9032b is used to call the end process after the execution process called by the first calling subunit 9032a finishes executing business logic;

The third calling subunit 9032c is used to save the state of the execution object in the storage medium when the execution process called by the first calling subunit 9032a needs to execute the business logic for a long time, until the execution of the business logic ends, and calls the wake-up process to perform data processing. Restore, and call the end process after the data is restored.

The device provided in this embodiment maps the process elements to the corresponding execution objects, and starts the execution process of the execution objects when the execution objects are called externally, that is, summarizes the behavioral characteristics of various process languages with the execution objects, and realizes the process The driver can not only support the block process language, but also support the graph-like process language, thereby improving the scalability of the process drive; in addition, because the technical solution provided by the embodiment of the present invention is not related to any specific data storage layer Technology and IOC container binding, therefore, has high portability.

It should be noted that when the process driving device provided in the above embodiment drives the process, it only uses the division of the above-mentioned functional modules as an example for illustration. In practical applications, the above-mentioned function allocation can be completed by different functional modules according to needs. The internal structure of the device is divided into different functional modules to complete all or part of the functions described above. In addition, the process driving device provided in the above embodiment and the process driving method embodiment belong to the same idea, and its specific implementation process is detailed in the method embodiment, and will not be repeated here.

The serial numbers of the above embodiments of the present invention are for description only, and do not represent the advantages and disadvantages of the embodiments.

All or part of the steps in the embodiments of the present invention can be realized by software, and the corresponding software program can be stored in a readable storage medium, such as an optical disk or a hard disk.

The above descriptions are only preferred embodiments of the present invention, and are not intended to limit the present invention. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present invention shall be included in the protection of the present invention. within range.

Claims (7)

1. A flow-driven method, characterized in that the method comprises: Determine the process elements of the process to be driven, and the process behavior corresponding to the process elements; Mapping the process element into a corresponding execution object, and assembling the process behavior of the process element into the corresponding execution object; The execution process of the execution object is started when the execution object is called externally. 2. The method according to claim 1, wherein the starting the execution process of the execution object when calling the execution object externally comprises: Judging whether the business logic corresponding to the execution object can be triggered; If yes, execute the business logic, and indicate the next operation after the execution ends. 3. The method according to claim 2, wherein the executing the business logic specifically comprises: calling the execution process to execute the business logic, and calling the end process after executing the business logic; If the business logic needs to be executed for a long time, the state of the execution object is saved in the storage medium until the execution of the business logic ends, the wake-up process is called for data recovery, and the end process is called after the data recovery. 4. The method according to claim 1, wherein the execution objects are divided into nets, nodes and arcs; Among them, each network contains multiple interconnected nodes and arcs; each node contains multiple input arcs and multiple output arcs; each arc contains at least one input node and one output node. 5. A process drive device, characterized in that the device comprises: A determining module, configured to determine the process elements of the process to be driven, and the process behavior corresponding to the process elements; A mapping module, configured to map the process element to a corresponding execution object, and assemble the process behavior of the process element into the corresponding execution object; The driving module is used to start the execution process of the execution object when the execution object is called externally. 6. The device according to claim 5, wherein the drive module specifically comprises: A judging unit, configured to judge whether the business logic corresponding to the execution object can be triggered when the execution object is called externally; an executing unit, configured to execute the business logic when the judging unit judges that the business logic can be triggered; The instructing unit is configured to instruct the next operation after the execution unit finishes executing the business logic. 7. The device according to claim 6, wherein the execution unit specifically comprises: The first calling subunit is used to call the execution process to execute the business logic; The second calling subunit is used to call the end process after the execution process called by the first calling subunit finishes executing the business logic; The third calling subunit is used to save the state of the execution object in the storage medium when the execution process called by the first calling subunit needs to execute the business logic for a long time until the execution of the business logic ends , call the wake-up process for data recovery, and call the end process after data recovery.

Images