Be productive developing Enterprise AJAX Applications

Javier Paniza

Subscribe to Javier Paniza: eMailAlertsEmail Alerts
Get Javier Paniza via: homepageHomepage mobileMobile rssRSS facebookFacebook twitterTwitter linkedinLinkedIn

Related Topics: Java EE Journal, Java Developer Magazine

Java Developer : Article

Are the JPA Callback Methods Useful?

The restrictions JPA imposes on callback methods made them practically useless in real-life applications

Definitely no. The section 3.5 of JPA specification states:

"In general, the lifecycle method of a portable application should not invoke EntityManager or Query operations, access other entity instances, or modify relationships within the same persistence context. A lifecycle callback method may modify the non-relationship state of the entity on which it is invoked."

Surely these restrictions have a good technical reason behind them, but from a business application developer perspective they mean that JPA callback methods are practically useless.

For example, these scenarios are typical:

  • In order to remove some entity we need to verify if some data exists, and we want do it using a JPA query.
  • When an entity is saved, some other entities must be automatically created and saved, and we want to use the JPA EntityManager to do so.

Unfortunately, it's difficult to solve such cases using the standard annotations: @PrePersist, @PostPersist, @PreRemove, @PostRemove, @PreUpdate, @PostUpdate or @PostLoad.

What can we do?
We have several options such as:

  • Using JDBC from the callback methods: Horror!
  • Create a new EntityManager in the callback method: This works sometimes, but you can have problems with isolation levels. Moreover, you lose the transactional behavior.
  • Put the on-save or on-remove logic in the controller layer, that is in the actions. Of course, this works just fine, but if you access the entities from other actions, from a batch process, or from a web service, the on-logic or on-remove will not be executed.

Obviously, these options are messy and unnatural, and even worse, they mean more work for us.

Create your own callback annotations
In OpenXava, we have opted for the simplest solution for the poor application developer, just creating some new callback annotations that allow them to use JPA inside them. OpenXava 4.0.1 includes the next new annotations: @PreCreate, @PostCreate and @PreDelete.

For example, if we need to create a customer and assign it to an invoice when the customer is not specified, you can write:

public void onPreCreate() {
// Automatically create a new customer
if (getCustomer() == null) {
Customer cust = new Customer();
cust = XPersistence.getManager().merge(cust); // Here we use the EntityManager
setCustomer(cust); // and here we change a relationship

If you want to enjoy these annotations just use OpenXava to develop your application. Although if you are not still ready for rapid development, you can create these annotations easily, just use the decorator pattern over the EntityManager or use AOP to refine the behavior of persist() and remove() methods.

Learn more about these annotations

More Stories By Javier Paniza

Javier Paniza is the project lead for OpenXava project. He works as software developer at Gestión 400, a software company for public administration in Spain. He has been developing with Java Enterprise since 1998. Also he has been J2EE mentor for development teams in banking projects.