I’m also referenced by name in the book, a nice pitch for me! I’ve ordered the book and I’ll publish a review later, but from what I’ve seen it looks very promising.

It’s written by Gary Mak of the best-selling Spring Recipes and Josh Long, an expert Spring user and developer.

• Key concepts of Business Process Management to understand how the community leads and implements open source software
• Gain deep understanding of JPDL, the preferred process language, to know how your processes must be defined and implemented
• Convert your projects into fully featured applications with advanced jBPM features such as the persistence service and human task mechanism
• Understand the framework’s behavior in different environments
• Create and configure Human Task activities to model situations where human beings interact with the process
• Understand how the framework handles information that flows through your business process
• Configure the persistence service to reduce risk and perform successful implementations with jBPM
• Improve your process definitions using nodes
• Configure the Eclipse IDE to start modeling your processes

Keep an eye on this blog to read the review.

Regards,
Andries

From the quick start:

Quick Start
 * Download the latest release from http://sourceforge.net/projects/statsvn/
 * Expand the zip file into some directory, e.g c:\statsvn
 * Check out a working copy of the desired SVN module into
 some directory, e.g. c:\myproject.
 * Change into that directory and type
 'svn log --xml -v > svn.log'
 * Change back to the c:\statsvn directory
 * type 'java -jar statsvn.jar c:\myproject\svn.log c:\myproject'
 * Open c:\statsvn\index.html in your web browser

Regards,
Andries

If you still have questions, please post them at the forums. My spies (c.f. Joram) at JBoss keeps me posted of any Spring related topic, and I’m more then happy to answer the questions there.

KR,
Andries

KR,
Andries

Design

Transaction Management

A typical Spring application defines transaction management and ORM definition.  It follows following scheme:

Applications are accessed from the web tier and enter the transactional boundary by invoking service beans. These service beans will access the jBPM services. Spring users expect that all these operations run in a single transaction, which as we’ll see makes testing a lot easier.

In reality, we replace the standard-transaction-interceptor by a spring-transaction interceptor. Instead of starting and committing transactions, we want to reuse any existing transactions (which was already started by Spring).

The same is true for the hibernate session, which will be available through Spring.

Spring Context

JBPM4 comes with multiple contexts, which contains beans. With the SpringContext, we add the Spring Application Context to this set of contexts.

Configuration

Replace the standard-transaction-interceptor with the spring-transaction-interceptor.

The hibernate session needs the attribute current=”true”. This forces jBPM to search for the current session, which will be provided by Spring.

For the Spring context to be known, we created a SpringConfiguration. This extends the JbpmConfiguration but will add itself as a context. The single constructor take the location of the jBPM configuration.

<bean id="jbpmConfiguration" class=”org.jbpm.pvm.internal.cfg.SpringConfiguration”>
   <constructor-arg value="be/inze/spring/demo/jbpm.cfg.xml" />
</bean>

The services can also be defined in the Spring applicationContext, as following:

<bean id="processEngine" factory-bean="jbpmConfiguration" factory-method="buildProcessEngine" />
<bean id="repositoryService" factory-bean="processEngine" factory-method="getRepositoryService" />
<bean id="executionService" factory-bean="processEngine" factory-method="getExecutionService" />

For accessing Spring beans from a process, we need to register the Spring applicationContext. This can be done as following:

<script-manager default-expression-language="juel"
 default-script-language="juel"
 read-contexts="execution, environment, process-engine, spring"
 write-context="">
 <script-language name="juel"
 factory="org.jbpm.pvm.internal.script.JuelScriptEngineFactory" />
 </script-manager>

Use

In jBPM4 most development will happen through the client API aka the services. Simple inject these beans into your transactional service methods and start using them.

Invoking Spring beans from a process can be done as following:

<java name="echo" expr="#{echoService}" method="sayHello" >
    <transition name="to accept" to="join1"/>
 </java>

The scripting engine will look into all contexts from the bean named echoService. If you configured the ScriptManager as above, Spring will be the last context to search for. A good practice is to use unique names for the beans.

Testing

With the AbstractTransactionalJbpmTestCase we can test the process in isolation. Extending from AbstractTransactionalDataSourceSpringContextTests we can test like we test our DAO’s.

Any feedback is appreciated.

KR,
Andries

Resolving Spring Beans

As I mentioned briefly, it is now possible to call Spring beans from a process. Using the scripting, any bean with any parameter can be called from the process.

Testing using AbstractTransactionJbpmTestCase

As we are used in spring-test, we test our processes in a transactional way. Using this class, we can accomplish the same.

The only thing missing now is timer support, which I’ll add before the final release!

Any feedback is welcome,

KR, Andries

The expr resolves the Spring bean. Furthermore, it’s possible to provide parameters, as following:

I’m waiting for the release of RC1 before I’ll update the demo application.

KR,
Andries