Getting started with JPA and Mule

gowebing

Working with JPA managed entities in Mule applications can be difficult.  Since the JPA session is not propagated between message processors, transformers are typically needed to produce an entity from a message’s payload, pass it to a component for processing, then serialize it back to an un-proxied representation for further processing.

Transactions have been complicated too.  Its difficult to coordinate a transaction between multiple components that are operating with JPA entity payloads.  Finally the lack of support for JPA queries makes it difficult to  load objects without working with raw SQL and the JDBC transport.

Mule Support for JPA Entities

The JPA module aims to simplify working with JPA managed entities with Mule.  It provides message processors that map to an EntityManager’s methods.  The message processors participate in Mule transactions, making it easy to structure JPA transactions within Mule flows.  The JPA module also provides a @PersistenceContext implementation.  This allows Mule components to participate in JPA transactions.

Installing the JPA Module

To install the JPA Module you need to click on “Help” followed by “Install New Software…” from Mule Studio.  Select the “MuleStudio Cloud Connectors Update Site” from the “Work With” drop-down list then find the “Mule Java Persistence API Module Mule Extension.”  This is illustrated below:

Installing the JPA Module in Mule Studio

Fetching JPA Entities

JPA query language or criteria queries can be executed using the “query” MP.  Supplying a statement to the query will execute the given query and return the results to the next message processor, as illustrated in the following Gist:


<flow name="testQueryWithListParameters">
  <jpa:query statement="from Dog dog where dog.name = ?" queryParameters-ref="#[payload:]"/>
  <vm:outbound-endpoint path="foo"/>
</flow>
The queryParameters-ref defines the parameters.  In this case  the message’s payload as the parameters to the query.  The following query illustrates how a Map payload could be used to populate query parameters: 

<flow name="testQueryWithMapParameters">
   <jpa:query statement="from Dog dog where dog.name = :name and dog.breed = :breed" queryParameters-ref="#[payload:]"/>
</flow>
The query processor also supports criteria queries by setting the queryParameters-ref to an instance of a CriteriaQuery, as illustrated in the functional test snippet below. 
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<Dog> criteriaQuery = criteriaBuilder.createQuery(Dog.class);
Root<Dog> from = criteriaQuery.from(Dog.class);
 
Predicate condition = criteriaBuilder.equal(from.get("name"), "Cujo");
criteriaQuery.where(condition);
 
runFlowWithPayloadAndExpect("testQuery", expectedResults, criteriaQuery);
You can use the  ”find” MP to load a single object if you know its ID: 
<flow name="testFind">
  <jpa:find entityClass="domain.Dog" id-ref="#[payload:]"/>
</flow>

Transactions and Entity Operations

The default behavior of most JPA providers, like Hibernate, is to provide proxies on entity relationships to avoid loading full object graphs into memory.  When these objects are detached from the JPA session, however, attempts to access relations in the object will often fail because the proxied session is no longer available.  This complicates using JPA is Mule applications as JPA objects pass between message processors and inbetween flows and the session subsequently becomes unavailable.

The JPA module allows you to avoid this by wrapping your operations in a transactional block.  Let’s first look at how to persist an object then query it within a transaction.  The below assumes the message’s payload is an instance of the Dog domain class.

<flow name="testTransactionalInsertAndQuery">
    <transactional>
        <jpa:persist/>
        <jpa:query statement="from Dog dog where dog.name = 'Cujo'"/>
    </transactional>
</flow>
Now let’s see how we can use the merge processor to attach a JPA object to a new session.  This can be useful when passing a JPA entity from one flow to another. 
<flow name="testMerge">
     <vm:inbound-endpoint path="in"/>
     <transactional>
        <jpa:merge/>
        ....other processing here....
    </transactional>
    <vm:outbound-endpoint path="foo"/>
</flow>
Detaching an entity is just as simple: 
 <flow name="testDetach">
    <transactional>
        <jpa:detach/>
    </transactional>
</flow>

Component Operations with JPA

The real power of using JPA with Mule is allowing your business services to participate in Mule managed JPA transactions.   A @PersistenceContext EntityManager reference in your component class will cause Mule to inject a reference to a transactional flow’s current EntityManager for that method, as illustrated in the following class:

public class DogServiceImpl {

    @PersistenceContext
    EntityManager entityManager;

    public Dog groom(Dog dog) {
        return entityManager.merge(dog);
    }
    
}
We can now wire the component up in a flow: 
<flow name="dogGroomingFlow">
    <vm:inbound-endpoint path="dog.groom.in"/>
    <transactional>
        <jpa:merge/>
        <component class="service.DogServiceImpl"/>
     </transactional>
     <vm:outbound-endpoint path="dog.groom.out"/>
</flow>

Conclusion

JPA is an important  part of the JEE ecosystem and hopefully this module will simplify your use of JPA managed entities in Mule applications.

 

 

 

 

Top