Enterprise Integration Zone is brought to you in partnership with:

John D'Emic is a technologist, developer and author. He is currently a Solutions Architect at MuleSoft and a co-author of both editions of Mule in Action. John is a DZone MVB and is not an employee of DZone and has posted 10 posts at DZone. You can read more from them at their website. View Full User Profile

Getting started with JPA and Mule

07.24.2013
| 3699 views |
  • submit to reddit

Working with managed entities in Mule applications can be difficult.  Since the 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.

Published at DZone with permission of John D'Emic, author and DZone MVB. (source)

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)

Comments

Nishant Sonar replied on Mon, 2013/08/05 - 11:21am

This is a good post John.

Does the JPA Entity Context be defined from the JDBC Endpoints, otherwise the database connections are driven by ServiceImpl classes with @PersistenceContext injected.

In some of my experiments , where I had to query using JDBC Endpoints I was hoping for Mule-JPA where I don't have to write code for ResultSetMapping (Datahandler on JDBC to DTO/VO) but I had to write my mappers separately.

John D'Emic replied on Tue, 2013/09/24 - 11:31am in response to: Nishant Sonar

Thanks Nishant,

You unfortunately can't use the JPA module in direct conjunction with JDBC, although the use case is interesting.  Have you looked at using DataMapper to transform the result of the JDBC endpoint to a domain model?

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.