First Look at Java Persistence API

The Java Persistence API page on java.sun.com describes the Persictence API as:

The Java Persistence API provides a POJO persistence model for object-relational mapping. The Java Persistence API was developed by the EJB 3.0 software expert group as part of JSR 220, but its use is not limited to EJB software components. It can also be used directly by web applications and application clients, and even outside the Java EE platform, for example, in Java SE applications

So let’s look a bit deeper into the fetures of new API.

Persistense is dealing with entities. An Entitiy is a lightweight domain object, that shold be persistent. Typically an entity represents a table in a relational database, and each entity instance corresponds to a row in that table.

In the Java Persistens API the persistent state of an entity is represented either through persistent fields or persistent properties. These fields or properties use object/relational mapping annotations to map the entities and entity relationships to the relational data in the underlying data store.

So Entities are marked with the @Entity (javax.persistence.Entity) annotation and the entitiy-class shold implement Serializable interface. Further requirements for entitiy classes can be found in the Java EE 5 Tutorial.

Here ist just little examle of Persisten entitiy “User”.

{[.java1 /enzymes/s_java.php]}

If the entity name is the same as that of the table name, @Table is not required. The same with @Column Attribute. Not Persisten Fields or methods shold be marked with @Transient. Here more Information about persistent field and properties and especialy Primary Keys.
So far its quite simple.

Entities can have relations to each other. Java Persistence API knows four types of multiplicities: one-to-one, one-to-many, many-to-one, and many-to-many, which are marked with appropriate anotations. Furthermore relationships can be unidirectional or bidirectional. In a unidirectional relationship, only one entity has a relationship field or property that refers to the other. Read more about it.

This looks really intresting to me. But it gone to be better then, the Java Persistence API has an important new feature that was not covered bu SUn before: support for inheritance and polymorphism. An entity may inherit from another entity class. By default, the queries are polymorphic and are applicable against the entire entity hierarchy. Read more about inheritance posibilities.

An fionely ist better Query language

Queries and query language

The Java Persistence query language (JPQL) is an extension of the EJB QL, but overcomes EJB QL’s limitations and provides more features such as:

More on JPQL in the Tutorial

Management of entities

Entities are managed by the entity manager. The entity manager is represented by javax.persistence.EntityManager instances. Each EntityManager instance is associated with a persistence context. A persistence context is a set of managed entity instances that exist in a particular data store and defines the scope under which particular entity instances are created, persisted, and removed.

As expected the are two kinds of managers an container managed and one application managed.
With a container-managed entity manager, an EntityManager instance’s persistence context is automatically propagated by the container to all application components that use the EntityManager instance within a single Java Transaction Architecture (JTA) transaction.

{[.java2 /enzymes/s_java.php]}
With application-managed entity managers, on the other hand, the persistence context is not propagated to application components, and the lifecycle of EntityManager instances is managed by the application.

{[.java3 /enzymes/s_java.php]}

Persisten context is described in persistense.xml file

Conclusion

At first look is the Java Persistence API an real break trough. (Ofcourse i should try it out in praxis befor i’m shure :) )
But the points are:

Furthermore Java Persistence API can be used for Java SE environments too. This is possible because of the Java Persistence API’s support outside the EJB container. This is rely an advansed feature.

  1. Java Persistence API on java.sun.com
  2. Java Persistence API in the Java EE 5 Tototial
  3. Good Article goes detailed on inheritance at JavaWorld
  4. Extended fetures in Examples of using Persistence API in EJB tier
  5. Using Persistens with JSF
  6. Java WebStart Persistence
Share and Enjoy:
  • Digg
  • del.icio.us
  • Facebook
  • Mixx
  • Google Bookmarks
  • BlinkList
  • MisterWong.DE
  • Slashdot
  • StumbleUpon
  • Technorati
  • NewsVine
  • Reddit
  • Yigg
  • HackerNews
  • LinkedIn
  • Webnews.de
  • Yahoo! Buzz

If you enjoyed this post, please consider to leave a comment or subscribe to the feed and get future articles delivered to your feed reader.

Comments

No comments yet.

Leave a comment

(required)

(required)