La différence entre JPA, Hibernate et EclipseLink

Introduction

Dans ce tutoriel, nous aborderons Hibernate et l’API de persistance Java (JPA) – en nous concentrant sur les différences entre eux.

Nous commencerons par explorer ce qu’est JPA, comment il est utilisé, et les concepts fondamentaux qui le sous-tendent.

Puis, nous jetterons un coup d’œil à la façon dont Hibernate et EclipseLink s’intègrent dans le tableau.

Mappage objet-relationnel

Avant de plonger dans JPA, il est important de comprendre le concept de mappage objet-relationnel – également connu sous le nom d’ORM.

Le mappage objet-relationnel est simplement le processus de persistance de tout objet Java directement dans une table de base de données. Habituellement, le nom de l’objet persistant devient le nom de la table, et chaque champ de cet objet devient une colonne. Avec la table configurée, chaque ligne correspond à un enregistrement dans l’application.

Une introduction à JPA

L’API Java Persistence, ou JPA, est une spécification qui définit la gestion des données relationnelles dans une application Java. L’API cartographie un ensemble de concepts qui définissent quels objets au sein de l’application doivent être persistés, et comment elle doit les persister.

Il est important de noter ici que JPA n’est qu’une spécification et qu’elle a besoin d’une implémentation pour fonctionner – mais nous y reviendrons plus tard.

Maintenant, discutons de certains des concepts fondamentaux de JPA qu’une implémentation doit couvrir.

3.1. Entité

La classe javax.persistence.Entity définit quels objets doivent être persistés dans la base de données. Pour chaque entité persistée, JPA crée une nouvelle table au sein de la base de données choisie.

En outre, toutes les entités choisies doivent définir une clé primaire dénotée par l’annotation @Id. Avec l’annotation @GeneratedValue, nous définissons que la clé primaire doit être automatiquement générée lorsque l’enregistrement est persistant dans la base de données.

Regardons un exemple rapide d’une entité décrite par JPA.

@Entitypublic class Car { @GeneratedValue @Id public long id; // getters and setters}

Rappellez-vous, cela n’aura actuellement aucun effet sur l’application – JPA ne fournit aucun code d’implémentation.

3.2. Persistance des champs

Un autre concept central de JPA est la persistance des champs. Lorsqu’un objet en Java est défini comme une entité, tous les champs qu’il contient sont automatiquement persistés comme différentes colonnes dans la table d’entité.

S’il y a un champ dans un objet persistant que nous ne voulons pas persister dans la base de données, nous pouvons déclarer le champ transitoire avec l’annotation @Transient.

3.3. Relations

Puis, JPA précise comment nous devons gérer les relations entre les différentes tables de la base de données au sein de notre application. Comme nous l’avons vu, JPA gère cela avec des annotations. Il y a quatre annotations de relation que nous devons garder à l’esprit :

1. @OneToOne
2. @OneToMany
3. @ManyToOne
4. @ManyToMany

Regardons comment cela fonctionne :

@Entitypublic class SteeringWheel { @OneToOne private Car car // getters and setters}

Dans notre exemple ci-dessus, la classe Volant décrit une relation de un à un avec notre classe Voiture de tout à l’heure.

3.4. Gestionnaire d’entités

Enfin, la classe javax.persistence.EntityManager spécifie les opérations vers et depuis la base de données. L’EntityManager contient des opérations communes de création, de lecture, de mise à jour et de suppression (CRUD) qui sont persistées dans la base de données.

Mise en œuvre de JPA

Avec la spécification JPA définissant comment et quoi nous devons persister, nous devons maintenant choisir un fournisseur de mise en œuvre pour fournir le code nécessaire. Sans un tel fournisseur, nous aurions besoin d’implémenter toutes les classes pertinentes pour nous conformer à JPA, et c’est beaucoup de travail !

Il existe de nombreux fournisseurs parmi lesquels choisir, chacun affichant ses propres avantages et inconvénients. Au moment de prendre une décision sur celui à utiliser, nous devrions considérer quelques-uns des points suivants :

1. Maturité du projet – depuis combien de temps le fournisseur existe-t-il, et est-il bien documenté ?
2. Sous-projets – le fournisseur a-t-il des sous-projets utiles pour notre nouvelle application ?
3. Support communautaire – y a-t-il quelqu’un pour nous aider lorsque nous nous retrouvons avec un bug critique ?
4. Benchmarking – quelle est la performance de l’implémentation ?

Bien que nous n’irons pas en profondeur sur le benchmarking des différents fournisseurs JPA, JPA Performance Benchmark (JPAB) contient des informations précieuses à ce sujet.

Avec cela de côté, jetons un bref coup d’œil à certains des meilleurs fournisseurs de JPA.

Hibernate

À son cœur, Hibernate est un outil de mapping objet-relationnel qui fournit une implémentation de JPA. Hibernate est l’une des implémentations JPA les plus matures qui existent, avec une énorme communauté soutenant le projet.

Il implémente toutes les classes javax.persistence que nous avons examinées plus tôt dans l’article, ainsi que de fournir des fonctionnalités au-delà de JPA – outils Hibernate, validation et recherche. Bien que ces API spécifiques à Hibernate puissent être utiles, elles ne sont pas nécessaires dans les applications qui ne nécessitent que la fonctionnalité JPA de base.

Regardons rapidement ce qu’Hibernate offre avec l’annotation @Entity.

Tout en remplissant le contrat JPA, @org.hibernate.annotations.Entity ajoute des métadonnées supplémentaires qui vont au-delà de la spécification JPA. Cela permet de régler avec précision la persistance des entités. Par exemple, examinons quelques annotations offertes par Hibernate qui étendent la fonctionnalité de @Entity:

1. @Table – nous permet de spécifier le nom de la table créée pour l’entité
2. @BatchSize – spécifie la taille du lot lors de la récupération des entités de la table

Il convient également de noter quelques-unes des fonctionnalités supplémentaires que la JPA ne spécifie pas, qui peuvent s’avérer utiles dans les applications plus importantes :

1. Des instructions CRUD personnalisables avec les annotations @SQLInsert, @SQLUpate et @SQLDelete
2. Prise en charge de la suppression douce
3. Des entités immuables avec l’annotation @Immutable

Pour une plongée plus profonde dans Hibernate et la persistance Java – rendez-vous sur notre série de tutoriels sur la persistance Spring.

EclipseLink

EclipseLink, construit par la Fondation Eclipse, fournit une implémentation JPA open-source. En outre, EclipseLink prend en charge un certain nombre d’autres normes de persistance telles que Java Architecture for XML Binding (JAXB).

En termes simples, plutôt que de persister un objet à une ligne de base de données, JAXB le mappe à une représentation XML.

Puis, en comparant la même mise en œuvre de l’annotation @Entity, nous voyons qu’EclipseLink offre à nouveau des extensions différentes. Alors qu’il n’y a pas d’annotation pour @BatchSize comme nous l’avons vu précédemment, EclipseLink offre d’autres options qu’Hibernate ne propose pas.

Par exemple :

1. @ReadOnly – spécifie que l’entité à persister est en lecture seule
2. @Struct – définit la classe pour mapper vers un type ‘struct’ de base de données

Pour en savoir plus sur ce qu’EclipseLink a à offrir, rendez-vous sur notre guide sur EclipseLink avec Spring.

Conclusion

Dans cet article, nous avons examiné l’API de persistance Java, ou JPA.

Enfin, nous avons exploré comment elle diffère d’Hibernate et d’EclipseLink.