Defining and executing processes using declarative programming language constructs

• US 8,108,834 B2
• Filed: 03/21/2007
• Issued: 01/31/2012
• Est. Priority Date: 03/21/2007
• Status: Active Grant

• Current Assignee: SAP SE
• Original Assignee: International Business Machines Corporation
• Inventors: Oren, David, Shachor, Gal
• Primary Examiner(s): Puente, Emerson
• Assistant Examiner(s): SWIFT, CHARLES M
• Application Number:
  US11/688,904
• Publication Number:
  US 20080235682A1
• Time in Patent Office: 1,777 Days
• Field of Search: 717/104, 717/114, 717/117, 709/204
• US Class Current: 717/117
• CPC Class Codes: G06F 8/31 Programming languages or programming paradigms

Abstract

A computer-implemented technique for executing a process is provided. The technique includes providing a class having at least one annotation that defines at least a portion of the process. The annotation is a run-time-readable, non-executable declarative programming construct that is associated with a first method of the class, and specifies at least one transition rule and a second method of the class associated with the transition rule. A process engine, which runs on a computer and is not an instance of the class, parses the annotation to extract the transition rule. The process engine receives a message from a source external to the process engine, and evaluates whether the transition rule is satisfied, responsively to the message. Upon finding that the transition rule is satisfied, the process engine invokes the second method, so as to generate an output with respect to the message. Other embodiments are also described.

Claims

1. A computer-implemented technique for executing a business workflow management process, comprising:

providing a class to a process engine executing on a processing management server, the process engine and the process class being implemented in an object-oriented programming language, the class having at least one annotation that defines at least a portion of a business workflow management process, the process comprising user interactions with distributed services, wherein the annotation is a run-time-readable, non-executable declarative programming construct that is associated with a first method of the class, and specifies at least one transition rule and a second method of the class associated with the transition rule;

executing the first method and the second method of the process class by parsing the annotation to extract the transition rule;

receiving a message at the process engine from a source external to the process engine;

evaluating, by the process engine, whether the transition rule is satisfied, responsively to the message; and

upon finding that the transition rule is satisfied, invoking the second method by the process engine, so as to generate an output with respect to the message.

2. The technique according to claim 1, wherein receiving the message comprises:

waiting for the message to arrive; and

evaluating whether the transition rule is satisfied after the message arrives.

3. The technique according to claim 1, wherein the transition rule specifies an interaction name, wherein parsing comprises extracting the interaction name from the transition rule, wherein receiving the message comprises extracting a descriptive name from the message, and wherein evaluating comprises comparing the interaction name to the descriptive name.

4. The technique according to claim 1, wherein the transition rule specifies a predicate, wherein parsing comprises extracting the predicate from the transition rule, and wherein evaluating comprises evaluating whether the predicate is satisfied.

5. The technique according to claim 4, wherein evaluating whether the predicate is satisfied comprises calling a third method of the class having a method name specified by the predicate, and evaluating a value returned by the third method.

6. The technique according to claim 1, wherein the annotation specifies a plurality of transition rules, and wherein evaluating comprises evaluating whether at least one of the plurality of transition rules is satisfied, responsively to the message.

7. The technique according to claim 1, wherein the annotation includes a first annotation, wherein the transition rule is specified by a second annotation, and wherein providing the class comprises providing the class having the first annotation that specifies the transition rule by including the second annotation as an element of the first annotation.

8. The technique according to claim 1, wherein invoking the second method comprises invoking the second method so as to send the output to the source external to the process engine.

9. The technique according to claim 1, wherein the process includes a business transaction, and wherein evaluating comprises storing a state of the business transaction, and evaluating whether the transition rule is satisfied responsively to the message and the state.

10. The technique according to claim 1, wherein invoking the second method to generate the output comprises invoking the second method to generate the output that invokes a service external to the process engine.

11. The technique according to claim 1, wherein parsing the annotation comprises parsing the annotation at run time.

12. The technique according to claim 11, wherein parsing the annotation at run time comprises using reflection to extract the transition rule.

13. Apparatus for executing a process, comprising a process management server that comprises:

an input interface for receiving a message from a source external to the process management server; and

a processor, which is configured to implement a process engine that is configured to execute a business workflow management process that includes user interactions with distributed services using a code listing, the code listing and the process engine being implemented in an object-oriented programming language, and to load a class that is defined in the listing, the class having at least one annotation that defines at least a portion of the process, wherein the annotation is a run-time-readable, nonexecutable declarative programming construct that is associated with a first method of the class, and specifies at least one transition rule and a second method of the class associated with the transition rule, and wherein the process engine is not an instance of the class, execute the first method and the second method of the class by parsing the annotation to extract the transition rule, evaluate whether the transition rule is satisfied, responsively to the message, and upon finding that the transition rule is satisfied, invoke the second method, so as to generate an output with respect to the message.

14. The apparatus according to claim 13, wherein the transition rule specifies an interaction name, and wherein the process engine is configured to extract the interaction name from the transition rule, extract a descriptive name from the message, and evaluate whether the transition rule is satisfied by comparing the interaction name to the descriptive name.

15. The apparatus according to claim 13, wherein the transition rule specifies a predicate, and wherein the process engine is configured to extract the predicate from the transition rule, and evaluate whether the transition rule is satisfied by evaluating whether the predicate is satisfied.

16. The apparatus according to claim 13, wherein the process includes a business transaction, and wherein the process engine is configured to store a state of the business transaction, and evaluate whether the transition rule is satisfied responsively to the message and the state.

17. A computer software product for executing a process, the product comprising a non-transitory computer-readable medium in which program instructions are stored, which instructions, when read by a computer, cause the computer to execute a business workflow management process that includes user interactions with distributed services using a code listing, and to implement a process engine that loads a class that is defined in the listing, the class having at least one annotation that defines at least a portion of the process, wherein the code listing and the process engine are implemented in an object-oriented programming language, and the annotation is a run-time-readable, non-executable declarative programming construct that is associated with a first method of the class, and specifies at least one transition rule and a second method of the class associated with the transition rule, and wherein the process engine is not an instance of the class;

executes the first method and the second method of the class by parsing the annotation to extract the transition rule;

receives a message from a source external to the process engine;

evaluates whether the transition rule is satisfied, responsively to the message; and

upon finding that the transition rule is satisfied, invokes the second method, so as to generate an output with respect to the message.

18. The product according to claim 17, wherein the transition rule specifies an interaction name, and wherein the instructions cause the process engine to extract the interaction name from the transition rule, extract a descriptive name from the message, and evaluate whether the transition rule is satisfied by comparing the interaction name to the descriptive name.

19. The product according to claim 17, wherein the transition rule specifies a predicate, and wherein the instructions cause the process engine to extract the predicate from the transition rule, and evaluate whether the transition rule is satisfied by evaluating whether the predicate is satisfied.

20. The product according to claim 17, wherein the process includes a business transaction, and wherein the instructions cause the process engine to store a state of the business transaction, and evaluate whether the transition rule is satisfied responsively to the message and the state.