JPA - Composants ORM

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. La partie centrale de ces technologies relationnelles d'objets est le mappage du fichier 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 tenir compte des données, du type de données et de leurs relations avec son auto-entité ou entité dans 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 éminent. Utilisé par de nombreux programmeurs industriels.

Architecture ORM

Voici l'architecture ORM.

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 dataphase 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. Et des méthodes comme les méthodes 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 comme mapping ou persistence phase qui contient le fournisseur JPA, le fichier de mappage (ORM.xml), le chargeur JPA et la grille d'objets.

JPA Provider: 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 la mémoire cache, qui 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: La grille d'objets est un emplacement temporaire qui permet de stocker la copie de données relationnelles, c'est-à-dire 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 sa validation qu'il affecte la base de données principale.

Phase 3

La troisième phase est la phase des données relationnelles. 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. Il en va de même pour le processus d'obtention des données.

Le mécanisme de l'interaction programmatique des trois phases ci-dessus est appelé mappage relationnel d'objet.

Mapping.xml

Le fichier mapping.xml doit indiquer au fournisseur JPA de mapper les classes Entity avec les tables de 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 attributs eid, ename, salaire et deg. Considérez que ces attributs sont les champs de table dans la base de données et eid est la clé primaire de cette table. Maintenant, nous devons concevoir un 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 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> : la balise définit la 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 conserver le nom de la classe comme nom de 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> La balise définit comment attribuer la valeur de la clé primaire telle que Automatique, Manuel ou extraite de la séquence.
<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 le nom du champ de table défini par l'utilisateur.

Annotations

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

Voici la solution: dans la définition de classe, nous pouvons écrire la partie 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 que la classe, la propriété ou la méthode ne soit déclarée. Toutes les annotations de JPA sont définies dans le package javax.persistence.

Voici la liste des annotations utilisées dans nos exemples

Annotation	La description
@Entité	Cette annotation spécifie de déclarer la classe en tant qu'entité ou table.
@Table	Cette annotation spécifie de déclarer le nom de la table.
@De base	Cette annotation spécifie explicitement les champs sans contrainte.
@Embedded	Cette annotation spécifie les propriétés de la classe ou d'une entité dont la valeur instance d'une classe intégrable.
@Id	Cette annotation spécifie la propriété, à utiliser pour l'identité (clé primaire d'une table) de la classe.
@GeneratedValue	Cette annotation spécifie comment l'attribut d'identité peut être initialisé, par exemple Automatique, Manuel ou valeur extraite de la table de séquence.
@Transitoire	Cette annotation 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	Cette annotation est utilisée pour spécifier la colonne ou l'attribut de la propriété de persistance.
@SequenceGenerator	Cette annotation est utilisée pour définir la valeur de la propriété qui est spécifiée dans l'annotation @GeneratedValue. Cela crée une séquence.
@TableGenerator	Cette annotation est utilisée pour spécifier 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 par champ se produira. Si vous définissez @AccessType (PROPERTY), une évaluation de propriété sera effectuée.
@JoinColonne	Cette annotation est utilisée pour spécifier une association d'entités ou une collection d'entités. Ceci est utilisé dans les associations plusieurs-à-un et un-à-plusieurs.
@Contrainte unique	Cette annotation est utilisée pour spécifier le champ, contrainte unique pour la table primaire ou secondaire.
@ColumnResult	Cette annotation fait référence au nom d'une colonne dans la requête SQL à l'aide de la clause select.
@Plusieurs à plusieurs	Cette annotation est utilisée pour définir une relation plusieurs-à-plusieurs entre les tables de jointure.
@ManyToOne	Cette annotation est utilisée pour définir une relation plusieurs-à-un entre les tables de jointure.
@OneToMany	Cette annotation est utilisée pour définir une relation un-à-plusieurs entre les tables de jointure.
@Un par un	Cette annotation est utilisée pour définir une relation univoque entre les tables de jointure.
@NamedQueries	Cette annotation est utilisée pour spécifier la liste des requêtes nommées.
@NamedQuery	Cette annotation est utilisée pour spécifier une requête à l'aide d'un nom statique.

Java Bean Standard

Classe Java, encapsule les valeurs d'instance et les comportements dans un objet appelé unité unique. Java Bean est un stockage temporaire et un composant ou un objet réutilisable. C'est une classe sérialisable qui a des méthodes de constructeur et de lecture et de définition par défaut pour initialiser les attributs d'instance individuellement.

Conventions Bean

Bean contient le constructeur par défaut ou un fichier qui contient une instance sérialisée. Par conséquent, un bean peut instancier le bean.
Les propriétés d'un bean peuvent être séparées en propriétés booléennes et en propriétés 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.
GetterLa méthode de toute propriété doit commencer par «get» en minuscule (convention de la méthode java) et se poursuivre avec un nom de champ commençant par une majuscule. Par exemple, le nom du champ est «salaire» donc la méthode de lecture de ce champ est «getSalary ()».
SetterLa méthode de toute propriété doit commencer par «set» en minuscule (convention de la méthode java), suivie d'un nom de champ commençant par une majuscule et de la valeur de l'argument à définir sur field. Par exemple, le nom du champ est «salaire», donc la méthode de définition de ce champ est «setSalary (double sal)».
Pour la propriété booléenne, est une méthode pour vérifier si elle est vraie ou fausse. Par exemple, la propriété booléenne «vide», la méthode est de ce champ est «isEmpty ()».