Un peu de lumière sur JPA et Hibernate

Comment on en est arrivé là...

"Eh les gars, il est temps de passer à JPA maintenant ! Hibernate c'est fini !".

JPA quoi ?! Java Persistence Architecture API ? Un super nouveau méga système révolutionnaire du mapping objet ?! 

En écoutant cet étrange personnage nous présenter son système de persistance, on comprend qu'il très vite s'agit d'une spécification et non d'une implémentation, et qu'il faudrait quand même continuer nos devs avec Hibernate mais avec des contraintes différentes...

Alors à quoi bon changer de système si ça fait la même chose ? Eh bien, pour participer enfin à la standardisation des interfaces dans les ORM Java !

Mais à ma connaissance Hibernate est sorti au début du siècle (en 2001...). Sur quoi donc se basait-il à l'époque ? En fouillant sur le site officiel d'Hibernate, on découvre que Gavin King avait développé son propre système de persistance afin de proposer les mêmes fonctionnalités que le système d'EJB2 mais avec une complexité moindre.

Quelques années plus tard, au vu de la floraison d'implémentations d'ORM, il semblait urgent de définir un socle unifié, d'où la sortie de JPA1.0 en 2006, mis à jour en 2009 avec JPA2.0.

2010 est l'année de sortie de la version 3.x d'Hibernate, qui est une implémentation certifié de JPA2.0.

Voila pour la petite histoire de JPA...

JPA en quelques mots

JPA2 est bien une spécification, et non une implémentation. Et sans implémentation il est impossible d'exécuter notre programme, et donc d'effectuer des appels en base (embêtant tout de même...)

Par exemple JPA définie les interfaces :

public interface JPA {
public void insert(Object obj);
public void update(Object obj);
public void delete(Object obj);
public Object select();
}

mais ne définit les implémentations, c'est à dire le code qui implémente les méthodes de ces interfaces.

Depuis sa version 3.2, Hibernate fournit une implémentation de JPA

En réalité il existe de nombreuses implémentations de JPA. Parmi celles-ci Hibernate, Toplink Essentials, Openjpa, Eclipselink, etc. Mais Hibernate est de loin la plus utilisée dans le monde java.

Il est possible d'utiliser les librairies d'Hibernate sans JPA. Le choix d'utiliser JPA force les développeurs à suivre les spécifications JPA. Par exemple les imports du type

org.hibernate.xxx

sont supprimés et sont remplacés par les imports de l'API JPA

javax.persistence.xxx

Les objets de type hibernateTemplate sont supprimés et sont remplacés par des EntityManager de JPA.
etc...
Bref, tout est standardisé !
Au runtime, il suffit d'inclure le jar de l'implémentation désirée, et c'est parti ! (pratique...)

Pour terminer, JPA n'est pas la seul spécification qui existe pour définir les concepts de persistence.
Une autre célèbre spécification en java se prénomme JDO pour Java Data Objects. A la différence de JPA, elle définit des solutions pour de la persistence vers des systèmes non-RDBMS (ex : LDAP, XML, ODF, Excel etc)

En pratique

On va donc chercher les dépendances de JPA pour les coller dans notre projet Java.

Pour les mavenistes, on colle la dépendance suivante dans notre pom.xml

<dependency>
<groupId>javax.persistence</groupId>
<artifactId>persistence-api</artifactId>
<version>1.0</version>
</dependency>

On met à jour nos imports, nos annotations, nos appels dans nos DAO, nos HQL (le language HQL est remplacé par du JPQL, plus strictes). Et hop le code compile !

Au runtime, on ajoute notre implémentation d'hibernate dans notre projet a déployer.

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>3.5.1-Final</version>
</dependency>

Eh voila, vous êtes devenus JPA compliant !