JBoss.org Community Documentation

- Prev
- Next

## Chapter 13. Domain-specific processes

## 13.1. Introduction

One of the goals of jBPM is to allow users to extend the default process constructs with domain-specific extensions that simplify development in a particular application domain. This tutorial describes how to take your first steps towards domain-specific processes. Note that you don't need to be a jBPM expert to define your own domain-specific nodes, this should be considered integration code that a normal developer with some experience in jBPM can do himself.

Most process languages offer some generic action (node) construct that allows plugging in custum user actions. However, these actions are usually low-level, where the user is required to write custom code to implement the work that should be incorporated in the process. The code is also closely linked to a specific target environment, making it difficult to reuse the process in different contexts.

Domain-specific languages are targeted to one particular application domain and therefore can offer constructs that are closely related to the problem the user is trying to solve. This makes the processes and easier to understand and self-documenting. We will show you how to define domain-specific work items (also called service nodes), which represent atomic units of work that need to be executed. These service nodes specify the work that should be executed in the context of a process in a declarative manner, i.e. specifying what should be executed (and not how) on a higher level (no code) and hiding implementation details.

So we want service nodes that are:

1. domain-specific

2. declarative (what, not how)

3. high-level (no code)

4. customizable to the context

Users can easily define their own set of domain-specific service nodes and integrate them in our process language. For example, the next figure shows an example of a process in a healthcare context. The process includes domain-specific service nodes for ordering nursing tasks (e.g. measuring blood pressure), prescribing medication and notifying care providers.

## 13.2. Example: Notifications

Let's start by showing you how to include a simple work item for sending notifications. A work item represent an atomic unit of work in a declarative way. It is defined by a unique name and additional parameters that can be used to describe the work in more detail. Work items can also return information after they have been executed, specified as results. Our notification work item could thus be defined using a work definition with four parameters and no results:

      Name: "Notification"
      Parameters
      From [String]
      To [String]
      Message [String]
      Priority [String]

### 13.2.1. Creating the work definition

All work definitions must be specified in one or more configuration files in the project classpath, where all the properties are specified as name-value pairs. Parameters and results are maps where each parameter name is also mapped to the expected data type. Note that this configuration file also includes some additional user interface information, like the icon and the display name of the work item.

In our example we will use MVEL for reading in the configuration file, which allows us to do more advanced configuration files. This file must be placed in the project classpath in a directory called META-INF. Our MyWorkDefinitions.wid file looks like this:

    import org.drools.process.core.datatype.impl.type.StringDataType;
    [
      // the Notification work item
      [
        "name" : "Notification",
        "parameters" : [
          "Message" : new StringDataType(),
          "From" : new StringDataType(),
          "To" : new StringDataType(),
          "Priority" : new StringDataType(),
        ],
        "displayName" : "Notification",
        "icon" : "icons/notification.gif"
      ]

    ]

The project directory structure could then look something like this:

    project/src/main/resources/META-INF/MyWorkDefinitions.wid

You might now want to create your own icons to go along with your new work definition. To add these you will need .gif or .png images with a pixel size of 16x16. Place them in a directory outside of the META-INF directory, for example as follows:

    project/src/main/resources/icons/notification.gif

### 13.2.2. Registering the work definition

The configuration API can be used to register work definition files for your project using the drools.workDefinitions property, which represents a list of files containing work definitions (separated usings spaces). For example, include a drools.rulebase.conf file in the META-INF directory of your project and add the following line:

      drools.workDefinitions = MyWorkDefinitions.wid

This will replace the default domain specific node types EMAIL and LOG with the newly defined NOTIFICATION node in the process editor. Should you wish to just add a newly created node definition to the existing palette nodes, adjust the drools.workDefinitions property as follows including the default set configuration file:

      drools.workDefinitions = MyWorkDefinitions.conf WorkDefinitions.conf

### 13.2.3. Using your new work item in your processes

Once our work definition has been created and registered, we can start using it in our processes. The process editor contains a separate section in the palette where the different service nodes that have been defined for the project appear.

Using drag and drop, a notification node can be created inside your process. The properties can be filled in using the properties view.

Apart from the properties defined by for this work item, all work items also have these three properties:

1. Parameter Mapping: Allows you map the value of a variable in the process to a parameter of the work item. This allows you to customize the work item based on the current state of the actual process instance (for example, the priority of the notification could be dependent of some process-specific information).

2. Result Mapping: Allows you to map a result (returned once a work item has been executed) to a variable of the process. This allows you to use results in the remainder of the process.

3. Wait for completion: By default, the process waits until the requested work item has been completed before continuing with the process. It is also possible to continue immediately after the work item has been requested (and not waiting for the results) by setting "wait for completion" to false.

Here is an example that creates a domain specific node to execute Java, asking for the class and method parameters. It includes a custom java.gif icon and consists of the following files and resulting screenshot:

    import org.drools.process.core.datatype.impl.type.StringDataType;
    [
      // the Java Node work item located in:
      // project/src/main/resources/META-INF/JavaNodeDefinition.conf
      [
        "name" : "JavaNode",
        "parameters" : [
          "class" : new StringDataType(),
          "method" : new StringDataType(),
        ],
        "displayName" : "Java Node",
        "icon" : "icons/java.gif"
      ]

    ]

    // located in: project/src/main/resources/META-INF/drools.rulebase.conf
    //
      drools.workDefinitions = JavaNodeDefinition.conf WorkDefinitions.conf

    // icon for java.gif located in:
    // project/src/main/resources/icons/java.gif

### 13.2.4. Executing service nodes

The jBPM engine contains a WorkItemManager that is responsible for executing work items whenever necessary. The WorkItemManager is responsible for delegating the work items to WorkItemHandlers that execute the work item and notify the WorkItemManager when the work item has been completed. For executing notification work items, a NotificationWorkItemHandler should be created (implementing the WorkItemHandler interface):

    package com.sample;

    import org.drools.runtime.process.WorkItem;

    import org.drools.runtime.process.WorkItemHandler;

    import org.drools.runtime.process.WorkItemManager;

    public class NotificationWorkItemHandler implements WorkItemHandler {

      public void executeWorkItem(WorkItem workItem, WorkItemManager manager) {

        // extract parameters

        String from = (String) workItem.getParameter("From");

        String to = (String) workItem.getParameter("To");

        String message = (String) workItem.getParameter("Message");

        String priority = (String) workItem.getParameter("Priority");

        // send email

        EmailService service = ServiceRegistry.getInstance().getEmailService();

        service.sendEmail(from, to, "Notification", message);

        // notify manager that work item has been completed

        manager.completeWorkItem(workItem.getId(), null);

      }

      public void abortWorkItem(WorkItem workItem, WorkItemManager manager) {

        // Do nothing, notifications cannot be aborted

      }

    }

This WorkItemHandler sends a notification as an email and then immediate notifies the WorkItemManager that the work item has been completed. Note that not all work items can be completed directly. In cases where executing a work item takes some time, execution can continue asynchronously and the work item manager can be notified later. In these situations, it might also be possible that a work item is being aborted before it has been completed. The abort method can be used to specify how to abort such work items.

WorkItemHandlers should be registered at the WorkItemManager, using the following API:

    ksession.getWorkItemManager().registerWorkItemHandler(

        "Notification", new NotificationWorkItemHandler());

Decoupling the execution of work items from the process itself has the following advantages:

1. The process is more declarative, specifying what should be executed, not how.

2. Changes to the environment can be implemented by adapting the work item handler. The process itself should not be changed. It is also possible to use the same process in different environments, where the work item handler is responsible for integrating with the right services.

3. It is easy to share work item handlers across processes and projects (which would be more difficult if the code would be embedded in the process itself).

4. Different work item handlers could be used depending on the context. For example, during testing or simulation, it might not be necessary to actually execute the work items. In this case specialized dummy work item handlers could be used during testing.

- PrevChapter 12. Human Tasks
- Top of page
- Front page
- NextChapter 14. Testing and debugging