Raible's Wiki: IntegratingJBPMIntoAppFuse

You will use the jbpm-db package to create the jbpm tables in your database for workflow persistence and will author process definitions in Eclispe. And finally you will write some JUnit

classes to test if the integration is working.

AppFuse uses Hibernate

for its default persistence layer. jBPM also uses Hibernate for its persistence layer. It can be configured to either use the same session factory as AppFuse or use its own dedicated session factory.

Font Conventions (work in progress)

[#1] Download jBPM package and install jBPM database

Unzip them into a temporary folder. jBPM uses its own database, before you proceed any further you have to decide whether you will use a dedicated databse for jBPM or use the same database as AppFuse. To keep things simple we will use a dedicated db for jBPM. The following steps will create sql scripts to create/drop jBPM schema.

Create a new user in oracle with the username/pass as jbpm/jbpm. Copy file ojdbc14.jar into jbpm-db/oracle/lib/ directory (if you are not using oracle, copy the neccessary driver to jbpm-db/**database_of_choice**/lib/ directory). Modify hibernate.properties located in jbpm-db/oracle/ directory to reflect your connection information:

You are now ready to generate the scripts. Execute ant oracle.scripts this will generate the scripts in jbpm-db/build/oracle/scripts/ directory. Execute oracle.create.sql in your favorite database tool, I use TOAD

, and voila! jBPM schema should be created and ready for use.

[#2] Add classpath references to the appfuse build process

Copy jbpm/lib/jboss/bsh-1.3.0.jar jbpm/build/jbpm-3.1.2.jar jbpm/build/jbpm.sar.cfg.jar jbpm/build/jbpm-identity-3.1.2.jar to appfuse/lib/jbpm-3.1.2 folder.

[#3] Download and configure Spring Modules for jBPM

At this point we want to ensure that all our previous steps are working so it is a good idea to test the configuration. We will dive into writing more complex definitions later on(using the process design tool in eclipse), for now write a simple process definition as:

Apparently there is another way to reference the mapping files(.hbm.xml) using "org/jbpm/**/**/**.hbm.xml" syntax, however, i couldn't get it to work.

[#4] Test basic configuration




public class ExampleProcessTest extends BaseDaoTestCase {



    JbpmConfiguration config = null;

    JbpmContext context = null;

    ProcessDefinition definition = null;

    

  protected void onSetUpBeforeTransaction() throws Exception {

  config = (JbpmConfiguration) applicationContext.getBean("jbpmConfig");

        context = config.createJbpmContext();

      definition = context.getGraphSession().findLatestProcessDefinition("testProcess");

  }



  public void testProcessDefinition() throws Exception {



      ProcessDefinition def = context.getGraphSession().findLatestProcessDefinition("testProcess");

      

      assertNotNull("Definition should not be null", def);

  }



  public void testStartState() throws Exception {

    

        // The next line creates one execution of the process definition.

        // After construction, the process execution has one main path

        // of execution (=the root token) that is positioned in the

        // start-state.

        ProcessInstance inst = definition.createProcessInstance();

        

        // Also after construction, the main path of execution is positioned

        // in the start-state of the process definition.

        assertEquals("Instance is in start state", definition.getStartState(), inst.getRootToken().getNode());

  

  }



  public void testTransitions() throws Exception {

    

        ProcessInstance inst = definition.createProcessInstance();



        // Let's start the process execution, leaving the start-state 

        // over its default transition.

        inst.signal();

        // The signal method will block until the process execution 

        // enters a wait state.



        // The process execution will have entered the first wait state

        // in state 's'. So the main path of execution is now 

        // positioned in state 's'

        assertEquals("Instance is in 's' state", inst.getRootToken().getNode().getName(), "s");



        // Let's send another signal.  This will resume execution by 

        // leaving the state 's' over its default transition.

        inst.signal();

        // Now the signal method returned because the process instance 

        // has arrived in the end-state.

  

        assertEquals("Instance is in 'end' state", inst.getRootToken().getNode().getName(), "end");

  }



}

A few words regarding the above code. We grab the config bean(previously configured) and use it to initialize a context. Using jBPM context we can make use of all the services defined in the jbpm.cfg file. GraphSession is used to load the latest instance of process definition by executing a hql query (defined in org/jbpm/db/hibernate.queries.hbm.xml). Once we have the defintion we can create instances from that workflow and perform transitions, tasks, adding variables, scheduling etc (more on this later).

The first time you fire up the test, jbpm will initialize and deploy your process defintion to its database. After it has been initialized you should get the green light of junit!

In the next installment we will dive into creating more real-life like (tasks, variables, scheduling, custom queries) process defintions using the graphical plugin tool for Eclipse. We will also cover how to avoid reploying process defintions across server restarts, and finally we will inject some spring beans into our jBPM actions to demonstrate what a poweful and easy workflow mechanism jBPM really is!

Raible's Wiki

AppFuse

Other Applications

IntegratingJBPMIntoAppFuse

About this tutorial

Font Conventions (work in progress)

Table of Contents

[#1] Download jBPM package and install jBPM database

[#2] Add classpath references to the appfuse build process

[#3] Download and configure Spring Modules for jBPM

[#4] Test basic configuration