Generating the metamodel turned out to be somewhat harder than I first thought. Since I’m a JBoss alcoholic, I’m using Hibernate as persistence provider with and the jpamodelgen subproject.

Generating the metamodel

According to the official documentation, all we need to do is add the hibernate-jpamodelgen to the classpath.

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-jpamodelgen</artifactId>
</dependency>

However, this resulted  in nothing. The only thing that did work for me was adding extra configuration with maven-annotation-plugin.

<plugin>
    <groupId>org.bsc.maven</groupId>
    <artifactId>maven-processor-plugin</artifactId>
    <executions>
        <execution>
            <id>process</id>
            <goals>
                <goal>process</goal>
            </goals>
            <phase>generate-sources</phase>
            <configuration>
                <!-- source output directory -->
                <outputDirectory>
target/metamodel
</outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>
<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>build-helper-maven-plugin</artifactId>
    <version>1.3</version>
    <executions>
        <execution>
            <id>add-source</id>
            <phase>generate-sources</phase>
            <goals>
                <goal>add-source</goal>
            </goals>
            <configuration>
                <sources>
                    <source>target/metamodel</source>
                </sources>
            </configuration>
        </execution>
    </executions>
</plugin>

Success! The User.java file

@Entity
public class User implements UserDetails {
 /** The Constant serialVersionUID. */
 private static final long serialVersionUID = 1L;
 /** The user name. */
 @Id
 @Column(name = "USER_ID")
 @Size(min = 3, max = 10)
 private String username;
 /** The password. */
 @NotNull
 @Size(min = 6, max = 40)
 @Column(name = "PASSWORD")
 private String password;
 /** The name. */
 @Column(name = "NAME")
 private String name;
 /** The first name. */
 @Column(name = "FIRSTNAME")
 private String firstName;

was transformed into User_.java

import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.StaticMetamodel;
@StaticMetamodel(User.class)
public abstract class User_ {
 public static volatile SingularAttribute<User, String> username;
 public static volatile SingularAttribute<User, String> name;
 public static volatile SingularAttribute<User, String> firstName;
 public static volatile SingularAttribute<User, String> password;
}

Now we can use the model to do typysafe queries:

public UserDetails loadUserByUsername(final String username) throws UsernameNotFoundException,
 DataAccessException {
 CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
 CriteriaQuery<User> criteriaQuery = criteriaBuilder.createQuery(User.class);
 Root<User> u = criteriaQuery.from(User.class);
 Predicate usernameCondition = criteriaBuilder.equal(u.get(User_.username), username);
 criteriaQuery.where(usernameCondition);
 TypedQuery<User> query = entityManager.createQuery(criteriaQuery);
 try {
 return (User) query.getSingleResult();
 } catch (NoResultException e) {
 throw new UsernameNotFoundException("User not found: " + username, e);
 }
 }

18:00 – 19:00: Kabir Khan - What’s Cooking in JBoss AS 6

Kabir will talk about the JBoss AS 6 roadmap, the new development model, ongoing optimizations since AS 6. He will also give a bird’s eye overview of the new projects that will be bundled in AS 6, such as Weld, HornetQ, RestEasy and several more. There will be a short demo at the end showing some of the new features in AS.

19:00 – 20:00: Kris Verlaenen – Looking forward to the future of (j)BPM

There’s much going on in the area of BPM. This presentation will offer you an overview of how the jBPM project will continue to offer you business processes support (in their entire life cycle), while also taking these new challenges into account, like more dynamic or adaptive processes, standardization using the BPMN2 process definition language, etc.

I think we can all agree on the fact that these talks will be very interesting (to say the least).
So… do not forget to register for this event! (Maximium capacity is set to 45 people)

See you soon on the 3rd of June at Xplore premises!

• 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

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

I have chosen a typical JSF-Spring-Hibernate stack as a base, and added jbpm4. The demo starts simple processes, just to prove the integration is a working fact.

This is release 0.1, which means I just finished a rudimentary version. However, I’ll keep updating and adding following features:

• Timers
• Forks
• Invoking Spring beans
• …

Don’t hesitate to subscribe so you’ll find out when newer versions are available.

Installation from SVN

1. Checkout
   

   svn checkout 
   http://jbpm4-spring-demo.googlecode.com/svn/trunk/
   jbpm4-spring-demo-read-only
   (All on 1 line)
   

2. Download the jbpm4 maven dependencies. The spring integration is not yet part of any released jbpm4. Extract them into the org folder in your .m2/repository folder.
3. enter following maven command in your checked out folder:

    mvn jetty:run

Running just the WAR:

1. Download the war file.
2. Drop it into jboss, tomcat, … and run it.

The integration:

If you would like to find more information about how it’s done, please look at my slides here.

The short version: We remove some dependencies from the jbpm-config, and add them into the spring-config. The integration will then search the required dependencies in the jbpm-contexts and then move on to the spring-context.

The dependencies we want Spring to provide are following:

• Hibernate Session factory
• Transaction Manager

But in essence other dependencies could be added. Since jBPM4 uses Hibernate for persistence, we need to add the mapping files to the sessionfactory:
From applicationContext-common.xml:

<bean id="sessionFactory"
	class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
	<property name="dataSource" ref="dataSource" />
	<property name="hibernateProperties">
		<props>
			<prop key="hibernate.dialect">org.hibernate.dialect.HSQLDialect</prop>
			<prop key="hibernate.show_sql">true</prop>
			<prop key="hibernate.hbm2ddl.auto">create-drop</prop>
		</props>
	</property>
	<property name="configLocations">
		<list>
			<value>classpath:be/inze/spring/demo/hibernate.cfg.xml</value>
		</list>
		</property>
	<property name="mappingLocations">
		<list>
			<value>classpath:jbpm.execution.hbm.xml</value>
			<value>classpath:jbpm.repository.hbm.xml</value>
			<value>classpath:jbpm.jpdl.hbm.xml</value>
			<value>classpath:jbpm.task.hbm.xml</value>
			<value>classpath:jbpm.history.hbm.xml</value>
		</list>
	</property>
</bean>

Own hbm files can be added as well (or mixed with annotations).

The jbpm.cfg.xml has been altered a bit. Changes (2 of them) are marked in bold:
From jbpm.cfg.xml:

<?xml version="1.0" encoding="UTF-8"?>
<jbpm-configuration xmlns="http://jbpm.org/xsd/cfg">
  <process-engine-context>
    <repository-service />
    <repository-cache />
    <execution-service />
    <history-service />
    <management-service />
    <task-service />
    <identity-service />
    <command-service>
      <retry-interceptor />
      <environment-interceptor />
      <spring-transaction-interceptor current="true"/>
    </command-service>
    <hibernate-configuration>
      <cfg resource="jbpm.hibernate.cfg.xml" />
    </hibernate-configuration>
    <deployer-manager>
      <jpdl-deployer />
    </deployer-manager>
    <script-manager default-expression-language="juel"
                    default-script-language="juel"
                    read-contexts="execution, environment,
                                   process-engine"
                    write-context="">
        <script-language name="juel"
factory="org.jbpm.pvm.internal.script.JuelScriptEngineFactory" />
    </script-manager>
    <authentication />
    <job-executor auto-start="false" />
    <id-generator />
    <types resource="jbpm.variable.types.xml" />
    <business-calendar>
      <monday    hours="9:00-12:00 and 12:30-17:00"/>
      <tuesday   hours="9:00-12:00 and 12:30-17:00"/>
      <wednesday hours="9:00-12:00 and 12:30-17:00"/>
      <thursday  hours="9:00-12:00 and 12:30-17:00"/>
      <friday    hours="9:00-12:00 and 12:30-17:00"/>
      <holiday period="01/07/2008 - 31/08/2008"/>
    </business-calendar>
  </process-engine-context>
  <transaction-context>
    <repository-session />
    <pvm-db-session />
    <job-db-session />
    <task-db-session />
    <message-session />
    <timer-session />
    <history-session />
    <transaction />
    <hibernate-session />
    <hibernate-session current="true" />
    <identity-session />
  </transaction-context>
</jbpm-configuration>

spring-transaction-interceptor: The standard-transaction-interceptor will start and commit transactions. Instead, we want jbpm to reuse an existing transaction. The current=true forces the interceptor to check if a transaction already exists. It will crash else. On current=false, a new transaction will be created.

<hibernate-session current=”true” />: The current=true defines that we will use the hibernate-session that is available, no new one will be created.

Exposing beans:

When configuration is done, one can access the beans as follows:

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

Feedback

Any feedback, positive AND negative is highly appreciated, either by comment or mail me at

noop field type

noop field’s are columns that exist in the database, but not in your class. Sometimes handy for calculated values are connecting to legacy databases. We actually encountered such a use case, where the data conversion from an old application gave some data which we didn’t want to see or alter in the new application. But as a reporting query, we did want to show which data was old. We actually didn’t use the noop (didn’t knew about it), but it would have made a great use case.

NamingStrategy

In my first project, we declared naming standards for tables and column. Although we abide them, we did it manually. The NamingStrategy would let us declare those standards automatically. In our use case, we suffixed Boolean columns with _B, and enum states with _S , etc… . A good NamingStrategy would have done this automatically.

Bags don’t need to be loaded when inserts happen

Since no filtering or ordering is required, one can insert data into a Bag, without triggering the lazy loading of the entire bag. This is, in a lot of use cases, a great performance gain. In our teams, we do batch processing regularly where we insert a lot of data. This would have been faster if we used the Bag interface (instead of the more common Set).

Replicating

You can compare it with merging, but only you are not reattaching a detached object, you are attaching an object with a different database. Never ever had to use this, but it was still a gem I didn’t know about.

Persist() vs save()  (persist does not cascade)

I just didn’t know this. What would be a good use case for this?

.addEntity

session.createSQLQuery(
“select {c.*} from CATEGORY {c} where NAME like ‘Laptop%’”
).addEntity(“c”, Category.class);

HQL new keyword

I’m absolutely crazy about this one. Following is a standard idiom in the projects I’ve worked in: we do some search query with HQL and we map, by hand, the result into our own custom created result object. All the mapping, type conversion etc we do is just a waste of time! Don’t know what I’m talking about? Here is an example:

select new UserSearchResult(u.id, u.name, u.birthDate) from User u where …

The UserSearchResult is a plain POJO (with either needs to be declared or fully qualified). The solution is simple and clean. Absolutely love it!

Query.setProperties()

This one is also a type-safer (as in life-saver). Fill in the entire object and let HQL get the values by reflection. Beats the hell out of determining setString or setDouble etc.

Item item = new Item();
item.setSeller(seller);
item.setDescription(description);
String queryString = “from Item item”
+ ” where item.seller = :seller and item.description like :description”;
session.createQuery(queryString).setProperties(item);

It again safes you some typing.

Query hints

FlushMode: very good for search results and batch jobs (will not trigger a flush before the query)

setReadonly: very good for search results (disabled dirty checking)

setTimeout: a default should be set for every query.
Actually this is very important. We have had applications which, due to bug or db crash, kept a lock for hours. No (normal) query should take more then, oh lets say, 60sec. Setting the timeout on all query to this is a safe precaution.

Using named queries

Using named queries abstracts the query definition from your DAO layer. I believe this to be a nice addition, something that could be done after the implementation. You can define the query on class level (in the class.hbm.xml) or on an application wide scope, so you can reuse them across multiple DAO’s. Never actually came across a query I’d reuse across multiple dao’s though…

MatchMode.START

On most of my projects we write a DaoUtil that would prefix/suffix the search input, with the right wild card. Now it seems Hibernate provided a shortcut to this (all along).
e.g. Restrictions.like(“streetname”, “G”, MatchMode.START)

Projections.projectionList

This let’s you search on some fields, instead of complete objects using Criteria. I’ve always found it strange that Criteria queries only returned complete objects. Seems that my ignorance was to blame

session.createCriteria(User.class)
.setProjection( Projections.projectionList()
.add( Property.forName(“id”) )
.add( Property.forName(“username”) )
.add( Property.forName(“birthDate”) )
);

Conclusion

Never too old to learn?

You can’t learn everything the first time round. It’s only after larger experience you truly start to see all the finesse of a framework. I truly believe in studying everything twice. With Spring, I had the same insight after going back 2 basic on it after doing a complete project with it. Now with Hibernate, I see the same enlightement for me.

The book is intended as an good introduction into the BPM world, primarily for Business Analysts. For developers it promises a useful introduction to the key concepts with directions for implementing BPM the right way.

Things I didn’t like:

Let’s start with the easy part, trashing parts of the book. My first thought I had when I received the book, is that it’s rather small. With only a good 200 pages, stuffed with screenshots and code examples, the book is practically read in a day. And that is with every exercise made. Of course, you could also argue this is positive, but this brings me to my second issue: the book is not thoroughly enough for developers. I like to code and I need coding guidelines to do that. This book does not provide that.

Things I liked:

It’s a good thing that there are a lot more things I liked about the book. Firstly, the book actually delivers what it says: providing a good introduction into the jBPM world. Instead of being a reference book, it’s a hands-on book for Business Analysts. It’s short, to the point and very easy to read cover to cover.

The code examples just work! This seems normal, but it ain’t. I’ve read my share of books where the examples always needed a little magic to work. There is one catch: the examples work for jBPM Designer 3.2 (suite). They do not work with 3.2.2. I don’t know why or how, but the 3.2.2 version actually has LESS features then the older version. Took me a while to find it. (Actually, this is a negative…).

There is always a trade-off: provide a decent small examples, or deliver a large complete example. This book chose the latter, which would be way to large if they didn’t provide the example in real code, for each chapter. So you can start the next chapter with only the code you would have written in the previous one. Very well done! Makes it all the more fun to actually follow the examples throughout the book.

It handles stuff that’s pure BPM, and not only jBPM. It talks about kick-off meetings, project sponsors and SME‘s. This helps deliver a good broad image of BPM.

Conclusion

I recommend this book to anyone who wants to learn about jBPM. It’s actually a fantastic book, if you know what it will deliver. Hands one experience from a business analysts view, nothing more, nothing less! For a developer like myself, it doesn’t provide the answers to actually create a full-wedged application with it, but it’ll help paving the way.

Andries