These structures are static representations of our business processes. In Chapter 3, Using BPMN 2.0 to Model Business Scenarios, we will see how these representations can be written by technical people and different domain experts in detail; we do this using an XML standard called BPMN 2.0 for process definition and graphical representation.

However, from the process engine's internal perspective, these representations are far from the actual process structure that the engine is prepared to handle. In order for the engine to get those structures generated, it requires the previously described semantic module to transform those representations into the required object structure.

The following figure shows how this parsing process happens as well as the resultant structure:

Using a process modeler, business analysts can draw business processes by dragging-and-dropping different activities from the modeler palette. For jBPM6, there is a web-based modeler designed to draw Scalable Vector Graphics (SVG) files; this is a type of image file that has the particularity of storing the image information using XML text, which is later transformed into valid BPMN2 files.

Note that both BPMN2 and jBPM6 are not tied up together. On one hand, the BPMN2 standard can be used by other process engine provides such as Activiti or Oracle BPM Suite. Also, because of the semantic module, jBPM6 could easily work with other parsers to virtually translate any form of textual representation of a process to its internal structures.

In the internal structures, we have a root component (called Process in our case, which is finally implemented in a class called RuleFlowProcess) that will contain all the steps that are represented inside the process definition.

From the jBPM6 perspective, you can manually create these structures using nothing but the objects provided by the engine. Inside the jBPM6-Quickstart project, you will find a code snippet doing exactly this in the createProcessDefinition() method of the ProgrammedProcessExecutionTest class:

//Process Definition
RuleFlowProcess process = new RuleFlowProcess();
process.setId("myProgramaticProcess");

//Start Task
StartNode startTask = new StartNode();
startTask.setId(1);

//Script Task
ActionNode scriptTask = new ActionNode();
scriptTask.setId(2);
DroolsAction action = new DroolsAction();
action.setMetaData("Action", new Action() {
    @Override
    public void execute(ProcessContext context) throws Exception {
        System.out.println("Executing the Action!!");
    }
});
scriptTask.setAction(action);

//End Task
EndNode endTask = new EndNode();
endTask.setId(3);

//Adding the connections to the nodes and the nodes to the processes
new ConnectionImpl(startTask, "DROOLS_DEFAULT", 
        scriptTask, "DROOLS_DEFAULT");
new ConnectionImpl(scriptTask, "DROOLS_DEFAULT", 
        endTask, "DROOLS_DEFAULT");
process.addNode(startTask);
process.addNode(scriptTask);
process.addNode(endTask);

Using this code, we can manually create the object structures to represent the process shown in the following figure:

This process contains three components: a start node, a script node, and an end node. In this case, this simple process is in charge of executing a simple action. The start and end tasks simply specify a sequence.

Even if this is a correct way to create a process definition, it is not the recommended one (unless you're making a low-level functionality test). Real-world, complex processes are better off being designed in a process modeler, with visual tools, and exported to standard representations such as BPMN 2.0. The output of both the cases is the same; a process object that will be understandable by the jBPM6 runtime. While we analyze how the process instance structures are created and how they are executed, this will do.

Process instances represent the running processes and all the information being handled by them. Every time you want to start a process execution, the engine will create a process instance. Each particular instance will keep track of all the activities that are being created by its execution.

In jBPM6, the structure is very similar to that of the process definitions, with one root structure (the ProcessInstance object) in charge of keeping all the information and NodeInstance objects to keep track of live nodes. The following code shows a simplification of the methods of the ProcessInstance implementation:

public class RuleFlowProcessInstance implements ProcessInstance {
  public RuleFlowProcess getRuleFlowProcess() { ... }
  public long getId() { ... }
  public void start() { ... }
  public int getState() { ... }
  public void setVariable(String name, Object value) { ... }
  public Collection<NodeInstance> getNodeInstances() { ... }
  public Object getVariable(String name) { ... }
}

After its creation, the engine calls the start() method of ProcessInstance. This method seeks StartNode of the process and triggers it. Depending on the execution of the path and how different nodes connect between each other, other nodes will get triggered until they reach a safe state where the execution of the process is completed or awaiting external data.

You can access the internal parameters that the process instance has through the getVariable and setVariable methods. They provide local information from the particular process instance scope.