A Guide to jBPM with Java

1. Introduction

In this tutorial, we’ll discuss the Business Process Management (BPM) System and its implementation in Java as jBPM System.

2. Business Process Management System

We can define Business Process Management as one of those fields whose scope extends beyond development to all aspects of a company.

BPM provides visibility towards the functional processes of the company. This allows us to find an optimal flow, depicted by a flow chart, by using iterative improvement. The improved flow increases profits and reduces costs.

BPM defines its own objectives, life cycle, practices, and a common language between all its participants, i.e., business processes.

3. The jBPM System

jBPM is the implementation of a BPM System in Java. It allows us to create a business process flow, execute it, and monitor its life cycle. The core of jBPM is a workflow engine, written in Java, that provides us with a tool to create and execute a process flow using the latest Business Process Modeling Notation (BPMN) 2.0 specifications.

jBPM focuses mainly on the executable business process. These processes have enough details so that they can be executed on the workflow engine.

Here is a graphical flowchart example of the execution order of our BPMN process model to aid in our understanding:

1. We start executing the flow using the initial context, denoted by the green start node
2. First, Task 1 will execute
3. On the completion of Task 1, we’ll proceed with Task 2
4. The execution stops upon encountering the red end node

4. IDE Plugins for jBPM Project

Let’s see how to install plugins to create a jBPM project and a BPMN 2.0 process in Eclipse and IntelliJ IDEA.

4.1. Eclipse Plugin

We’ll need to install a plugin to create jBPM projects. Let’s follow the steps below:

1. In the Help section, click on Install New Software
2. Add the Drools and jBPM update site
3. Accept the terms of license agreement and complete the plugin installation
4. Restart Eclipse

Once Eclipse restarts, we’ll need to go to Windows -> Preferences -> Drools -> Drools Flow Nodes:

After selecting all the options, we can click on “Apply and Close”. Now, we’re ready to create our first jBPM Project.

4.2. IntelliJ IDEA Plugin

IntelliJ IDEA has jBPM plugin installed by default, but that’s present only in the Ultimate and not the Community option.

We just need to enable it by clicking Configure -> Settings -> Plugins -> Installed -> JBoss jBPM:

Currently, there is no BPMN 2.0 process designer for this IDE, though we can import the *.bpmn files from any other designer and run them.

4.3. Running with JDK 21

The java.lang.Compiler was removed in JDK 21. Running with the JDK 21 we need to add the mvel2 dependency (an expression language  library) as follows:

<dependency>
    <groupId>org.mvel</groupId>
    <artifactId>mvel2</artifactId>
    <version>2.5.2.Final</version>
</dependency>

5. Hello World Example

Let’s get our hands dirty in creating a simple Hello World project.

5.1. Create a jBPM Project

To create a new jBPM project in Eclipse, we’ll go to File -> New -> Other -> jBPM Project (Maven). After providing the name of our project we can hit finish. Eclipse will do all the hard work for us and will download the required Maven dependencies to create a sample jBPM project for us.

To create the same in IntelliJ IDEA, we can go to File -> New -> Project -> JBoss Drools. The IDE will download all the required dependencies and place them in the lib folder of the project.

5.2. Create the Hello World Process Model

Let’s create a small BPM process model that prints “Hello World” in the console.

For this, we need to create a new BPMN file under src/main/resources:

The file extension is .bpmn and it opens in the BPMN designer:

The left panel of the designer lists the nodes we selected earlier while setting up the Eclipse plugin. We’re going to use these nodes to create our process model. The middle panel is the workspace, where we’ll create the process models. The right side is the properties tab, where we can set the properties of a process or node.

In this HelloWorld model, we’ll be using the:

• Start Event – required to start the process instance
• Script Task – enables Java snippets
• End Event – required to end the process instance

As mentioned earlier, IntelliJ IDEA doesn’t have a BPMN designer, but we can import the .bpmn files designed in Eclipse or a web designer.

5.3. Declare and Create the Knowledge Base (kbase)

All the BPMN files are loaded in kbase as processes. We need to pass the respective process ids to the jBPM engine in order to execute them.

We’ll create the kmodule.xml under the resources/META-INF with our kbase and BPMN file package declaration:

<kmodule xmlns="http://jboss.org/kie/6.0.0/kmodule">
    <kbase name="kbase" packages="com.baeldung.bpmn.process" />
</kmodule>

Once the declaration is done, we can use the KieContainer to load the kbase:

KieServices kService = KieServices.Factory.get();
KieContainer kContainer = kService.getKieClasspathContainer();
KieBase kbase = kContainer.getKieBase(kbaseId);

5.4. Create the jBPM Runtime Manager

We’ll use the JBPMHelper present in the org.jbpm.test package to build a sample runtime environment.

We require two things to create the environment: first, a data source to create the EntityManagerFactory, and second, our kbase.

JBPMHelper has methods to start an in-memory H2 server and set the data source. Using the same, we can create the EntityManagerFactory:

JBPMHelper.startH2Server();
JBPMHelper.setupDataSource();
EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit);

Once we’ve got everything ready, we can create our RuntimeEnvironment:

RuntimeEnvironmentBuilder runtimeEnvironmentBuilder = 
  RuntimeEnvironmentBuilder.Factory.get().newDefaultBuilder();
RuntimeEnvironment runtimeEnvironment = runtimeEnvironmentBuilder.
  entityManagerFactory(emf).knowledgeBase(kbase).get();

Using the RuntimeEnvironment, we can create our jBPM runtime manager:

RuntimeManager runtimeManager = RuntimeManagerFactory.Factory.get()
  .newSingletonRuntimeManager(runtimeEnvironment);

5.5. Execute Process Instance

Finally, we’ll use the RuntimeManager to get the RuntimeEngine:

RuntimeEngine engine = manager.getRuntimeEngine(initialContext);

Using RuntimeEngine, we’ll create a knowledge session and start the process:

KieSession ksession = engine.getKieSession();
ksession.startProcess(processId);

The process will start and print Hello World on the IDE console.

6. Conclusion

In this article, we introduced the BPM System, using its Java implementation —  jBPM.

To execute the process, we simply need to run the main method in the WorkflowProcessMain class.