JPA - Guide rapide

Toute application d'entreprise effectue des opérations de base de données en stockant et en récupérant de grandes quantités de données. Malgré toutes les technologies disponibles pour la gestion du stockage, les développeurs d'applications ont généralement du mal à effectuer efficacement les opérations de base de données.

En règle générale, les développeurs Java utilisent beaucoup de code ou utilisent le cadre propriétaire pour interagir avec la base de données, tandis qu'en utilisant JPA, la charge d'interaction avec la base de données diminue considérablement. Il forme un pont entre les modèles objet (programme Java) et les modèles relationnels (programme de base de données).

Inadéquations entre les modèles relationnel et objet

Les objets relationnels sont représentés dans un format tabulaire, tandis que les modèles d'objets sont représentés dans un graphique interconnecté de format objet. Lors du stockage et de la récupération d'un modèle d'objet à partir d'une base de données relationnelle, une certaine incompatibilité se produit pour les raisons suivantes:

• Granularity : Le modèle objet a plus de granularité que le modèle relationnel.

• Subtypes : Les sous-types (signifie héritage) ne sont pas pris en charge par tous les types de bases de données relationnelles.

• Identity : Comme le modèle objet, le modèle relationnel n'expose pas d'identité lors de l'écriture d'égalité.

• Associations : Les modèles relationnels ne peuvent pas déterminer plusieurs relations lors de l'examen du modèle de domaine objet.

• Data navigation : La navigation dans les données entre les objets d'un réseau d'objets est différente dans les deux modèles.

Qu'est-ce que JPA?

L'API Java Persistence est un ensemble de classes et de méthodes permettant de stocker de manière permanente les vastes quantités de données dans une base de données fournie par Oracle Corporation.

Où utiliser JPA?

Pour réduire le fardeau de l'écriture de codes pour la gestion des objets relationnels, un programmeur suit le framework 'JPA Provider', qui permet une interaction facile avec l'instance de base de données. Ici, le cadre requis est repris par JPA.

Histoire JPA

Versions antérieures d'EJB, couche de persistance définie associée à une couche de logique métier à l'aide de l'interface javax.ejb.EntityBean.

• Lors de l'introduction d'EJB 3.0, la couche de persistance a été séparée et spécifiée comme JPA 1.0 (API Java Persistence). Les spécifications de cette API ont été publiées avec les spécifications de JAVA EE5 le 11 mai 2006 en utilisant JSR 220.

• JPA 2.0 a été publié avec les spécifications de JAVA EE6 le 10 décembre 2009 dans le cadre du Java Community Process JSR 317.

• JPA 2.1 a été publié avec la spécification de JAVA EE7 le 22 avril 2013 en utilisant JSR 338.

Fournisseurs JPA

JPA est une API open source, par conséquent, divers fournisseurs d'entreprise tels qu'Oracle, Redhat, Eclipse, etc. fournissent de nouveaux produits en y ajoutant la saveur de persistance JPA. Certains de ces produits comprennent:

Hibernate, Eclipselink, Toplink, Spring Data JPA, etc.

L'API Java Persistence est une source pour stocker des entités commerciales en tant qu'entités relationnelles. Il montre comment définir un PLAIN OLD JAVA OBJECT (POJO) en tant qu'entité et comment gérer des entités avec des relations.

Architecture au niveau de la classe

L'image suivante montre l'architecture au niveau de la classe de JPA. Il montre les classes principales et les interfaces de JPA.

Le tableau suivant décrit chacune des unités présentées dans l'architecture ci-dessus.

Unités	La description
EntityManagerFactory	Il s'agit d'une classe d'usine d'EntityManager. Il crée et gère plusieurs instances EntityManager.
EntityManager	C'est une Interface, elle gère les opérations de persistance sur les objets. Cela fonctionne comme l'usine pour l'instance de requête.
Entity	Les entités sont les objets de persistance, stockés sous forme d'enregistrements dans la base de données.
EntityTransaction	Il a une relation individuelle avec EntityManager. Pour chaque EntityManager, les opérations sont gérées par la classe EntityTransaction.
Persistence	Cette classe contient des méthodes statiques pour obtenir l'instance EntityManagerFactory.
Query	Cette interface est implémentée par chaque fournisseur JPA pour obtenir des objets relationnels répondant aux critères.

Les classes et interfaces ci-dessus sont utilisées pour stocker des entités dans une base de données en tant qu'enregistrement. Ils aident les programmeurs en réduisant leurs efforts pour écrire des codes pour stocker des données dans une base de données afin qu'ils puissent se concentrer sur des activités plus importantes telles que l'écriture de codes pour mapper les classes avec des tables de base de données.

Relations de classe JPA

Dans l'architecture ci-dessus, les relations entre les classes et les interfaces appartiennent au package javax.persistence. Le diagramme suivant montre la relation entre eux.

• La relation entre EntityManagerFactory et EntityManager est one-to-many. Il s'agit d'une classe d'usine pour les instances EntityManager.

• La relation entre EntityManager et EntityTransaction est one-to-one. Pour chaque opération EntityManager, il existe une instance EntityTransaction.

• La relation entre EntityManager et Query est one-to-many. De nombreuses requêtes peuvent être exécutées à l'aide d'une seule instance EntityManager.

• La relation entre EntityManager et Entity est one-to-many. Une instance EntityManager peut gérer plusieurs entités.

La plupart des applications contemporaines utilisent une base de données relationnelle pour stocker des données. Récemment, de nombreux fournisseurs sont passés à la base de données d'objets pour réduire leur charge de maintenance des données. Cela signifie que les bases de données d'objets ou les technologies relationnelles d'objets prennent en charge le stockage, la récupération, la mise à jour et la maintenance des données. La partie centrale de cette technologie relationnelle objet consiste à mapper des fichiers orm.xml. Comme xml ne nécessite pas de compilation, nous pouvons facilement apporter des modifications à plusieurs sources de données avec moins d'administration.

Mappage relationnel d'objets

Object Relational Mapping (ORM) vous explique brièvement ce qu'est l'ORM et son fonctionnement. ORM est une capacité de programmation permettant de convertir des données d'un type d'objet en type relationnel et vice versa.

La principale caractéristique d'ORM est de mapper ou de lier un objet à ses données dans la base de données. Lors du mappage, nous devons prendre en compte les données, le type de données et leurs relations avec les entités autonomes ou les entités de toute autre table.

Fonctionnalités avancées

• Idiomatic persistence : Il vous permet d'écrire les classes de persistance en utilisant des classes orientées objet.

• High Performance : Il a de nombreuses techniques de récupération et des techniques de verrouillage pleines d'espoir.

• Reliable : Il est très stable et utilisé par de nombreux programmeurs professionnels.

Architecture ORM

L'architecture ORM se présente comme suit.

L'architecture ci-dessus explique comment les données d'objets sont stockées dans une base de données relationnelle en trois phases.

La phase 1

La première phase, nommée object data phase, contient des classes POJO, des interfaces de service et des classes. Il s'agit de la couche de composant métier principal, qui possède des opérations et des attributs de logique métier.

Par exemple, prenons une base de données d'employés comme schéma.

• La classe POJO d'employé contient des attributs tels que l'ID, le nom, le salaire et la désignation. Il contient également des méthodes comme setter et getter de ces attributs.

• Les classes DAO / Service des employés contiennent des méthodes de service telles que créer un employé, rechercher un employé et supprimer un employé.

Phase 2

La deuxième phase, nommée mapping ou persistence phase, contient le fournisseur JPA, le fichier de mappage (ORM.xml), le chargeur JPA et la grille d'objets.

• JPA Provider: C'est le produit du fournisseur qui contient la saveur JPA (javax.persistence). Par exemple Eclipselink, Toplink, Hibernate, etc.

• Mapping file : Le fichier de mappage (ORM.xml) contient la configuration de mappage entre les données d'une classe POJO et les données d'une base de données relationnelle.

• JPA Loader: Le chargeur JPA fonctionne comme une mémoire cache. Il peut charger les données de la grille relationnelle. Il fonctionne comme une copie de la base de données pour interagir avec les classes de service pour les données POJO (attributs de la classe POJO).

• Object Grid: C'est un emplacement temporaire qui peut stocker une copie de données relationnelles, comme une mémoire cache. Toutes les requêtes sur la base de données sont d'abord effectuées sur les données de la grille d'objets. Ce n'est qu'après son engagement qu'il affecte la base de données principale.

Phase 3

La troisième phase est la relational data phase. Il contient les données relationnelles qui sont logiquement connectées au composant métier. Comme indiqué ci-dessus, ce n'est que lorsque le composant métier valide les données que celles-ci sont stockées physiquement dans la base de données. Jusque-là, les données modifiées sont stockées dans une mémoire cache sous forme de grille. Le processus d'obtention des données est identique à celui de stockage des données.

Le mécanisme de l'interaction programmatique des trois phases ci-dessus est appelé object relational mapping.

Mapping.xml

Le fichier mapping.xml doit indiquer au fournisseur JPA de mapper les classes Entity avec les tables de la base de données.

Prenons un exemple d'entité Employee qui contient quatre attributs. La classe POJO de l'entité Employee nomméeEmployee.java est comme suit:

public class Employee 
{
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	public Employee(int eid, String ename, double salary, String deg) 
	{
		super( );
		this.eid = eid;
		this.ename = ename;
		this.salary = salary;
		this.deg = deg;
	}
	
	public Employee( ) 
	{
		super();
	}
	
	public int getEid( ) 
	{
		return eid;
	}
	public void setEid(int eid)  
	{
		this.eid = eid;
	}
    public String getEname( ) 
	{
		return ename;
	}
	public void setEname(String ename) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}
}

Le code ci-dessus est la classe POJO de l'entité Employee. Il contient quatre attributseid, ename, salary, et deg. Considérez ces attributs comme les champs de table dans une table eteidcomme clé primaire de cette table. Nous devons maintenant concevoir le fichier de mappage d'hibernation pour cela. Le fichier de mappage nommémapping.xml est comme suit:

<? xml version="1.0" encoding="UTF-8" ?>
<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm    
                        http://java.sun.com/xml/ns/persistence/orm_1_0.xsd"
                        version="1.0">
    <description> XML Mapping file</description>
    <entity class="Employee">        
        <table name="EMPLOYEETABLE"/>
        <attributes>
            <id name="eid">
                <generated-value strategy="TABLE"/>
            </id>
            <basic name="ename">
                <column name="EMP_NAME" length="100"/>
            </basic>
            <basic name="salary">
            </basic>
            <basic name="deg">
            </basic>
        </attributes>
    </entity>
</entity-mappings>

Le script ci-dessus est utilisé pour mapper la classe d'entité avec la table de base de données. Dans ce dossier

• <entity-mappings> : tag définit la définition de schéma pour autoriser les balises d'entité dans le fichier xml.

• <description> : balise fournit une description de l'application.

• <entity>: tag définit la classe d'entité que vous souhaitez convertir en table dans une base de données. La classe d'attribut définit le nom de la classe d'entité POJO.

• <table>: la balise définit le nom de la table. Si vous souhaitez avoir des noms identiques pour la classe et la table, cette balise n'est pas nécessaire.

• <attributes> : la balise définit les attributs (champs dans une table).

• <id>: tag définit la clé primaire de la table. le<generated-value> balise définit comment attribuer la valeur de clé primaire telle que Automatic, Manual, ou pris de Sequence.

• <basic> : la balise est utilisée pour définir les attributs restants de la table.

• <column-name> : la balise est utilisée pour définir les noms de champ de table définis par l'utilisateur dans la table.

Annotations

En général, les fichiers xml sont utilisés pour configurer des composants spécifiques ou pour mapper deux spécifications différentes de composants. Dans notre cas, nous devons maintenir les fichiers xml séparément dans un cadre. Cela signifie que lors de l'écriture d'un fichier xml de mappage, nous devons comparer les attributs de classe POJO avec des balises d'entité dans le fichier mapping.xml.

Voici la solution. Dans la définition de classe, nous pouvons écrire la partie de configuration à l'aide d'annotations. Les annotations sont utilisées pour les classes, les propriétés et les méthodes. Les annotations commencent par le symbole «@». Les annotations sont déclarées avant une classe, une propriété ou une méthode. Toutes les annotations de JPA sont définies dans lejavax.persistence paquet.

Voici la liste des annotations utilisées dans nos exemples ci-dessous.

Annotation	La description
@Entité	Déclare la classe en tant qu'entité ou table.
@Table	Déclare le nom de la table.
@De base	Spécifie les champs sans contrainte explicitement.
@Embedded	Spécifie les propriétés d'une classe ou d'une entité dont la valeur est une instance d'une classe intégrable.
@Id	Spécifie la propriété, utiliser pour l'identité (clé primaire d'une table) de la classe.
@GeneratedValue	Spécifie comment l'attribut d'identité peut être initialisé, tel que automatique, manuel ou valeur extraite d'une table de séquence.
@Transitoire	Spécifie la propriété qui n'est pas persistante, c'est-à-dire que la valeur n'est jamais stockée dans la base de données.
@Colonne	Spécifie l'attribut de colonne pour la propriété de persistance.
@SequenceGenerator	Spécifie la valeur de la propriété spécifiée dans l'annotation @GeneratedValue. Cela crée une séquence.
@TableGenerator	Spécifie le générateur de valeur pour la propriété spécifiée dans l'annotation @GeneratedValue. Il crée une table pour la génération de valeur.
@Type d'accès	Ce type d'annotation est utilisé pour définir le type d'accès. Si vous définissez @AccessType (FIELD), l'accès se produit par champ. Si vous définissez @AccessType (PROPRIÉTÉ), l'accès se produit par propriété.
@JoinColonne	Spécifie une association d'entités ou une collection d'entités. Ceci est utilisé dans les associations plusieurs-à-un et un-à-plusieurs.
@Contrainte unique	Spécifie les champs et les contraintes uniques pour la table principale ou secondaire.
@ColumnResult	Référence le nom d'une colonne dans la requête SQL à l'aide de la clause select.
@Plusieurs à plusieurs	Définit une relation plusieurs-à-plusieurs entre les tables de jointure.
@ManyToOne	Définit une relation plusieurs-à-un entre les tables de jointure.
@OneToMany	Définit une relation un-à-plusieurs entre les tables de jointure.
@Un par un	Définit une relation un-à-un entre les tables de jointure.
@NamedQueries	spécifie la liste des requêtes nommées.
@NamedQuery	Spécifie une requête utilisant un nom statique.

Java Bean Standard

La classe Java encapsule les valeurs d'instance et leurs comportements dans une seule unité appelée objet. Java Bean est un stockage temporaire et un composant ou un objet réutilisable. Il s'agit d'une classe sérialisable qui a un constructeur par défaut et des méthodes getter et setter pour initialiser les attributs d'instance individuellement.

Conventions Bean

• Bean contient son constructeur par défaut ou un fichier qui contient une instance sérialisée. Par conséquent, un bean peut instancier un autre bean.

• Les propriétés d'un bean peuvent être séparées en propriétés booléennes ou non booléennes.

• La propriété non booléenne contient getter et setter méthodes.

• La propriété booléenne contient setter et is méthode.

• Getter la méthode de toute propriété doit commencer par une petite lettre get(convention de la méthode java) et a continué avec un nom de champ commençant par une majuscule. Par exemple, le nom du champ estsalary donc la méthode getter de ce champ est getSalary ().

• Setter la méthode de toute propriété doit commencer par une petite lettre set (convention de la méthode java), suite avec un nom de champ commençant par une majuscule et le argument valueà définir sur le champ. Par exemple, le nom du champ estsalary par conséquent, la méthode de réglage de ce champ est setSalary ( double sal ).

• Pour la propriété booléenne, isméthode pour vérifier si elle est vraie ou fausse. Par exemple, la propriété booléenneempty, la is la méthode de ce champ est isEmpty ().

Ce chapitre vous guide tout au long du processus de configuration de JPA sur les systèmes Windows et Linux. JPA peut être facilement installé et intégré à votre environnement Java actuel en suivant quelques étapes simples sans aucune procédure de configuration complexe. L'administration des utilisateurs est requise lors de l'installation.

Configuration requise

JDK	Java SE 2 JDK 1.5 ou supérieur
Mémoire	1 Go de RAM (recommandé)
Espace disque	Aucune exigence minimale
Version du système d'exploitation	Windows XP ou supérieur, Linux

Passons maintenant aux étapes d'installation de JPA.

Étape 1: Vérifiez votre installation Java

Tout d'abord, vous devez disposer du kit de développement logiciel Java (SDK) installé sur votre système. Pour vérifier cela, exécutez l'une des deux commandes suivantes en fonction de la plate-forme sur laquelle vous travaillez.

Si l'installation de Java a été effectuée correctement, elle affichera la version actuelle et les spécifications de votre installation Java. Un exemple de sortie est donné dans le tableau suivant.

Plate-forme	Commander	Exemple de sortie
les fenêtres	Ouvrez la console de commande et tapez: \>java –version	Version Java "1.7.0_60" Environnement d'exécution Java (TM) SE (build 1.7.0_60-b19) VM serveur 64 bits Java Hotspot (TM) (build 24.60-b09, mode mixte)
Linux	Ouvrez le terminal de commande et tapez: $java –version	version java "1.7.0_25" Ouvrir l'environnement d'exécution JDK (rhel-2.3.10.4.el6_4-x86_64) Ouvrez la machine virtuelle du serveur JDK 64 bits (build 23.7-b01, mode mixte)

• Nous supposons que les lecteurs de ce didacticiel ont installé la version 1.7.0_60 du SDK Java sur leur système.

• Si vous ne disposez pas du SDK Java, téléchargez sa version actuelle sur http://www.oracle.com/technetwork/java/javase/downloads/index.html et faites-le installer.

Étape 2: définissez votre environnement Java

Définissez la variable d'environnement JAVA_HOME pour qu'elle pointe vers l'emplacement du répertoire de base où Java est installé sur votre machine. Par exemple,

Plate-forme	La description
les fenêtres	Définissez JAVA_HOME sur C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux	Exporter JAVA_HOME = / usr / local / java-current

Ajoutez le chemin complet de l'emplacement du compilateur Java au chemin système.

Plate-forme	La description
les fenêtres	Ajoutez la chaîne «C: \ Program Files \ Java \ jdk1.7.0_60 \ bin» à la fin de la variable système PATH.
Linux	Exporter PATH = $ PATH: $ JAVA_HOME / bin /

Exécutez la commande java -version à partir de l'invite de commande comme expliqué ci-dessus.

Étape 3: Installation de JPA

Vous pouvez effectuer l'installation de JPA en utilisant l'un des fournisseurs JPA de ce didacticiel, par exemple, Eclipselink, Hibernate. Suivons l'installation de JPA à l'aide d'Eclipselink. Pour la programmation JPA, nous devons suivre le cadre de dossier spécifique, il est donc préférable d'utiliser IDE.

Télécharger le formulaire Eclipse IDE suivant le lien https://www.eclipse.org/downloads/ Choisissez le développeur EclipseIDE pour JavaEE Eclipse indigo.

Décompressez le fichier zip Eclipse dans le lecteur C. Ouvrez Eclipse IDE.

Installation de JPA à l'aide d'Eclipselink

Eclipselink est une bibliothèque, nous ne pouvons donc pas l'ajouter directement à Eclipse IDE. Pour installer JPA à l'aide d'Eclipselink, vous devez suivre les étapes ci-dessous.

• Créez un nouveau projet JPA en sélectionnant File->New->JPA Project dans l'IDE Eclipse comme suit:

  

• Vous obtiendrez une boîte de dialogue nommée New JPA Project. Entrez le nom du projettutorialspoint_JPA_Eclipselink, vérifier la jre version et cliquez sur suivant:

  

• Cliquez sur télécharger la bibliothèque (si vous n'avez pas la bibliothèque) dans la section bibliothèque utilisateur.

  

• Sélectionnez la dernière version de la bibliothèque Eclipselink dans la boîte de dialogue Télécharger la bibliothèque et cliquez sur suivant comme suit:

  

• Acceptez les termes de la licence et cliquez sur Terminer pour télécharger la bibliothèque.

  

• 6. Le téléchargement démarre comme indiqué dans la capture d'écran suivante.

  

• Après le téléchargement, sélectionnez la bibliothèque téléchargée dans la section Bibliothèque utilisateur et cliquez sur Terminer.

  

• Enfin, vous obtenez le fichier de projet dans le Package Explorerdans Eclipse IDE. Extrayez tous les fichiers, vous obtiendrez la hiérarchie des dossiers et des fichiers comme suit:

  

Ajout d'un connecteur MySQL au projet

Tout exemple que nous discutons ici nécessite une connectivité de base de données. Considérons la base de données MySQL pour les opérations de base de données. Il nécessite le jar de mysql-connector pour interagir avec un programme Java.

Suivez les étapes pour configurer le fichier jar de base de données dans votre projet.

• Aller aux propriétés du projet ->Java Build Path en cliquant dessus avec le bouton droit de la souris. Vous obtiendrez une boîte de dialogue comme indiqué dans la capture d'écran suivante. Cliquez sur Add External Jars.

  

• Accédez à l'emplacement du fichier jar dans la mémoire de votre système, sélectionnez le fichier et cliquez sur Ouvrir.

  

• Cliquez sur OK dans la boîte de dialogue des propriétés. Vous obtiendrez le Jar du connecteur MySQL dans votre projet. Vous pouvez maintenant effectuer des opérations de base de données à l'aide de MySQL.

Ce chapitre utilise un exemple simple pour illustrer le fonctionnement de JPA. Prenons l'exemple de la gestion des employés. Supposons que la gestion des employés crée, met à jour, trouve et supprime les enregistrements d'un employé. Comme mentionné, nous utilisons la base de données MySQL pour les opérations de base de données.

Les principaux modules de cet exemple sont les suivants:

• Model or POJO

  Employee.java

• Persistence

  Persistence.xml

• Service

  CreatingEmployee.java

  UpdatingEmployee.java

  FindingEmployee.java

  DeletingEmployee.java

Prenons la hiérarchie des packages que nous avons utilisée dans l'installation JPA avec Eclipselink. Suivez la hiérarchie de cet exemple comme indiqué ci-dessous:

Créer des entités

Les entités ne sont que des beans ou des modèles. Dans cet exemple, nous utiliseronsEmployee en tant qu'entité. eid, ename, salary, et degsont les attributs de cette entité. Il contient un constructeur par défaut ainsi que les méthodes setter et getter de ces attributs.

Dans la hiérarchie ci-dessus, créez un package nommé ‘com.tutorialspoint.eclipselink.entity’, en dessous de ‘src’(Source) package. Créez une classe nomméeEmployee.java sous le paquet donné comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table
public class Employee 
{
	@Id
	@GeneratedValue(strategy= GenerationType.AUTO) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	public Employee(int eid, String ename, double salary, String deg) 
	{
		super( );
		this.eid = eid;
		this.ename = ename;
		this.salary = salary;
		this.deg = deg;
	}
	
	public Employee( ) 
	{
		super();
	}
	
	public int getEid( ) 
	{
		return eid;
	}
	public void setEid(int eid)  
	{
		this.eid = eid;
	}
    public String getEname( ) 
	{
		return ename;
	}
	public void setEname(String ename) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}
	@Override
	public String toString() {
		return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
				+ salary + ", deg=" + deg + "]";
	}
}

Dans le code ci-dessus, nous avons utilisé l'annotation @Entity pour faire de cette classe POJO une entité.

Avant de passer au module suivant, nous devons créer une base de données pour l'entité relationnelle, qui enregistrera la base de données dans persistence.xmlfichier. Ouvrez MySQL workbench et saisissez la requête suivante.

create database jpadb
use jpadb

Persistence.xml

Ce module joue un rôle crucial dans le concept de JPA. Dans ce fichier xml, nous enregistrerons la base de données et spécifierons la classe d'entité.

Dans la hiérarchie de packages illustrée ci-dessus, persistence.xml sous JPA Content package est le suivant:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
                         	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
	<properties>
	   <property name="javax.persistence.jdbc.url"
                   value="jdbc:mysql://localhost:3306/jpadb"/>
     	   <property name="javax.persistence.jdbc.user" value="root"/>
	       <property name="javax.persistence.jdbc.password" value="root"/>
	       <property name="javax.persistence.jdbc.driver"
                   value="com.mysql.jdbc.Driver"/>
           <property name="eclipselink.logging.level" value="FINE"/>
	       <property name="eclipselink.ddl-generation" 
		           value="create-tables"/>
	</properties>
	</persistence-unit>
</persistence>

Dans le xml ci-dessus, <persistence-unit> La balise est définie avec un nom spécifique pour la persistance JPA. le<class>La balise définit la classe d'entité avec le nom du package. le<properties> tag définit toutes les propriétés, et <property>La balise définit chaque propriété telle que l'enregistrement de la base de données, la spécification d'URL, le nom d'utilisateur et le mot de passe. Ce sont les propriétés Eclipselink. Ce fichier configurera la base de données.

Opérations de persistance

Les opérations de persistance sont utilisées pour interagir avec une base de données et sont load et storeopérations. Dans un composant métier, toutes les opérations de persistance relèvent des classes de service.

Dans la hiérarchie de packages illustrée ci-dessus, créez un package nommé ‘com.tutorialspoint.eclipselink.service’, en dessous de ‘src’(source) package. Toutes les classes de service nommées CreateEmloyee.java, UpdateEmployee.java, FindEmployee.java et DeleteEmployee.java. relève du package donné comme suit:

Créer un employé

Le segment de code suivant montre comment créer une classe Employee nommée CreateEmployee.java.

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class CreateEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		Employee employee = new Employee( ); 
		employee.setEid( 1201 );
		employee.setEname( "Gopal" );
		employee.setSalary( 40000 );
		employee.setDeg( "Technical Manager" );
		entitymanager.persist( employee );
		entitymanager.getTransaction( ).commit( );
		
		entitymanager.close( );
		emfactory.close( );
	}
}

Dans le code ci-dessus, le createEntityManagerFactory ()crée une unité de persistance en fournissant le même nom unique que celui fourni pour l'unité de persistance dans le fichier persistent.xml. leentitymanagerfactory objet créera le entitymanger instance en utilisant createEntityManager ()méthode. leentitymanager objet crée entitytransactioninstance pour la gestion des transactions. En utilisantentitymanager objet, nous pouvons conserver les entités dans la base de données.

Après la compilation et l'exécution du programme ci-dessus, vous recevrez des notifications de la bibliothèque eclipselink sur le panneau de la console de l'IDE eclipse.

Pour obtenir le résultat, ouvrez le plan de travail MySQL et saisissez les requêtes suivantes.

use jpadb
select * from employee

La table de base de données affectée nommée employee sera affiché dans un format tabulaire comme suit:

Eid	Ename	Un salaire	Degré
1201	Gopal	40000	Directeur technique

Mettre à jour l'employé

Pour mettre à jour les enregistrements d'un employé, nous devons récupérer les enregistrements existants de la base de données, apporter des modifications et enfin les valider dans la base de données. La classe nomméeUpdateEmployee.java s'affiche comme suit:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class UpdateEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
				entitymanager.getTransaction( ).begin( );
		Employee employee=entitymanager.
				find( Employee.class, 1201 );
		//before update
		System.out.println( employee );
		employee.setSalary( 46000 );
		entitymanager.getTransaction( ).commit( );
        //after update
		System.out.println( employee );
		entitymanager.close();
		emfactory.close();
	}
}

Après la compilation et l'exécution du programme ci-dessus, vous recevrez des notifications de la bibliothèque Eclipselink sur le panneau de la console de l'IDE eclipse.

Pour obtenir le résultat, ouvrez le plan de travail MySQL et saisissez les requêtes suivantes.

use jpadb
select * from employee

La table de base de données affectée nommée employee sera affiché dans un format tabulaire comme suit:

Eid	Ename	Un salaire	Degré
1201	Gopal	46 000	Directeur technique

Le salaire de l'employé, 1201 est mis à jour à 46000.

Trouver un employé

Pour trouver les enregistrements d'un employé, nous devrons récupérer les données existantes de la base de données et les afficher. Dans cette opération, EntityTransaction n'est pas appliquée lors de la récupération d'un enregistrement.

La classe nommée FindEmployee.java comme suit.

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class FindEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence
				.createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager();
		Employee employee = entitymanager.
				find( Employee.class, 1201 );
		
		System.out.println("employee ID = "+employee.getEid( ));
		System.out.println("employee NAME = "+employee.getEname( ));
		System.out.println("employee SALARY = "+employee.getSalary( ));
		System.out.println("employee DESIGNATION = "+employee.getDeg( ));
	}
}

Après avoir compilé et exécuté le programme ci-dessus, vous obtiendrez la sortie suivante de la bibliothèque Eclipselink sur le panneau de la console de l'IDE eclipse.

employee ID = 1201
employee NAME = Gopal
employee SALARY = 46000.0
employee DESIGNATION = Technical Manager

Suppression d'un employé

Pour supprimer les enregistrements d'un employé, nous allons d'abord rechercher les enregistrements existants, puis les supprimer. Ici, EntityTransaction joue un rôle important.

La classe nommée DeleteEmployee.java comme suit:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class DeleteEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		Employee employee=entitymanager.
				find( Employee.class, 1201 );
		entitymanager.remove( employee );
		entitymanager.getTransaction( ).commit( );
		entitymanager.close( );
		emfactory.close( );
	}
}

Après la compilation et l'exécution du programme ci-dessus, vous recevrez des notifications de la bibliothèque Eclipselink sur le panneau de la console de l'IDE eclipse.

Pour obtenir le résultat, ouvrez le plan de travail MySQL et saisissez les requêtes suivantes.

use jpadb
select * from employee

La base de données affectée nommée employee aura des enregistrements nuls.

Une fois tous les modules de cet exemple terminés, la hiérarchie des packages et des fichiers se présente comme suit:

Ce chapitre décrit JPQL et son fonctionnement avec les unités de persistance. Dans ce chapitre, les exemples donnés suivent la même hiérarchie de packages que celle utilisée dans le chapitre précédent.

Langage de requête de persistance Java

JPQL signifie Java Persistence Query Language. Il est utilisé pour créer des requêtes sur des entités à stocker dans une base de données relationnelle. JPQL est développé sur la base de la syntaxe SQL. Mais cela n'affectera pas directement la base de données.

JPQL peut récupérer des données à l'aide de la clause SELECT, peut effectuer des mises à jour en bloc à l'aide des clauses UPDATE et DELETE.

Structure de la requête

La syntaxe JPQL est très similaire à la syntaxe de SQL. Avoir une syntaxe similaire à SQL est un avantage car SQL est simple et largement utilisé. SQL fonctionne directement avec les tables, les enregistrements et les champs de base de données relationnelle, tandis que JPQL fonctionne avec les classes et les instances Java.

Par exemple, une requête JPQL peut récupérer un objet entité plutôt qu'un jeu de résultats de champ à partir d'une base de données, comme avec SQL. La structure de requête JPQL comme suit.

SELECT ... FROM ...
[WHERE ...]
[GROUP BY ... [HAVING ...]]
[ORDER BY ...]

La structure des requêtes JPQL DELETE et UPDATE est la suivante.

DELETE FROM ... [WHERE ...]
 
UPDATE ... SET ... [WHERE ...]

Fonctions scalaires et agrégées

Les fonctions scalaires renvoient des valeurs résultantes basées sur les valeurs d'entrée. Les fonctions d'agrégation renvoient les valeurs résultantes en calculant les valeurs d'entrée.

Nous utiliserons le même exemple de gestion des employés que dans le chapitre précédent. Ici, nous allons passer en revue les classes de service en utilisant les fonctions scalaires et agrégées de JPQL.

Supposons que le jpadb.employee La table contient les enregistrements suivants.

Eid	Ename	Un salaire	Degré
1201	Gopal	40000	Directeur technique
1202	Manisha	40000	Lecteur d'épreuves
1203	Masthanvali	40000	Rédacteur technique
1204	Satish	30000	Rédacteur technique
1205	Krishna	30000	Rédacteur technique
1206	Kiran	35 000	Lecteur d'épreuves

Créez une classe nommée ScalarandAggregateFunctions.java en dessous de com.tutorialspoint.eclipselink.service paquet comme suit.

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

public class ScalarandAggregateFunctions 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager();
		//Scalar function
		Query query = entitymanager.
		createQuery("Select UPPER(e.ename) from Employee e");
		List<String> list=query.getResultList();
		
		for(String e:list)
		{
			System.out.println("Employee NAME :"+e);
		}
		//Aggregate function
		Query query1 = entitymanager.
				createQuery("Select MAX(e.salary) from Employee e");
		Double result=(Double) query1.getSingleResult();
		System.out.println("Max Employee Salary :"+result);
	}
}

Après la compilation et l'exécution du programme ci-dessus, vous obtiendrez la sortie suivante sur le panneau de la console d'Eclipse IDE.

Employee NAME :GOPAL
Employee NAME :MANISHA
Employee NAME :MASTHANVALI
Employee NAME :SATISH
Employee NAME :KRISHNA
Employee NAME :KIRAN
ax Employee Salary :40000.0

Entre, et, comme des mots clés

Between, And, et Likesont les principaux mots-clés de JPQL. Ces mots clés sont utilisés aprèsWhere clause dans une requête.

Créez une classe nommée BetweenAndLikeFunctions.java en dessous de com.tutorialspoint.eclipselink.service paquet comme suit:

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.eclipselink.entity.Employee;

public class BetweenAndLikeFunctions 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
			createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
			createEntityManager();
		//Between
		Query query = entitymanager.
			createQuery( "Select e " +
					     "from Employee e " +
					     "where e.salary " +
					     "Between 30000 and 40000" )
		List<Employee> list=(List<Employee>)query.getResultList( );
		 
		for( Employee e:list )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee salary :"+e.getSalary( ));
		}
		
		//Like
		Query query1 = entitymanager.
			createQuery("Select e " +
					    "from Employee e " +
					    "where e.ename LIKE 'M%'");
		List<Employee> list1=(List<Employee>)query1.getResultList( );
		for( Employee e:list1 )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee name :"+e.getEname( ));
		}
	}
}

Après avoir compilé et exécuté le programme ci-dessus, vous obtiendrez la sortie suivante dans le panneau de la console d'Eclipse IDE.

Employee ID :1201	 Employee salary :40000.0
Employee ID :1202	 Employee salary :40000.0
Employee ID :1203	 Employee salary :40000.0
Employee ID :1204	 Employee salary :30000.0
Employee ID :1205	 Employee salary :30000.0
Employee ID :1206	 Employee salary :35000.0

Employee ID :1202	 Employee name :Manisha
Employee ID :1203	 Employee name :Masthanvali

Commande

Pour commander les enregistrements en JPQL, nous utilisons la clause ORDER BY. L'utilisation de cette clause est la même que dans SQL, mais elle traite des entités. L'exemple suivant montre comment utiliser la clause ORDER BY.

Créer une classe Ordering.java en dessous de com.tutorialspoint.eclipselink.service paquet comme suit:

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.eclipselink.entity.Employee;

public class Ordering 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
			createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
			createEntityManager();
		//Between
		Query query = entitymanager.
			createQuery( "Select e " +
					     "from Employee e " +
					     "ORDER BY e.ename ASC" );
		List<Employee> list=(List<Employee>)query.getResultList( );
		 
		for( Employee e:list )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee Name :"+e.getEname( ));
		}
	}
}

en compilant et en exécutant le programme ci-dessus, vous produirez la sortie suivante dans le panneau de la console d'Eclipse IDE.

Employee ID :1201	 Employee Name :Gopal
Employee ID :1206	 Employee Name :Kiran
Employee ID :1205	 Employee Name :Krishna
Employee ID :1202	 Employee Name :Manisha
Employee ID :1203	 Employee Name :Masthanvali
Employee ID :1204	 Employee Name :Satish

Requêtes nommées

Une annotation @NamedQuery est définie comme une requête avec une chaîne de requête prédéfinie qui n'est pas modifiable. Contrairement aux requêtes dynamiques, les requêtes nommées peuvent améliorer l'organisation du code en séparant les chaînes de requête JPQL de POJO. Il transmet également les paramètres de requête plutôt que d'incorporer les littéraux de manière dynamique dans la chaîne de requête et produit donc des requêtes plus efficaces.

Tout d'abord, ajoutez l'annotation @NamedQuery à la classe d'entité Employee nommée Employee.java en dessous de com.tutorialspoint.eclipselink.entity paquet comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;

@Entity
@Table
@NamedQuery(query = "Select e from Employee e where e.eid = :id", 
		name = "find employee by id")
public class Employee 
{
	@Id
	@GeneratedValue(strategy= GenerationType.AUTO) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	public Employee(int eid, String ename, double salary, String deg) 
	{
		super( );
		this.eid = eid;
		this.ename = ename;
		this.salary = salary;
		this.deg = deg;
	}
	public Employee( ) 
	{
		super();
	}
	
	public int getEid( ) 
	{
		return eid;
	}
	public void setEid(int eid)  
	{
		this.eid = eid;
	}
	
	public String getEname( ) 
	{
		return ename;
	}
	public void setEname(String ename) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}
	@Override
	public String toString() {
		return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
				+ salary + ", deg=" + deg + "]";
	}
}

Créez une classe nommée NamedQueries.java en dessous de com.tutorialspoint.eclipselink.service paquet comme suit:

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.eclipselink.entity.Employee;

public class NamedQueries 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
			createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
			createEntityManager();
		Query query = entitymanager.createNamedQuery(
			"find employee by id");
		query.setParameter("id", 1204);
		List<Employee> list = query.getResultList( );
		for( Employee e:list )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee Name :"+e.getEname( ));
		}
	}
}

Après avoir compilé et exécuté le programme ci-dessus, vous obtiendrez la sortie suivante dans le panneau de la console d'Eclipse IDE.

Employee ID :1204	 Employee Name :Satish

Après avoir ajouté toutes les classes ci-dessus, la hiérarchie des packages se présente comme suit:

Récupération impatiente et paresseuse

Le concept le plus important de JPA est de faire une copie de la base de données dans la mémoire cache. Lors des transactions avec une base de données, le JPA crée d'abord un ensemble de données en double et seulement lorsqu'il est validé à l'aide d'un gestionnaire d'entités, les modifications sont effectuées dans la base de données.

Il existe deux manières d'extraire des enregistrements de la base de données.

Envie d'aller chercher

Dans la récupération impatiente, les objets enfants associés sont téléchargés automatiquement lors de la récupération d'un enregistrement particulier.

Récupération paresseuse

Dans la récupération différée, les objets associés ne sont pas téléchargés automatiquement, sauf si vous les demandez spécifiquement. Tout d'abord, il vérifie la disponibilité des objets associés et notifie. Plus tard, si vous appelez l'une des méthodes getter de cette entité, elle récupère tous les enregistrements.

La récupération différée est possible lorsque vous essayez de récupérer les enregistrements pour la première fois. De cette façon, une copie de l'ensemble de l'enregistrement est déjà stockée dans la mémoire cache. La récupération paresseuse en termes de performances est préférable.

JPA est une bibliothèque publiée avec des spécifications Java. Par conséquent, il prend en charge tous les concepts orientés objet pour la persistance des entités. Jusqu'à présent, nous en avons terminé avec les bases du mappage relationnel d'objets. Ce chapitre vous présente les mappages avancés entre les objets et les entités relationnelles.

Stratégies d'héritage

L'héritage est le concept de base de tout langage orienté objet, nous pouvons donc utiliser des relations ou des stratégies d'héritage entre entités. JPA prend en charge trois types de stratégies d'héritage: SINGLE_TABLE, JOINED_TABLE et TABLE_PER_CONCRETE_CLASS.

Analysons un exemple. Le diagramme suivant montre trois classes, à savoir. Personnel, personnel enseignant et personnel non enseignant, et leurs relations.

Dans le diagramme ci-dessus, le personnel est une entité, tandis que le personnel enseignant et le personnel non enseignant sont les sous-entités du personnel. Ici, nous utiliserons l'exemple ci-dessus pour démontrer les trois stratégies d'héritage.

Stratégie de table unique

La stratégie de table unique prend tous les champs de classes (super et sous-classes) et les mappe dans une seule table connue sous le nom de stratégie SINGLE_TABLE. Ici, la valeur du discriminateur joue un rôle clé dans la différenciation des valeurs de trois entités dans une table.

Prenons l'exemple ci-dessus. TeachingStaff et NonTeachingStaff sont les sous-classes du personnel. Selon le concept d'héritage, une sous-classe hérite des propriétés de sa super-classe. Par conséquent, sid et sname sont les champs qui appartiennent à la fois à TeachingStaff et NonTeachingStaff. Créez un projet JPA. Tous les modules de ce projet sont les suivants:

Créer des entités

Créez un package nommé ‘com.tutorialspoint.eclipselink.entity’ en dessous de ‘src’paquet. Créez une nouvelle classe Java nomméeStaff.javasous le paquet donné. La classe d'entité Staff est présentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import java.io.Serializable;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;
@Entity
@Table
@Inheritance( strategy = InheritanceType.SINGLE_TABLE )
@DiscriminatorColumn( name="type" )
public class Staff implements Serializable 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int sid;
	private String sname;
	public Staff( int sid, String sname ) 
	{
		super( );
		this.sid = sid;
		this.sname = sname;
	}
	public Staff( ) 
	{
		super( );
	}
	public int getSid( ) 
	{
		return sid;
	}
	public void setSid( int sid ) 
	{
		this.sid = sid;
	}
	public String getSname( ) 
	{
		return sname;
	}
	public void setSname( String sname ) 
	{
		this.sname = sname;
	}
}

Dans le code ci-dessus @DescriminatorColumn spécifie le nom du champ (type) et ses valeurs affichent les champs restants (Teaching et NonTeachingStaff).

Créez une sous-classe (classe) dans la classe Staff nommée TeachingStaff.java sous le com.tutorialspoint.eclipselink.entitypaquet. La classe Entité TeachingStaff est représentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue( value="TS" )
public class TeachingStaff extends Staff 
{
	private String qualification;
	private String subjectexpertise;
	
	public TeachingStaff( int sid, String sname, 
			String qualification,String subjectexpertise ) 
	{
		super( sid, sname );
		this.qualification = qualification;
		this.subjectexpertise = subjectexpertise;
	}
	
	public TeachingStaff( ) 
	{
		super( );
	}

	public String getQualification( )
	{
		return qualification;
	}

	public void setQualification( String qualification )
	{
		this.qualification = qualification;
	}

	public String getSubjectexpertise( ) 
	{
		return subjectexpertise;
	}

	public void setSubjectexpertise( String subjectexpertise )
	{
		this.subjectexpertise = subjectexpertise;
	}
}

Créez une sous-classe (classe) dans la classe Staff nommée NonTeachingStaff.java sous le com.tutorialspoint.eclipselink.entitypaquet. La classe d'entité NonTeachingStaff est affichée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue( value = "NS" )
public class NonTeachingStaff extends Staff 
{
	private String areaexpertise;

	public NonTeachingStaff( int sid, String sname, 
			String areaexpertise ) 
	{
		super( sid, sname );
		this.areaexpertise = areaexpertise;
	}

	public NonTeachingStaff( ) 
	{
		super( );
	}

	public String getAreaexpertise( ) 
	{
		return areaexpertise;
	}

	public void setAreaexpertise( String areaexpertise )
	{
		this.areaexpertise = areaexpertise;
	}
}

Persistence.xml

Persistence.xml contient les informations de configuration de la base de données et les informations d'enregistrement des classes d'entités. Le fichier xml est affiché comme suit:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	    <class>com.tutorialspoint.eclipselink.entity.Staff</class>
		<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
		<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
                            value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
                            value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
                            value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Classe de service

Les classes de service sont la partie implémentation du composant métier. Créez un package sous‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’.

Créez une classe nommée SaveClient.javasous le package donné pour stocker les champs de classe Staff, TeachingStaff et NonTeachingStaff. La classe SaveClient est présentée comme suit:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;

public class SaveClient 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Teaching staff entity 
		TeachingStaff ts1=new TeachingStaff(
				1,"Gopal","MSc MEd","Maths");
		TeachingStaff ts2=new TeachingStaff(
				2, "Manisha", "BSc BEd", "English");
		//Non-Teaching Staff entity
		NonTeachingStaff nts1=new NonTeachingStaff(
				3, "Satish", "Accounts");
		NonTeachingStaff nts2=new NonTeachingStaff(
				4, "Krishna", "Office Admin");
		
		//storing all entities
		entitymanager.persist(ts1);
		entitymanager.persist(ts2);
		entitymanager.persist(nts1);
		entitymanager.persist(nts2);
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Après avoir compilé et exécuté le programme ci-dessus, vous recevrez des notifications sur le panneau de la console d'Eclipse IDE. Vérifiez le workbench MySQL pour la sortie. La sortie dans un format tabulaire est présentée comme suit:

Sid	Type	Le nom de	Expertise régionale	Qualification	Expertise en matière
1	TS	Gopal		MSC MED	Mathématiques
2	TS	Manisha		LIT BSC	Anglais
3	NS	Satish	Comptes
4	NS	Krishna	Administrateur de bureau

Enfin, vous obtiendrez une seule table contenant le champ des trois classes avec une colonne discriminante nommée Type (champ).

Stratégie de table jointe

La stratégie de table jointe consiste à partager la colonne référencée qui contient des valeurs uniques pour rejoindre la table et effectuer des transactions faciles. Prenons le même exemple que ci-dessus.

Créez un projet JPA. Tous les modules du projet sont présentés ci-dessous.

Créer des entités

Créez un package nommé ‘com.tutorialspoint.eclipselink.entity’ en dessous de ‘src’paquet. Créez une nouvelle classe Java nomméeStaff.javasous le paquet donné. La classe d'entité Staff est présentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;

@Entity
@Table
@Inheritance( strategy = InheritanceType.JOINED )
public class Staff implements Serializable 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int sid;
	private String sname;
	public Staff( int sid, String sname ) 
	{
		super( );
		this.sid = sid;
		this.sname = sname;
	}
	public Staff( ) 
	{
		super( );
	}
	public int getSid( ) 
	{
		return sid;
	}
	public void setSid( int sid ) 
	{
		this.sid = sid;
	}
	public String getSname( ) 
	{
		return sname;
	}
	public void setSname( String sname ) 
	{
		this.sname = sname;
	}
}

Créez une sous-classe (classe) dans la classe Staff nommée TeachingStaff.java sous le com.tutorialspoint.eclipselink.entitypaquet. La classe Entité TeachingStaff est représentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@PrimaryKeyJoinColumn(referencedColumnName="sid")
public class TeachingStaff extends Staff 
{
	private String qualification;
	private String subjectexpertise;
	
	public TeachingStaff( int sid, String sname, 
			String qualification,String subjectexpertise ) 
	{
		super( sid, sname );
		this.qualification = qualification;
		this.subjectexpertise = subjectexpertise;
	}
	
	public TeachingStaff( ) 
	{
		super( );
		
	}

	public String getQualification( )
	{
		return qualification;
	}

	public void setQualification( String qualification )
	{
		this.qualification = qualification;
	}

	public String getSubjectexpertise( ) 
	{
		return subjectexpertise;
	}

	public void setSubjectexpertise( String subjectexpertise )
	{
		this.subjectexpertise = subjectexpertise;
	}
}

Créez une sous-classe (classe) dans la classe Staff nommée NonTeachingStaff.java sous le com.tutorialspoint.eclipselink.entitypaquet. La classe d'entité NonTeachingStaff est affichée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@PrimaryKeyJoinColumn(referencedColumnName="sid")
public class NonTeachingStaff extends Staff 
{
	private String areaexpertise;

	public NonTeachingStaff( int sid, String sname, 
			String areaexpertise ) 
	{
		super( sid, sname );
		this.areaexpertise = areaexpertise;
	}

	public NonTeachingStaff( ) 
	{
		super( );
	}

	public String getAreaexpertise( ) 
	{
		return areaexpertise;
	}

	public void setAreaexpertise( String areaexpertise )
	{
		this.areaexpertise = areaexpertise;
	}
}

Persistence.xml

Le fichier Persistence.xml contient les informations de configuration de la base de données et les informations d'enregistrement des classes d'entités. Le fichier xml est affiché comme suit:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Staff</class>
	<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
	<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
                            value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
                            value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
                            value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Classe de service

Les classes de service sont la partie implémentation du composant métier. Créez un package sous‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’.

Créez une classe nommée SaveClient.javasous le package donné pour stocker les champs de la classe Staff, TeachingStaff et NonTeachingStaff. Ensuite, la classe SaveClient est affichée comme suit:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;

public class SaveClient 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Teaching staff entity 
		TeachingStaff ts1=new TeachingStaff(
				1,"Gopal","MSc MEd","Maths");
		TeachingStaff ts2=new TeachingStaff(
				2, "Manisha", "BSc BEd", "English");
		//Non-Teaching Staff entity
		NonTeachingStaff nts1=new NonTeachingStaff(
				3, "Satish", "Accounts");
		NonTeachingStaff nts2=new NonTeachingStaff(
		4, "Krishna", "Office Admin");
		
		//storing all entities
		entitymanager.persist(ts1);
		entitymanager.persist(ts2);
		entitymanager.persist(nts1);
		entitymanager.persist(nts2);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Après avoir compilé et exécuté le programme ci-dessus, vous recevrez des notifications dans le panneau de la console d'Eclipse IDE. Pour la sortie, consultez MySQL workbench.

Ici, trois tableaux sont créés et le résultat de staff Le tableau est affiché dans un format tabulaire.

Sid	Dtype	Le nom de
1	Personnel enseignant	Gopal
2	Personnel enseignant	Manisha
3	Personnel non enseignant	Satish
4	Personnel non enseignant	Krishna

Le résultat de TeachingStaff le tableau s'affiche comme suit:

Sid	Qualification	Expertise en matière
1	MSC MED	Mathématiques
2	LIT BSC	Anglais

Dans le tableau ci-dessus, sid est la clé étrangère (champ de référence du tableau des employés) Le résultat de NonTeachingStaff le tableau s'affiche comme suit:

Sid	Expertise régionale
3	Comptes
4	Administrateur de bureau

Enfin, les trois tables sont créées à l'aide de leurs champs respectifs et le champ SID est partagé par les trois tables. Dans la table Staff, SID est la clé primaire. Dans les deux tables restantes (TeachingStaff et NonTeachingStaff), SID est la clé étrangère.

Stratégie de table par classe

La stratégie de table par classe consiste à créer une table pour chaque sous-entité. La table Staff sera créée, mais elle contiendra des valeurs nulles. Les valeurs de champ de la table Staff doivent être partagées par les tables TeachingStaff et NonTeachingStaff.

Prenons le même exemple que ci-dessus.

Créer des entités

Créez un package nommé ‘com.tutorialspoint.eclipselink.entity’ en dessous de ‘src’paquet. Créez une nouvelle classe Java nomméeStaff.javasous le paquet donné. La classe d'entité Staff est présentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;

@Entity
@Table
@Inheritance( strategy = InheritanceType.TABLE_PER_CLASS )
public class Staff implements Serializable 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int sid;
	private String sname;
	public Staff( int sid, String sname ) 
	{
		super( );
		this.sid = sid;
		this.sname = sname;
	}
	public Staff( ) 
	{
		super( );
	}
	public int getSid( ) 
	{
		return sid;
	}
	public void setSid( int sid ) 
	{
		this.sid = sid;
	}
	public String getSname( ) 
	{
		return sname;
	}
	public void setSname( String sname ) 
	{
		this.sname = sname;
	}
}

Créez une sous-classe (classe) dans la classe Staff nommée TeachingStaff.java sous le com.tutorialspoint.eclipselink.entitypaquet. La classe Entité TeachingStaff est représentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
public class TeachingStaff extends Staff 
{
	private String qualification;
	private String subjectexpertise;
	
	public TeachingStaff( int sid, String sname, 
			String qualification,String subjectexpertise ) 
	{
		super( sid, sname );
		this.qualification = qualification;
		this.subjectexpertise = subjectexpertise;
	}
	
	public TeachingStaff( ) 
	{
		super( );
		
	}

	public String getQualification( )
	{
		return qualification;
	}
	public void setQualification( String qualification )
	{
		this.qualification = qualification;
	}

	public String getSubjectexpertise( ) 
	{
		return subjectexpertise;
	}

	public void setSubjectexpertise( String subjectexpertise )
	{
		this.subjectexpertise = subjectexpertise;
	}
}

Créez une sous-classe (classe) dans la classe Staff nommée NonTeachingStaff.java sous le com.tutorialspoint.eclipselink.entitypaquet. La classe d'entité NonTeachingStaff est affichée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
public class NonTeachingStaff extends Staff 
{
	private String areaexpertise;

	public NonTeachingStaff( int sid, String sname, 
			String areaexpertise )
			{
		super( sid, sname );
		this.areaexpertise = areaexpertise;
	}

	public NonTeachingStaff( ) 
	{
		super( );
	}

	public String getAreaexpertise( ) 
	{
		return areaexpertise;
	}

	public void setAreaexpertise( String areaexpertise )
	{
		this.areaexpertise = areaexpertise;
	}
}

Persistence.xml

Le fichier Persistence.xml contient les informations de configuration de la base de données et les informations d'enregistrement des classes d'entités. Le fichier xml est affiché comme suit:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Staff</class>
	<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
	<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
                            value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
                            value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
                            value="create-tables"/>
			</properties>
	</persistence-unit>
</persistence>

Classe de service

Les classes de service sont la partie implémentation du composant métier. Créez un package sous‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’.

Créez une classe nommée SaveClient.javasous le package donné pour stocker les champs de classe Staff, TeachingStaff et NonTeachingStaff. La classe SaveClient est présentée comme suit:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;
public class SaveClient 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Teaching staff entity 
		TeachingStaff ts1=new TeachingStaff(
				1,"Gopal","MSc MEd","Maths");
		TeachingStaff ts2=new TeachingStaff(
				2, "Manisha", "BSc BEd", "English");
		//Non-Teaching Staff entity
		NonTeachingStaff nts1=new NonTeachingStaff(
				3, "Satish", "Accounts");
		NonTeachingStaff nts2=new NonTeachingStaff(
				4, "Krishna", "Office Admin");
		
		//storing all entities
		entitymanager.persist(ts1);
		entitymanager.persist(ts2);
		entitymanager.persist(nts1);
		entitymanager.persist(nts2);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Après avoir compilé et exécuté le programme ci-dessus, vous recevrez des notifications sur le panneau de la console d'Eclipse IDE. Pour la sortie, consultez MySQL workbench.

Ici, les trois tableaux sont créés et le Staff La table contient des enregistrements nuls.

Le résultat de TeachingStaff s'affiche comme suit:

Sid	Qualification	Le nom de	Expertise en matière
1	MSC MED	Gopal	Mathématiques
2	LIT BSC	Manisha	Anglais

Le tableau ci-dessus TeachingStaff contient les champs des entités Staff et TeachingStaff.

Le résultat de NonTeachingStaff s'affiche comme suit:

Sid	Expertise régionale	Le nom de
3	Comptes	Satish
4	Administrateur de bureau	Krishna

Le tableau ci-dessus NonTeachingStaff contient les champs des entités Staff et NonTeachingStaff.

Ce chapitre vous présente les relations entre les entités. En général, les relations sont plus efficaces entre les tables de la base de données. Ici, les classes d'entités sont traitées comme des tables relationnelles (concept de JPA), donc les relations entre les classes d'entités sont les suivantes:

• @ManyToOne Relation
• Relation @OneToMany
• Relation @OneToOne
• @ManyToMany Relation

@ManyToOne Relation

Une relation plusieurs-à-un entre les entités existe lorsqu'une entité (colonne ou ensemble de colonnes) est référencée avec une autre entité (colonne ou ensemble de colonnes) contenant des valeurs uniques. Dans les bases de données relationnelles, ces relations sont appliquées à l'aide d'une clé étrangère / clé primaire entre les tables.

Prenons un exemple de relation entre les entités Employé et Département. De manière unidirectionnelle, c'est-à-dire d'un employé au service, la relation plusieurs-à-un est applicable. Cela signifie que chaque enregistrement d'employé contient un identifiant de service, qui doit être une clé primaire dans la table Department. Ici, dans la table Employee, l'ID de service est la clé étrangère.

Le diagramme suivant montre la relation plusieurs-à-un entre les deux tables.

Créer un projet JPA dans l'EDI eclipse nommé JPA_Eclipselink_MTO. Tous les modules de ce projet sont décrits ci-dessous.

Créer des entités

Suivez le diagramme ci-dessus pour créer des entités. Créez un package nommé‘com.tutorialspoin.eclipselink.entity’ en dessous de ‘src’paquet. Créez une classe nomméeDepartment.javasous le paquet donné. L'entité de classe Department est représentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Department 
{
    @Id 
    @GeneratedValue( strategy=GenerationType.AUTO )
    private int id;
    private String name;

    public int getId() 
    {
    	return id;
    }
    
    public void setId(int id) 
    {
    	this.id = id;
    }
    
    public String getName( )
    {
    	return name;
    }
    
    public void setName( String deptName )
    {
    	this.name = deptName;
    }
}

Créez la deuxième entité dans cette relation - Classe d'entité Employee nommée Employee.java en dessous de ‘com.tutorialspoint.eclipselink.entity’paquet. La classe d'entité Employee est présentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue( strategy= GenerationType.AUTO ) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	@ManyToOne
	private Department department;
	
	public Employee(int eid, 
			String ename, double salary, String deg) 
	{
		super( );
		this.eid = eid;
		this.ename = ename;
		this.salary = salary;
		this.deg = deg;
	}
	
	public Employee( ) 
	{
		super();
	}
	
	public int getEid( ) 
	{
		return eid;
	}
	public void setEid(int eid)  
	{
		this.eid = eid;
	}
	
	public String getEname( ) 
	{
		return ename;
	}
	public void setEname(String ename) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}
		
	public Department getDepartment() {
		return department;
	}

	public void setDepartment(Department department) {
		this.department = department;
	}
}

Persistence.xml

Le fichier Persistence.xml est requis pour configurer la base de données et l'enregistrement des classes d'entités.

Persitence.xml sera créé par l'EDI eclipse lors de la création d'un projet JPA. Les détails de configuration sont les spécifications de l'utilisateur. Le fichier persistence.xml est présenté comme suit:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
	<class>com.tutorialspoint.eclipselink.entity.Department</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password"
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Classes de service

Ce module contient les classes de service, qui implémentent la partie relationnelle à l'aide de l'initialisation d'attribut. Créez un package sous‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’. La classe DAO nomméeManyToOne.javaest créé sous un package donné. La classe DAO est représentée comme suit:

package com.tutorialspointeclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;

public class ManyToOne 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Department Entity
		Department department = new Department();
		department.setName("Development");
		//Store Department
		entitymanager.persist(department);
		
		//Create Employee1 Entity
		Employee employee1 = new Employee();
		employee1.setEname("Satish");
		employee1.setSalary(45000.0);
		employee1.setDeg("Technical Writer");
		employee1.setDepartment(department);

		//Create Employee2 Entity
		Employee employee2 = new Employee();
		employee2.setEname("Krishna");
		employee2.setSalary(45000.0);
		employee2.setDeg("Technical Writer");
		employee2.setDepartment(department);

		//Create Employee3 Entity
		Employee employee3 = new Employee();
		employee3.setEname("Masthanvali");
		employee3.setSalary(50000.0);
		employee3.setDeg("Technical Writer");
		employee3.setDepartment(department);
		
		//Store Employees
		entitymanager.persist(employee1);
		entitymanager.persist(employee2);
		entitymanager.persist(employee3);
				
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Après avoir compilé et exécuté le programme ci-dessus, vous recevrez des notifications sur le panneau de la console d'Eclipse IDE. Pour la sortie, consultez MySQL workbench. Dans cet exemple, deux tables sont créées.

Passez la requête suivante dans l'interface MySQL et le résultat de Department Le tableau sera affiché comme suit:

Select * from department

ID	Nom
101	Développement

Passez la requête suivante dans l'interface MySQL et le résultat de Employee Le tableau sera affiché comme suit.

Select * from employee

Eid	Degré	Ename	Un salaire	Department_Id
102	Rédacteur technique	Satish	45 000	101
103	Rédacteur technique	Krishna	45 000	101
104	Rédacteur technique	Masthanwali	50000	101

Dans la table ci-dessus Deparment_Id est la clé étrangère (champ de référence) de la table Department.

Relation @OneToMany

Dans cette relation, chaque ligne d'une entité est référencée à de nombreux enregistrements enfants dans une autre entité. L'important est que les enregistrements enfants ne peuvent pas avoir plusieurs parents. Dans une relation un-à-plusieurs entre le tableau A et le tableau B, chaque ligne du tableau A peut être liée à une ou plusieurs lignes du tableau B.

Prenons l'exemple ci-dessus. Supposons que les tables Employee et Department de l'exemple ci-dessus soient connectées de manière unidirectionnelle inverse, alors la relation devient une relation un-à-plusieurs. Créer un projet JPA dans l'EDI eclipse nomméJPA_Eclipselink_OTM. Tous les modules de ce projet sont décrits ci-dessous.

Créer des entités

Suivez le diagramme ci-dessus pour créer des entités. Créez un package nommé‘com.tutorialspoin.eclipselink.entity’ en dessous de ‘src’paquet. Créez une classe nomméeDepartment.javasous le paquet donné. L'entité de classe Department est représentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;

@Entity
public class Department 
{
    @Id 
    @GeneratedValue( strategy=GenerationType.AUTO )
    private int id;
    private String name;
    
    @OneToMany( targetEntity=Employee.class )
    private List employeelist;

    public int getId() 
    {
    	return id;
    }
    
    public void setId(int id) 
    {
    	this.id = id;
    }
    
    public String getName( )
    {
    	return name;
    }
    
    public void setName( String deptName )
    {
    	this.name = deptName;
    }

    public List getEmployeelist() 
    {
	return employeelist;
    }

    public void setEmployeelist(List employeelist) 
    {
	this.employeelist = employeelist;
    }
}

Créez la deuxième entité dans cette relation -Employee entity class, nommée Employee.java en dessous de ‘com.tutorialspoint.eclipselink.entity’paquet. La classe d'entité Employee est présentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue( strategy= GenerationType.AUTO ) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
		
	public Employee(int eid, 
			String ename, double salary, String deg) 
	{
		super( );
		this.eid = eid;
		this.ename = ename;
		this.salary = salary;
		this.deg = deg;
	}
	
	public Employee( ) 
	{
		super();
	}
	
	public int getEid( ) 
	{
		return eid;
	}
	public void setEid(int eid)  
	{
		this.eid = eid;
	}
	
	public String getEname( ) 
	{
		return ename;
	}
	public void setEname(String ename) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}	
}

Persistence.xml

Le fichier persistence.xml se présente comme suit:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
	<class>com.tutorialspoint.eclipselink.entity.Department</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Classes de service

Ce module contient les classes de service, qui implémentent la partie relationnelle à l'aide de l'initialisation d'attribut. Créez un package sous‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’. La classe DAO nomméeOneToMany.javaest créé sous un package donné. La classe DAO est représentée comme suit:

package com.tutorialspointeclipselink.service;

import java.util.List;
import java.util.ArrayList;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;

public class OneToMany 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Employee1 Entity
		Employee employee1 = new Employee();
		employee1.setEname("Satish");
		employee1.setSalary(45000.0);
		employee1.setDeg("Technical Writer");
								
		//Create Employee2 Entity
		Employee employee2 = new Employee();
		employee2.setEname("Krishna");
		employee2.setSalary(45000.0);
		employee2.setDeg("Technical Writer");
								
		//Create Employee3 Entity
		Employee employee3 = new Employee();
		employee3.setEname("Masthanvali");
		employee3.setSalary(50000.0);
		employee3.setDeg("Technical Writer");
		
		//Store Employee
		entitymanager.persist(employee1);
		entitymanager.persist(employee2);
		entitymanager.persist(employee3);
		
		//Create Employeelist
		List<Employee> emplist = new ArrayList();
		emplist.add(employee1);
		emplist.add(employee2);
		emplist.add(employee3);
		
		//Create Department Entity
		Department department= new Department();
		department.setName("Development");
		department.setEmployeelist(emplist);
				
		//Store Department
		entitymanager.persist(department);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Après la compilation et l'exécution du programme ci-dessus, vous recevrez des notifications dans le panneau de la console d'Eclipse IDE. Pour la sortie, vérifiez le workbench MySQL comme suit.

Dans ce projet, trois tables sont créées. Passez la requête suivante dans l'interface MySQL et le résultat de la table department_employee s'affichera comme suit:

Select * from department_Id;

Department_ID	Employee_Eid
254	251
254	252
254	253

Dans le tableau ci-dessus, deparment_id et employee_id sont les clés étrangères (champs de référence) des tables de service et d'employé.

Passez la requête suivante dans l'interface MySQL et le résultat de la table de service sera affiché dans un format tabulaire comme suit.

Select * from department;

ID	Nom
254	Développement

Passez la requête suivante dans l'interface MySQL et le résultat de la table des employés s'affichera comme suit:

Select * from employee;

Eid	Degré	Ename	Un salaire
251	Rédacteur technique	Satish	45 000
252	Rédacteur technique	Krishna	45 000
253	Rédacteur technique	Masthanwali	50000

Relation @OneToOne

Dans une relation un-à-un, un élément ne peut être lié qu'à un seul autre élément. Cela signifie que chaque ligne d'une entité est référencée à une et une seule ligne d'une autre entité.

Prenons l'exemple ci-dessus. Employee et Departmentde manière unidirectionnelle inverse, la relation est une relation un-à-un. Cela signifie que chaque employé appartient à un seul département. Créer un projet JPA dans l'EDI eclipse nomméJPA_Eclipselink_OTO. Tous les modules de ce projet sont décrits ci-dessous.

Créer des entités

Suivez le diagramme ci-dessus pour créer des entités. Créez un package nommé‘com.tutorialspoin.eclipselink.entity’ en dessous de ‘src’paquet. Créez une classe nomméeDepartment.javasous le paquet donné. L'entité de classe Department est représentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Department 
{
    @Id 
    @GeneratedValue( strategy=GenerationType.AUTO )
    private int id;
    private String name;
   
    public int getId() 
    {
    	return id;
    }
    
    public void setId(int id) 
    {
    	this.id = id;
    }
    
    public String getName( )
    {
    	return name;
    }
    
    public void setName( String deptName )
    {
    	this.name = deptName;
    }
}

Créez la deuxième entité dans cette relation -Employee entity class, nommée Employee.java en dessous de ‘com.tutorialspoint.eclipselink.entity’paquet. La classe d'entité Employee est présentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue( strategy= GenerationType.AUTO ) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	
	@OneToOne
	private Department department;
		
	public Employee(int eid, 
			String ename, double salary, String deg) 
	{
		super( );
		this.eid = eid;
		this.ename = ename;
		this.salary = salary;
		this.deg = deg;
	}
	
	public Employee( ) 
	{
		super();
	}
	
	public int getEid( ) 
	{
		return eid;
	}
	public void setEid(int eid)  
	{
		this.eid = eid;
	}
	
	public String getEname( ) 
	{
		return ename;
	}
	public void setEname(String ename) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}

	public Department getDepartment() 
	{
		return department;
	}

	public void setDepartment(Department department) 
	{
		this.department = department;
	}	
}

Persistence.xml

Fichier Persistence.xml comme suit:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
	<class>com.tutorialspoint.eclipselink.entity.Department</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Classes de service

Créez un package sous ‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’. La classe DAO nomméeOneToOne.javaest créé sous le package donné. La classe DAO est représentée comme suit:

package com.tutorialspointeclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;

public class OneToOne 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Department Entity
		Department department = new Department();
		department.setName("Development");
		
		//Store Department
		entitymanager.persist(department);
		
		//Create Employee Entity
		Employee employee = new Employee();
		employee.setEname("Satish");
		employee.setSalary(45000.0);
		employee.setDeg("Technical Writer");
		employee.setDepartment(department);
		
		//Store Employee
		entitymanager.persist(employee);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Après la compilation et l'exécution du programme ci-dessus, vous recevrez des notifications dans le panneau de la console d'Eclipse IDE. Pour la sortie, vérifiez le workbench MySQL comme suit.

Dans l'exemple ci-dessus, deux tables sont créées. Passez la requête suivante dans l'interface MySQL et le résultat de la table department sera affiché comme suit:

Select * from department

ID	Nom
301	Développement

Passez la requête suivante dans l'interface MySQL et le résultat de employee Le tableau sera affiché comme suit:

Select * from employee

Eid	Degré	Ename	Un salaire	Department_id
302	Rédacteur technique	Satish	45 000	301

@ManyToMany Relation

La relation plusieurs-à-plusieurs est le cas où une ou plusieurs lignes d'une entité sont associées à plusieurs lignes d'une autre entité.

Prenons un exemple de relation entre deux entités: Class et Teacher. De manière bidirectionnelle, la classe et l'enseignant ont une relation plusieurs-à-un. Cela signifie que chaque enregistrement de classe est référencé par l'ensemble de l'enseignant (identifiants de l'enseignant), qui doit être des clés primaires dans la table Enseignant et stocké dans la table Teacher_Class et vice versa. Ici, la table Teachers_Class contient les deux champs de clé étrangère. Créer un projet JPA dans l'EDI eclipse nomméJPA_Eclipselink_MTM. Tous les modules de ce projet sont décrits ci-dessous.

Créer des entités

Créez des entités en suivant le schéma illustré dans le diagramme ci-dessus. Créez un package nommé‘com.tutorialspoin.eclipselink.entity’ en dessous de ‘src’paquet. Créez une classe nomméeClas.javasous le paquet donné. L'entité de classe Department est représentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Clas 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int cid;
	private String cname;
	
	@ManyToMany(targetEntity=Teacher.class)
	private Set teacherSet;
	
	public Clas() 
	{
		super();
	}
	public Clas(int cid, 
			String cname, Set teacherSet) 
	{
		super();
		this.cid = cid;
		this.cname = cname;
		this.teacherSet = teacherSet;
	}
	public int getCid() 
	{
		return cid;
	}
	public void setCid(int cid) 
	{
		this.cid = cid;
	}
	public String getCname() 
	{
		return cname;
	}
	public void setCname(String cname) 
	{
		this.cname = cname;
	}
	public Set getTeacherSet() 
	{
		return teacherSet;
	}
	public void setTeacherSet(Set teacherSet) 
	{
		this.teacherSet = teacherSet;
	}	  
}

Créez la deuxième entité dans cette relation -Employee entity class, nommée Teacher.java en dessous de ‘com.tutorialspoint.eclipselink.entity’paquet. La classe d'entité Employee est présentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Teacher 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int tid;
	private String tname;
	private String subject;
	
	@ManyToMany(targetEntity=Clas.class)
	private Set clasSet;
	
	public Teacher() 
	{
		super();
	}
	public Teacher(int tid, String tname, String subject, 
			Set clasSet) 
	{
		super();
		this.tid = tid;
		this.tname = tname;
		this.subject = subject;
		this.clasSet = clasSet;
	}
	public int getTid() 
	{
		return tid;
	}
	public void setTid(int tid) 
	{
		this.tid = tid;
	}
	public String getTname() 
	{
		return tname;
	}
	public void setTname(String tname) 
	{
		this.tname = tname;
	}
	public String getSubject() 
	{
		return subject;
	}
	public void setSubject(String subject) 
	{
		this.subject = subject;
	}
	public Set getClasSet() 
	{
		return clasSet;
	}
	public void setClasSet(Set clasSet) 
	{
		this.clasSet = clasSet;
	}
}

Persistence.xml

Fichier Persistence.xml comme suit:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
	<class>com.tutorialspoint.eclipselink.entity.Department</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Classes de service

Créez un package sous ‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’. La classe DAO nomméeManyToMany.javaest créé sous un package donné. La classe DAO est représentée comme suit:

package com.tutorialspoint.eclipselink.service;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Clas;
import com.tutorialspoint.eclipselink.entity.Teacher;

public class ManyToMany 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Clas Entity
		Clas clas1=new Clas(0,"1st",null);
		Clas clas2=new Clas(0,"2nd",null);
		Clas clas3=new Clas(0,"3rd",null);
		
		//Store Clas
		entitymanager.persist(clas1);
		entitymanager.persist(clas2);
		entitymanager.persist(clas3);
		
		//Create Clas Set1
		Set<Clas> classSet1 = new HashSet();
		classSet1.add(clas1);
		classSet1.add(clas2);
		classSet1.add(clas3);
		
		//Create Clas Set2
		Set<Clas> classSet2 = new HashSet();
		classSet2.add(clas3);
		classSet2.add(clas1);
		classSet2.add(clas2);
				
		//Create Clas Set3
		Set<Clas> classSet3 = new HashSet();
		classSet3.add(clas2);
		classSet3.add(clas3);
		classSet3.add(clas1);
		
		//Create Teacher Entity
		Teacher teacher1 = new Teacher(0,
				"Satish","Java",classSet1);
		Teacher teacher2 = new Teacher(0,
				"Krishna","Adv Java",classSet2);
		Teacher teacher3 = new Teacher(0,
				"Masthanvali","DB2",classSet3);
		
		//Store Teacher
		entitymanager.persist(teacher1);
		entitymanager.persist(teacher2);
		entitymanager.persist(teacher3);
		
		entitymanager.getTransaction( ).commit( );
		entitymanager.close( );
		emfactory.close( );
	}
}

Dans cet exemple de projet, trois tables sont créées. Passez la requête suivante dans l'interface MySQL et le résultat de la table teacher_clas s'affichera comme suit:

Select * form teacher_clas

Teacher_tid	Classet_cid
354	351
355	351
356	351
354	352
355	352
356	352
354	353
355	353
356	353

Dans le tableau ci-dessus teacher_tid est la clé étrangère de la table des enseignants, et classet_cidest la clé étrangère de la table de classe. Par conséquent, différents enseignants sont affectés à différentes classes.

Passez la requête suivante dans l'interface MySQL et le résultat de la table des enseignants s'affichera comme suit:

Select * from teacher

Tid	Matière	Tnom
354	Java	Satish
355	Adv Java	Krishna
356	DB2	Masthanvali

Passez la requête suivante dans l'interface MySQL et le résultat de clas Le tableau sera affiché comme suit:

Select * from clas

Cid	Cname
351	1er
352	2e
353	3e

Criteria est une API prédéfinie utilisée pour définir des requêtes pour les entités. C'est une manière alternative de définir une requête JPQL. Ces requêtes sont de type sécurisé, portables et faciles à modifier en modifiant la syntaxe. Similaire à JPQL, il suit un schéma abstrait (schéma facile à éditer) et des objets embarqués. L'API de métadonnées est mélangée à l'API de critères pour modéliser l'entité persistante pour les requêtes de critères.

Le principal avantage de l'API Criteria est que les erreurs peuvent être détectées plus tôt lors de la compilation. Les requêtes JPQL basées sur des chaînes et les requêtes basées sur des critères JPA sont identiques en termes de performances et d'efficacité.

Historique de l'API des critères

Les critères sont inclus dans toutes les versions de JPA. Par conséquent, chaque étape des critères est notifiée dans les spécifications de JPA.

• Dans JPA 2.0, l'API de requête de critères, la standardisation des requêtes est développée.
• Dans JPA 2.1, la mise à jour et la suppression des critères (mise à jour et suppression en bloc) sont incluses.

Structure de requête de critères

Les critères et le JPQL sont étroitement liés et sont autorisés à concevoir en utilisant des opérateurs similaires dans leurs requêtes. Ça suitjavax.persistence.criteriapackage pour concevoir une requête. La structure de la requête signifie la requête des critères de syntaxe.

La requête de critères simples suivante renvoie toutes les instances de la classe d'entité dans la source de données.

EntityManager em = ...;
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Entity class> cq = cb.createQuery(Entity.class);
Root<Entity> from = cq.from(Entity.class);
cq.select(Entity);
TypedQuery<Entity> q = em.createQuery(cq);
List<Entity> allitems = q.getResultList();

La requête montre les étapes de base pour créer un critère.

• EntityManager instance est utilisée pour créer un objet CriteriaBuilder.

• CriteriaQueryinstance est utilisée pour créer un objet de requête. Les attributs de cet objet de requête seront modifiés avec les détails de la requête.

• CriteriaQuery.form est appelée pour définir la racine de la requête.

• CriteriaQuery.select est appelé pour définir le type de liste de résultats.

• TypedQuery<T> instance est utilisée pour préparer une requête à exécuter et spécifier le type du résultat de la requête.

• getResultListsur l'objet TypedQuery <T> pour exécuter une requête. Cette requête renvoie une collection d'entités, le résultat est stocké dans une liste.

Exemple d'API de critères

Prenons l'exemple de la base de données des employés. Supposons que la table jpadb.employee contienne les enregistrements suivants:

Eid	 Ename          Salary	Deg
401	 Gopal	        40000	Technical Manager
402	 Manisha	    40000	Proof reader
403	 Masthanvali    35000	Technical Writer
404  Satish	        30000	Technical writer
405	 Krishna	    30000	Technical Writer
406	 Kiran	        35000	Proof reader

Créez un projet JPA dans l'EDI eclipse nommé JPA_Eclipselink_Criteria. Tous les modules de ce projet sont décrits ci-dessous:

Créer des entités

Créez un package nommé com.tutorialspoint.eclipselink.entity en dessous de ‘src’

Créez une classe nommée Employee.javasous le paquet donné. L'entité de classe Employee est représentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue(strategy= GenerationType.AUTO) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	public Employee(int eid, String ename, double salary, String deg) 
	{
		super( );
		this.eid = eid;
		this.ename = ename;
		this.salary = salary;
		this.deg = deg;
	}
	
	public Employee( ) 
	{
		super();
	}
	
	public int getEid( ) 
	{
		return eid;
	}
	public void setEid(int eid)  
	{
		this.eid = eid;
	}
	
	public String getEname( ) 
	{
		return ename;
	}
	public void setEname(String ename) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}
	@Override
	public String toString() {
		return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
				+ salary + ", deg=" + deg + "]";
	}
}

Persistence.xml

Le fichier Persistence.xml est le suivant:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
			          value="root"/>
			<property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Classes de service

Ce module contient les classes de service, qui implémentent la partie de requête Criteria à l'aide de l'initialisation de l'API MetaData. Créez un package nommé‘com.tutorialspoint.eclipselink.service’. La classe nomméeCriteriaAPI.javaest créé sous un package donné. La classe DAO est représentée comme suit:

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import com.tutorialspoint.eclipselink.entity.Employee;

public class CriteriaApi 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		CriteriaBuilder criteriaBuilder = entitymanager
				.getCriteriaBuilder();
		CriteriaQuery<Object> criteriaQuery = criteriaBuilder
				.createQuery();
		Root<Employee> from = criteriaQuery.from(Employee.class);
		
		//select all records
        System.out.println(“Select all records”);
		CriteriaQuery<Object> select =criteriaQuery.select(from);
		TypedQuery<Object> typedQuery = entitymanager
				.createQuery(select);
		List<Object> resultlist= typedQuery.getResultList();
		
		for(Object o:resultlist)
		{
			Employee e=(Employee)o;
			System.out.println("EID : "+e.getEid()
					+" Ename : "+e.getEname());
		}
		
		//Ordering the records 
        System.out.println(“Select all records by follow ordering”);
		CriteriaQuery<Object> select1 = criteriaQuery.select(from);
        select1.orderBy(criteriaBuilder.asc(from.get("ename")));
        TypedQuery<Object> typedQuery1 = entitymanager
        		.createQuery(select);
        List<Object> resultlist1= typedQuery1.getResultList();
		
		for(Object o:resultlist1)
		{
			Employee e=(Employee)o;
			System.out.println("EID : "+e.getEid()
					+" Ename : "+e.getEname());
		}
		
		entitymanager.close( );
		emfactory.close( );
	}
}

Après avoir compilé et exécuté le programme ci-dessus, vous obtiendrez la sortie suivante dans le panneau de la console d'Eclipse IDE.

Select All records
EID : 401 Ename : Gopal
EID : 402 Ename : Manisha
EID : 403 Ename : Masthanvali
EID : 404 Ename : Satish
EID : 405 Ename : Krishna
EID : 406 Ename : Kiran
Select All records by follow Ordering
EID : 401 Ename : Gopal
EID : 406 Ename : Kiran
EID : 405 Ename : Krishna
EID : 402 Ename : Manisha
EID : 403 Ename : Masthanvali
EID : 404 Ename : Satish