Comment mapper une clé primaire composite avec JPA et Hibernate Exemple
Bonjour lecteurs, dans ce tutoriel, nous montrerons comment mapper la clé primaire composite avec JPA et Hibernate en utilisant Eclipse Link et MySQL en Java. Parce que c'est une question récurrente, j'ai décidé d'écrire un tutoriel dans lequel j'ai décrit cette cartographie de manière détaillée.
Table des matières
- 1. Présentation
- 1.1 Avantages JPA
- 1.2 Comment y parvenir ?
- 1.3 Télécharger et installer EclipseLink
- 1.4 Télécharger et installer MySQL
- 2. Comment mapper une clé primaire composite avec JPA et exemple Hibernate
- 2.1 Outils utilisés
- 2.2 Structure du projet
- 2.3 Création de projet
- 3. Création d'applications
- 3.1 Création de bases de données et de tables
- 3.2 Dépendances Maven
- 3.3 Création de classe Java
- 3.4 Fichier de configuration de la base de données
- 4. Exécutez l'application
- 5. Démo du projet
- 6. Conclusion
- 7. Télécharger le projet Eclipse
1. Présentation
API de persistance Java (JPA), est une interface standard qui encapsule les différents outils de mappage relationnel objet (ORM) tels que Hibernate, EclipseLink, OpenJPA, etc. JPA fournit un javax.persistence.EntityManager
interface utilisée pour interagir avec la base de données. L'instance de EntityManager
joue autour du contexte de persistance et du EntityManagerFactory
interagit avec le EntityManager
objet.
- Contexte de persistance est l'ensemble d'instances d'entité où, pour toute identité d'entité de persistance, il existe une instance d'entité unique. Le cycle de vie des instances d'entité est géré dans le contexte de persistance à l'aide du
EntityManager
. Nous pouvons détacher et fusionner les instances d'entité dans un contexte de persistance - Gestionnaire d'entité est un modèle emprunté aux frameworks JDBC traditionnels, c'est-à-dire permettant aux développeurs d'effectuer plus facilement les opérations de base de données de base avec très peu de code
Dans cet exemple JPA autonome, nous utilisons EclipseLink avec MySQL Database. EclipseLink est un outil ORM (Object Relation Mapping) open source populaire pour la plate-forme Java utilisé pour mapper une entité à une base de données relationnelle traditionnelle comme Oracle, MySQL, etc.
Les développeurs peuvent consulter le tableau ci-dessous pour les différentes bases de données disponibles avec les exemples EclipseLink :
Base de données | Classe de pilote | Nom du pot |
---|---|---|
MySQL | com.mysql.jdbc.Driver | mysql-connector-java-5.1.25-bin.jar (le nom exact dépend de la version) http://www.mysql.com/downloads/connector/j/ |
HSQLDB | org.hsqldb.jdbcDriver | hsqldb.jar http://hsqldb.sourceforge.net |
Sybase | com.sybase.jdbc3.jdbc.SybDriver | jconnect.jar http://www.sybase.com/products/allproductsa-z/softwaredeveloperkit/jconnect |
Apache Derby | org.apache.derby.jdbc.EmbeddedDriver | derby.jar http://db.apache.org/derby/ |
IBM DB2 | com.ibm.db2.jcc.DB2Driver | db2jcc4.jar http://www-01.ibm.com/software/data/db2/linux-unix-windows/download.html |
PostgreSQL | org.postgresql.Driver | postgresql-8.4-701.jdbc4.jar (le nom exact dépend de la version de PostgreSQL) http://jdbc.postgresql.org |
SQL Server (pilote Microsoft) | com.microsoft.sqlserver.jdbc.SQLServerDriver | sqljdbc4.jar http://msdn.microsoft.com/en-gb/data/aa937724%28en-us%29.aspx |
1.1 Avantages JPA
L'utilisation du framework JPA présente de nombreux avantages, par exemple
- L'avantage d'utiliser le framework JPA par rapport à n'importe quelle bibliothèque spécifique liée au modèle relationnel objet (ORM) comme Hibernate, iBatis, etc. est que les développeurs ne changent pas le code lorsqu'ils changent de fournisseur
- Le code est faiblement associé au framework ORM sous-jacent
- Améliore la sécurité des données et l'accès aux données pour les utilisateurs en utilisant des langages hôtes et de requête
- Améliore les performances des applications en réduisant la redondance des données
- Plus grande intégrité des données et indépendance des programmes d'application
- Fournit une interrogation simple des données
1.2 Comment y parvenir ?
Les programmeurs peuvent obtenir de la persistance dans leur application en introduisant le persistence.xml
dans leur code, qui doit être situé dans le META-INF
répertoire dans le chemin de classe du projet. Un persistence.xml
Le fichier peut inclure des définitions pour une ou plusieurs unités de persistance. Ce fichier joue un rôle crucial dans le concept de JPA car dans ce fichier de configuration, les développeurs enregistreront la base de données et spécifieront la classe d'entité. Jetons un coup d'œil et comprenons l'exemple de code.
Exemple persistence.xml
<?xml version="1.0" encoding="UTF-8"?> <persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"> <persistence-unit name="TestPersistence" transaction-type="RESOURCE_LOCAL"> <class><!-- Entity Manager Class Name --></class> <properties> <property name="javax.persistence.jdbc.driver" value="Database Driver Name" /> <property name="javax.persistence.jdbc.url" value="Database Url" /> <property name="javax.persistence.jdbc.user" value="Database Username" /> <property name="javax.persistence.jdbc.password" value="Database Password" /> </properties> </persistence-unit> </persistence>
Le persistence.xml
indique qu'il n'y a qu'une seule unité de persistance mappée avec le nom TestPersistence et le type de transaction pour cette unité de persistance est RESOURCE_LOCAL
. Il existe deux types de transactions :
- JTA
- RESOURCE_LOCAL
Si les développeurs sélectionnent le RESOURCE_LOCAL
, la transaction sera alors gérée par l'implémentation de fournisseur JPA utilisée. Si JTA est spécifié, les transactions seront gérées par le serveur d'applications.
N'oubliez pas que si un développeur ne souhaite avoir que des transactions JPA, alors RESOURCE_LOCAL
est un bon choix. Mais, si un développeur souhaite que les transactions contiennent des ressources autres que JPA, comme les EJB, JMS, alors JTA
est le bon choix.
1.3 Télécharger et installer EclipseLink
Vous pouvez regarder cette vidéo afin de télécharger et d'installer le JPA dans Eclipse via EclipseLink.
1.4 Télécharger et installer MySQL
Vous pouvez regarder cette vidéo afin de télécharger et d'installer la base de données MySQL sur votre système d'exploitation Windows.
Maintenant, ouvrez l'Eclipse Ide et voyons comment définir la clé primaire composite mise en œuvre dans l'APP.
2. Comment mapper une clé primaire composite avec JPA et exemple Hibernate
2.1 Outils utilisés
Nous utilisons Eclipse Kepler SR2, JDK 8, MySQL et Maven. Cela dit, nous avons testé le code par rapport à JDK 1.7 et cela fonctionne bien.
2.2 Structure du projet
Tout d'abord, passons en revue la structure finale du projet, au cas où vous ne seriez pas sûr de l'endroit où vous devriez créer les fichiers ou dossiers correspondants plus tard !
Fig. 1 :Structure du projet de l'application
2.3 Création de projet
Cette section montrera comment créer un projet Maven basé sur Java avec Eclipse. Dans Eclipse IDE, allez à File -> New -> Maven Project
.
Fig. 2 :Créer un projet Maven
Dans la fenêtre Nouveau projet Maven, il vous sera demandé de sélectionner un emplacement de projet. Par défaut, "Utiliser l'emplacement de l'espace de travail par défaut" sera sélectionné. Cochez la case "Créer un projet simple (ignorer la sélection de l'archétype)" et cliquez simplement sur le bouton suivant pour continuer.
Fig. 3 :Détails du projet
Il vous demandera de "Entrez le groupe et l'identifiant de l'artefact pour le projet". Nous entrerons les détails comme indiqué dans l'image ci-dessous. Le numéro de version sera par défaut :0.0.1-SNAPSHOT
.
Fig. 4 : Paramètres de l'archétype
Cliquez sur terminer et la création d'un projet maven sera terminée. Si vous observez, il a téléchargé les dépendances maven et un pom.xml
fichier sera créé. Il aura le code suivant :
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>JPACompositeKey</groupId> <artifactId>JPACompositeKey</artifactId> <version>0.0.1-SNAPSHOT</version> </project>
Nous pouvons commencer à ajouter les dépendances que les développeurs veulent comme Eclipse Link, MySQL Connector Jar et Hibernate etc. Commençons à construire l'application !
3. Création d'applications
Voici les étapes impliquées dans le développement de cette application.
3.1 Création de bases de données et de tables
Un Com Positionner la clé primaire est une clé primaire composé de plusieurs colonnes et le script MySQL suivant est utilisé pour créer une base de données appelée jpacompositekey
avec tableau :book_info
contenant la clé composite . Ouvrez le terminal MySQL ou Workbench et exécutez le SQL
script :
CREATE DATABASE jpacompositekey; USE jpacompositekey; CREATE TABLE book_info ( isbn VARCHAR(100) NOT NULL, bk_name VARCHAR(200) NOT NULL, author_name VARCHAR(200) NOT NULL, PRIMARY KEY (bk_name, author_name) ); DESC book_info;
Si tout se passe bien, la base de données et la table seront affichées dans MySQL Workbench.
Fig. 5 : Création de la base de données et de la table
3.2 Dépendances Maven
Dans cet exemple, nous utilisons la version stable Hibernate, MySQL et Eclipse Link afin de prendre en charge le contenu JPA et d'établir une connexion de base de données réussie. Les dépendances restantes seront automatiquement résolues par Maven et la mise à jour le fichier aura le code suivant :
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>JPACompositeKey</groupId> <artifactId>JPACompositeKey</artifactId> <version>0.0.1-SNAPSHOT</version> <dependencies> <!-- https://mvnrepository.com/artifact/org.eclipse.persistence/eclipselink --> <dependency> <groupId>org.eclipse.persistence</groupId> <artifactId>eclipselink</artifactId> <version>2.5.2</version> </dependency> <dependency> <groupId>org.eclipse.persistence</groupId> <artifactId>javax.persistence</artifactId> <version>2.0.0</version> </dependency> <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.40</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>5.2.11.Final</version> </dependency> <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core --> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>5.2.11.Final</version> </dependency> </dependencies> <build> <finalName>${project.artifactId}</finalName> </build> </project>
3.3 Création de classes Java
Créons les fichiers Java requis. Faites un clic droit sur src/main/java
dossier, New -> Package
.
Fig. 6 : Création d'un package Java
Une nouvelle fenêtre contextuelle s'ouvrira dans laquelle nous saisirons le nom du package :com.jcg.compositekey.demo
.
Fig. 7 :nom du package Java (com.jcg.compositekey.demo)
Une fois le package créé, nous devrons créer le modèle et les classes d'implémentation. Faites un clic droit sur le package nouvellement créé, New -> Class
.
Fig. 8 : Création d'une classe Java
Une nouvelle fenêtre contextuelle s'ouvrira et saisira le nom du fichier sous la forme :Book
. La classe de modèle sera créée dans le package :com.jcg.compositekey.demo
.
Fig. 9 :Classe Java (Book.java)
Répétez l'étape (c'est-à-dire Fig. 8) et entrez le nom du fichier sous la forme :BookInfo
. La classe de modèle d'entité sera créée dans le package :com.jcg.compositekey.demo
.
Fig 10 :Classe Java (BookInfo.java)
Encore une fois, répétez l'étape indiquée dans la Fig. 8 et entrez le nom du fichier sous la forme Demo
. La classe d'implémentation sera créée dans le package :com.jcg.compositekey.demo
.
Fig. 11 :Classe Java (Demo.java)
3.3.1 Implémentation de la classe Model
Cette classe modélise le livre et le nom de l'auteur. Le livre lui-même se rapporte à une autre classe Java appelée BookInfo.java
. Un point important à noter est que la classe implémente le Java Serializable
interface et le @Embeddable
annotation. Une classe Java avec le @Embeddable
l'annotation peut elle-même devenir un sous-composant d'une autre classe . Ajoutez-y le code suivant :
Livre.java
package com.jcg.compositekey.demo; import java.io.Serializable; import java.util.Objects; import javax.persistence.Column; import javax.persistence.Embeddable; import javax.persistence.Id; @Embeddable public class Book implements Serializable { private static final long serialVersionUID = 1L; @Id @Column(name = "bk_name") private String bk_name; @Id @Column(name = "author_name") private String author_name; public Book() { } public Book(String book_name, String auth_name) { this.bk_name = book_name; this.author_name = auth_name; } public String getBk_name() { return bk_name; } public void setBk_name(String bk_name) { this.bk_name = bk_name; } public String getAuthor_name() { return author_name; } public void setAuthor_name(String author_name) { this.author_name = author_name; } @Override public boolean equals(Object o) { if (this == o) { return true; } if(!(o instanceof Book)) { return false; } Book bk_info = (Book) o; return Objects.equals(getBk_name(), bk_info.getBk_name()) && Objects.equals(getAuthor_name(), bk_info.getAuthor_name()); } @Override public int hashCode() { return Objects.hash(getBk_name(), getAuthor_name()); } }
3.3.2 Implémentation de la classe de modèle d'entité
Cette classe implémente le @Entity
annotation qui indique que la classe est une entité de base de données. Ajoutez-y le code suivant :
BookInfo.java
package com.jcg.compositekey.demo; import javax.persistence.AttributeOverride; import javax.persistence.AttributeOverrides; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.IdClass; import javax.persistence.Table; @Entity @Table(name = "book_info") @IdClass(Book.class) public class BookInfo { @Column(name = "isbn") private String isbn; @Id @Column(name = "bk_name") private String bk_name; @Id @Column(name = "author_name") private String author_name; public BookInfo() { } public BookInfo(Book bkObj) { bk_name = bkObj.getBk_name(); author_name = bkObj.getAuthor_name(); } @Id @AttributeOverrides( { @AttributeOverride(name = "bk_name",column = @Column(name="bk_name")), @AttributeOverride(name = "author_name", column = @Column(name="author_name")) } ) public String getIsbn() { return isbn; } public void setIsbn(String isbn) { this.isbn = isbn; } }
3.3.3 Implémentation de la classe utilitaire
Il s'agit de la classe de service qui implémente l'API Java Persistence pour effectuer une transaction de base de données (c'est-à-dire SQL
INSÉRER l'opération). Ajoutez-y le code suivant :
Démo.java
package com.jcg.compositekey.demo; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; public class Demo { private static final EntityManagerFactory emFactoryObj; private static final String PERSISTENCE_UNIT_NAME = "JPACompositeKey"; static { emFactoryObj = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME); } // This Method Is Used To Retrieve The 'EntityManager' Object public static EntityManager getEntityManager() { return emFactoryObj.createEntityManager(); } public static void main(String[] args) { EntityManager entityMgr = getEntityManager(); entityMgr.getTransaction().begin(); BookInfo bkInfo = new BookInfo(new Book("Harry Potter & The Philosopher's Stone", "J. K. Rowling")); bkInfo.setIsbn("978-1-4028-9462-6"); entityMgr.persist(bkInfo); entityMgr.getTransaction().commit(); entityMgr.clear(); System.out.println("Record Successfully Inserted In The Database"); } }
3.4 Fichier de configuration de la base de données
Les développeurs peuvent obtenir de la persistance dans leur application en introduisant le persistence.xml
dans leur code. Ce module joue un rôle crucial dans le concept de JPA car dans ce fichier de configuration, nous allons enregistrer la base de données et spécifier la classe d'entité. Créer un répertoire META-INF
dans le src/main/java
dossier et créez le fichier persistence.xml
à l'intérieur. Ajoutez-y le code suivant :
persistance.xml
<?xml version="1.0" encoding="UTF-8"?> <persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"> <persistence-unit name="JPACompositeKey" transaction-type="RESOURCE_LOCAL"> <class>com.jcg.compositekey.demo.Book</class> <class>com.jcg.compositekey.demo.BookInfo</class> <!-- Configuring The Database Connection Details --> <properties> <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" /> <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpacompositekey" /> <property name="javax.persistence.jdbc.user" value="root" /> <property name="javax.persistence.jdbc.password" value="" /> </properties> </persistence-unit> </persistence>
Remarques :
- Dans cet exemple, nous connectons l'application à la base de données MySQL. Ainsi, les développeurs doivent ajouter mysql-connector-java-
-bin.jar au projet - Nous avons conservé le
javax.persistence.jdbc.password
valeur vide pour plus de simplicité, cependant, il appartient à l'utilisateur de la laisser vide ou de la définir lors de la configuration de MySQL. Si l'utilisateur le définit, nous devons fournir le même mot de passe à cette chaîne
4. Exécutez l'application
Pour lancer l'application, faites un clic droit sur le Demo
classe, Run As -> Java Application
. Les développeurs peuvent déboguer l'exemple et voir ce qui se passe après chaque étape. Prendre plaisir!
Fig. 12 :Exécuter l'application
5. Démo du projet
Après avoir exécuté le code, l'application affiche l'état suivant en sortie :
Fig. 13 :sortie de l'application
C'est tout pour ce post. Bon apprentissage!!
6. Conclusion
Grâce à cet exemple, nous avons découvert l'implémentation de la clé primaire composite. J'espère que cet article vous a servi tout ce que vous cherchiez. Les développeurs peuvent télécharger l'exemple d'application en tant que projet Eclipse dans la section des téléchargements.
7. Télécharger le projet Eclipse
Ceci était un exemple de clé primaire composite JPA.hibernate jpa mysql sql