jBPM Work Items are really simple!

Work items are the way to build custom (domain specific) services that can be used from within a process. They are as any other activity in the process with the difference that they are usually focused on given domain or area.

Work Items are by default placed under Service Tasks category on the palette so can be easily drag and dropped into the canvas when designing processes and cases. Location on the palette is also configurable via category property of the work item definition. So let’s have a guided tour on how to create a very simple but functional work item.

The complete process consists of following steps:

  • generating maven project for work item (both definition and handler)
  • implementing handler and configuring work item
  • optionally provide custom icon (16×16)
  • add work item project into service repository
  • import work item into project in workbench
Let’s get our hands dirty and implement simple work item and then use it in a process.

Generate work item maven project

First step is to generate maven project that will be our base for:
  • work item definition
  • work item handler
First things first, what is work item definition and what is work item handler?
Work Item definition is a description of the work to be done. That is usually described by unique name, description, to make it more visible on the diagram – an icon and then what is expected at the entry (data inputs – parameters) and what is expected at the exit (data output – results).
Work Item handler is a logic that will be actually executed when given activity (representing work item) will be triggered as part of the process instance execution. 
Work Item is then a runtime representation of the Work Item definition that is backed by Work Item handler that is registered in the process engine via Work Item name. This registration gives users additional flexibility to allow usage of different logic to be executed depending where the process is executed – test vs production environment.
So to generate a maven project use maven archetype
mvn archetype:generate 
This command will generate a new project with:

  • groupId – org.jbpm.contrib
  • artifactId – custom-workitem
  • version – 7.8.0-SNAPSHOT
  • with work item configuration and handler class custom-workitem/src/main/java/org/jbpm/contrib/CustomWorkItemHandler.java
I’d like to recommend to generate this project as part of the official jbpm-work-items repository to benefit from service repository included in there. The rest of the article will assume this has been done. 
If you haven’t done it yet, follow these:

  • clone github project: https://github.com/kiegroup/jbpm-work-items
  • go into jbpm-work-items
  • check the version number of the cloned project and adjust version argument accordingly in the maven archetype:generate command
Once the project is generated, import it into your IDE and implement the handler – CustomWorkItemHandler.java. You might need to add additional dependencies to your project, depending your the implementation – when doing so please keep following in mind:
  • dependencies that are already included in KIE Server – mark them as provided
  • check for any conflicts with application server, KIE Server and your app dependencies and resolve them – either by adjusting your handler project dependencies or runtime environment
CustomWorkItemHandler.java class consists of @Wid annotation that is actually responsible for configuring your work item definition. It allows you to define (to name just few):
  • name
  • description
  • category
  • icon
  • input parameters
  • results
  • handler
Most of the important parts are already generated for you, so examine them and check for correctness. Most likely parameters and results will be the one most often changed when implementing handlers.
Once that is done, proceed with implementation of the executeWorkItem method which is the heart of your custom work item.

Expose your work item in Service Repository

Now to take advantage of repository generation of jbpm-work-items project you need to add your newly generated project into two pom files:

  • main pom.xml file of jbpm-work-items project – one regular and one zip dependency
  • <dependency>
  • repository/pom.xml – only zip dependency (but this time without the version tag)
  • <dependency>

When you’re finished just build the project (assuming you’re in jbpm-work-items repository) use following:

mvn clean install -DskipTests -rf :custom-workitem
this will then build your project (custom-work item – adjust it if the artifactId is different) and repositories. Then if you start SpringBoot based Service Repository

java -jar repository-springboot/target/repository-springboot-7.8.0-SNAPSHOT.jar

you’ll have your work item available there, just go to http://localhost:8090/repository

And that’s it, you have your work item implemented, built and exposed via Service Repository!!!

Use work item in workbench

To make use of your newly created work item, login to workbench and:

  • create project
  • create asset – Business Process
  • use the yellow repository icon in the designer menu to open service repository browser
  • select work item and install it
  • reopen process editor and you’ll find your installed work item under Service Tasks category (unless you changed the category when implementing work item)
That’s all you need, in the background when the work item was installed your project was modified to add:
  • dependency to your work item jar (as maven dependency of your workbench’s project)
  • deployment descriptor to register work item handler 
So now you’re ready to launch it – just build and deploy your project in workbench and enjoy your work item being executed.
All this in single screen cast can be found below


Comments are closed.