Java >> Tutoriel Java >  >> Tag >> hibernate

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

Balise Java