Qu’est-ce que JPA ?

JPA de démarrage de printemps est une spécification Java pour la gestion relationnel données dans les applications Java. Il nous permet d'accéder et de conserver les données entre l'objet/classe Java et la base de données relationnelle. JPA suit Mappage objet-relation (ORM). C'est un ensemble d'interfaces. Il fournit également un runtime Gestionnaire d'entités API pour traiter les requêtes et les transactions sur les objets par rapport à la base de données. Il utilise un langage de requête orienté objet indépendant de la plate-forme, JPQL (Java Persistent Query Language).

Dans le cadre de la persévérance, elle couvre trois domaines :

• L'API de persistance Java
Objet-Relationnelmétadonnées
• L'API elle-même, définie dans le persistance emballer

JPA n'est pas un framework. Il définit un concept qui peut être implémenté par n'importe quel framework.

Pourquoi devrions-nous utiliser JPA ?

JPA est plus simple, plus propre et demande moins de travail que JDBC, SQL et le mappage écrit à la main. JPA convient aux applications complexes non orientées performances. Le principal avantage de JPA par rapport à JDBC est que, dans JPA, les données sont représentées par des objets et des classes, tandis que dans JDBC, les données sont représentées par des tables et des enregistrements. Il utilise POJO pour représenter des données persistantes qui simplifient la programmation de bases de données. Il y a quelques autres avantages de JPA :

• JPA évite d'écrire du DDL dans un dialecte SQL spécifique à la base de données. Au lieu de cela, il permet le mappage en XML ou l'utilisation d'annotations Java.
• JPA nous permet d'éviter d'écrire du DML dans le dialecte SQL spécifique à la base de données.
• JPA nous permet de sauvegarder et de charger des objets et des graphiques Java sans aucun langage DML.
• Lorsque nous devons effectuer des requêtes JPQL, cela nous permet d'exprimer les requêtes en termes d'entités Java plutôt que de table et de colonnes SQL (natives).

Fonctionnalités JPA

Il existe les fonctionnalités suivantes de JPA :

• C'est un référentiel puissant et personnalisé abstraction du mappage d'objets.
• Il prend en charge pour persistance entre magasins . Cela signifie qu'une entité peut être partiellement stockée dans MySQL et Neo4j (Graph Database Management System).
• Il génère dynamiquement des requêtes à partir du nom des méthodes de requêtes.
• Les classes de base de domaine fournissent des propriétés de base.
• Il prend en charge un audit transparent.
• Possibilité d'intégrer du code de référentiel personnalisé.
• Il est facile à intégrer à Spring Framework avec l'espace de noms personnalisé.

Architecture JPA

JPA est une source permettant de stocker des entités commerciales en tant qu'entités relationnelles. Il montre comment définir un POJO en tant qu'entité et comment gérer les entités avec relation.

La figure suivante décrit l'architecture au niveau des classes de JPA qui décrit les classes principales et les interfaces de JPA définies dans le persistance javax emballer. L'architecture JPA contient les unités suivantes :

Persistance:C'est une classe qui contient des méthodes statiques pour obtenir une instance EntityManagerFactory.EntityManagerFactory :Il s'agit d'une classe d'usine d'EntityManager. Il crée et gère plusieurs instances d'EntityManager.Gestionnaire d'entité :C'est une interface. Il contrôle les opérations de persistance sur les objets. Cela fonctionne pour l'instance Query.Entité:Les entités sont les objets de persistance stockés sous forme d'enregistrement dans la base de données.Unité de persistance :Il définit un ensemble de toutes les classes d'entités. Dans une application, les instances EntityManager la gèrent. L'ensemble des classes d'entités représente les données contenues dans un seul magasin de données.EntitéTransaction :Il a un Un par un relation avec la classe EntityManager. Pour chaque EntityManager, les opérations sont gérées par la classe EntityTransaction.Requête:Il s'agit d'une interface implémentée par chaque fournisseur JPA pour obtenir des objets de relation répondant aux critères.

Relations de classe JPA

Les classes et interfaces dont nous avons parlé ci-dessus entretiennent une relation. La figure suivante montre la relation entre les classes et les interfaces.

• La relation entre EntityManager et EntiyTransaction est Un par un . Il existe une instance EntityTransaction pour chaque opération EntityManager.
• La relation entre EntityManageFactory et EntiyManager est un à plusieurs . Il s'agit d'une classe d'usine pour l'instance EntityManager.
• La relation entre EntityManager et Query est un à plusieurs . Nous pouvons exécuter n'importe quel nombre de requêtes en utilisant une instance de la classe EntityManager.
• La relation entre EntityManager et Entity est un à plusieurs . Une instance EntityManager peut gérer plusieurs entités.

Implémentations JPA

JPA est une API open source. Il existe divers fournisseurs d'entreprises tels que Eclipse, RedHat, Oracle, etc. qui proposent de nouveaux produits en y ajoutant le JPA. Il existe des cadres d'implémentation JPA populaires tels que Mise en veille prolongée, EclipseLink, DataNucleus, etc. Il est également connu sous le nom de Mappage objet-relation (ORM).

Mappage objet-relation (ORM)

Dans ORM, le mappage des objets Java aux tables de base de données, et vice-versa, est appelé Mappage objet-relationnel. Le mappage ORM fonctionne comme un pont entre un base de données relationnelle (tableaux et enregistrements) et Application Java (classes et objets).

Dans la figure suivante, la couche ORM est une couche adaptateur. Il adapte le langage des graphes d'objets au langage SQL et aux tables de relations.

La couche ORM existe entre l'application et la base de données. Il convertit les classes et objets Java afin qu'ils puissent être stockés et gérés dans une base de données relationnelle. Par défaut, le nom persistant devient le nom de la table et les champs deviennent des colonnes. Une fois l'application configurée, chaque ligne du tableau correspond à un objet.

Versions JPA

Les versions antérieures d'EJB définissent la couche de persistance combinée à la couche de logique métier en utilisant javax.ejb.EntityBean Interface. La spécification EJB inclut la définition de JPA.

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 (Java Persistence API). 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.

En 2019, JPA a été renommé Persistance de Jakarta . La dernière version de JPA est 2.2 . Il prend en charge les fonctionnalités suivantes :

• Java 8, API de données et de temps
• Injection CDI dans AttributeConvertes
• Il fait des annotations @Repeatable

Différence entre JPA et Hibernate

JPA : JPA est une spécification Java utilisée pour accéder, gérer et conserver les données entre un objet Java et une base de données relationnelle. Il s'agit d'une approche standard pour ORM.

Hiberner: Il s'agit d'un outil ORM léger et open source utilisé pour stocker des objets Java dans le système de base de données relationnelle. C'est un fournisseur de JPA. Il suit une approche commune fournie par JPA.

Le tableau suivant décrit les différences entre JPA et Hibernate.

Données de démarrage Spring Boot JPA

Spring Boot fournit une dépendance de démarrage spring-boot-starter-data-jpa pour connecter efficacement l'application Spring Boot à la base de données relationnelle. Le spring-boot-starter-data-jpa utilise en interne la dépendance spring-boot-jpa.

 org.springframework.boot spring-boot-starter-data-jpa 2.2.2.RELEASE 

Exemple JPA de démarrage printanier

Créons une application Spring Boot qui utilise JPA pour se connecter à la base de données. Dans l'exemple suivant, nous avons utilisé une base de données en mémoire Apache Derby.

Derby Apache : C'est un open source, embarqué base de données relationnelle implémentée entièrement en Java. Il est disponible sous la licence Apache 2.0. Apache Derby présente les avantages suivants :

tri de liste de tableaux Java

• Il est facile à installer, à déployer et à utiliser.
• Il est basé sur les standards Java, JDBC et SQL.
• Il fournit un pilote JDBC intégré qui nous permet d'intégrer Derby dans n'importe quelle solution basée sur Java.
• Il prend également en charge le mode client/serveur avec le pilote JDBC Derby Network Client et Derby Network Server.

Spring Boot peut configurer automatiquement une base de données intégrée telle que H2, HSQL, et Bases de données Derby . Nous n'avons pas besoin de fournir d'URL de connexion. Il nous suffit d'inclure une dépendance de build sur la base de données intégrée que nous souhaitons utiliser.

Dans Spring Boot, nous pouvons facilement intégrer la base de données Apache Derby simplement en ajoutant Derby dépendance dans le fichier pom.xml.

 org.apache.derby derby runtime 

Étape 1: Initialisation du printemps ouvert https://start.spring.io/ .

Étape 2: Sélectionnez la dernière version de Spring Boot 2.3.0 (INSTANTANÉ)

Étape 3: Fournir le Groupe nom. Nous avons fourni com.javatpoint.

Étape 4: Fournir le Artefact Identifiant. Nous avons fourni exemple-apache-derby .

Étape 5 : Ajoutez les dépendances : Spring Web, Spring DataJPA, et Base de données Apache Derby .

Étape 6 : Clique sur le Générer bouton. Lorsque nous cliquons sur le bouton Générer, le projet est enveloppé dans un fichier Jar et téléchargé sur le système local.

Étape 7 : Extraire le fichier Jar et collez-le dans l'espace de travail STS.

remplacer tout dans la chaîne java

Étape 8 : Importer le dossier du projet dans STS.

Fichier -> Importer -> Projets Maven existants -> Parcourir -> Sélectionnez le dossier apache-derby-example -> Terminer

L'importation prend un certain temps.

Étape 9 : Créez un package avec le nom com.javatpoint.model dans le dossier src/main/java.

Étape 10 : Créez une classe avec le nom Enregistrement utilisateur dans le paquet com.javatpoint.model et procédez comme suit :

• Définir trois variables pièce d'identité, nom, et e-mail .
• Générez des Getters et des Setter.
  Faites un clic droit sur le fichier -> Source -> Générer des getters et des setters
• Définissez un constructeur par défaut.
• Marquez la classe comme Entité en utilisant l'annotation @Entité.
• Marque Identifiant comme clé primaire en utilisant l'annotation @Identifiant.

UserRecord.java

 package com.javatpoint.model; import javax.persistence.Entity; import javax.persistence.Id; @Entity public class UserRecord { @Id private int id; private String name; private String email; //default conatructor public UserRecord() { } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } } 

Étape 11 : Créez un package avec le nom com.javatpoint.controller dans le dossier src/main/java.

Étape 12 : Créez une classe Controller avec le nom Contrôleur utilisateur dans le paquet com.javatpoint.controller et procédez comme suit :

• Marquez la classe comme contrôleur en utilisant l'annotation @RestController.
• Câblage automatique de la classe Service utilisateur en utilisant l'annotation @Autowired .
• Nous avons défini deux mappages, un pour obtenir tous les utilisateurs et l'autre pour ajouter un utilisateur.

UserController.java

 package com.javatpoint.controller; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import com.javatpoint.model.UserRecord; import com.javatpoint.service.UserService; import java.util.List; @RestController public class UserController { @Autowired private UserService userService; @RequestMapping('/') public List getAllUser() { return userService.getAllUsers(); } @RequestMapping(value='/add-user', method=RequestMethod.POST) public void addUser(@RequestBody UserRecord userRecord) { userService.addUser(userRecord); } } 

Étape 13 : Créez un package avec le nom com.javatpoint.service dans le dossier src/main/java.

Étape 14 : Créez une classe de service avec le nom Service utilisateur dans le paquet com.javatpoint.service et procédez comme suit :

• Marquez la classe comme service en utilisant l'annotation @Service.
• Câblage automatique du Référentiel utilisateur
• Définir une méthode getAllUsers() qui renvoie une liste de
• Définir un autre nom de méthode ajouterUtilisateur() qui enregistre l'enregistrement de l'utilisateur.

UserService.java

 package com.javatpoint.service; import java.util.List; import java.util.ArrayList; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import com.javatpoint.model.UserRecord; import com.javatpoint.repository.UserRepository; @Service public class UserService { @Autowired private UserRepository userRepository; public List getAllUsers() { ListuserRecords = new ArrayList(); userRepository.findAll().forEach(userRecords::add); return userRecords; } public void addUser(UserRecord userRecord) { userRepository.save(userRecord); } } 

Étape 15 : Créez un package avec le nom com.javatpoint.repository dans le dossier src/main/java.

Étape 16 : Créez une interface de référentiel avec le nom Référentiel utilisateur dans le paquet com.javatpoint.repository et s'étend CrudRepository .

UserRepository.java

 package com.javatpoint.repository; import org.springframework.data.repository.CrudRepository; import com.javatpoint.model.UserRecord; public interface UserRepository extends CrudRepository { } 

Étape 17 : Maintenant, ouvrez le ApacheDerbyExampleApplication.java déposer. Il est créé par défaut lorsque nous configurons une application.

ApacheDerbyExampleApplication.java

 package com.javatpoint; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class ApacheDerbyExampleApplication { public static void main(String[] args) { SpringApplication.run(ApacheDerbyExampleApplication.class, args); } } 

Maintenant, nous avons mis en place toutes les classes et packages nécessaires en fonction des exigences. Notez que nous n'avons fourni aucun URL de connexion pour la base de données. Après avoir terminé toutes les étapes ci-dessus, le répertoire du projet ressemble à ceci :

Lançons l'application.

Étape 18 : Ouvrez le ApacheDerbyExampleApplication.java fichier et exécutez-le en tant qu’application Java.

Étape 19 : Ouvrez le navigateur et appelez l'URL http://localhost:8080/. Il renvoie une liste vide car nous n'avons ajouté aucun utilisateur dans la liste.

Pour ajouter un utilisateur à la base de données, nous enverrons un POSTE demande en utilisant le Facteur .

Étape 20 : Ouvrez le Facteur et procédez comme suit :

• Sélectionnez le POSTE
• Appelez l'URL http://localhost:8080/add-user.
• Clique sur le Corps
• Sélectionnez le type de contenu comme JSON (application/json).
• Insérez les données que vous souhaitez insérer dans la base de données. Nous avons inséré les données suivantes :

 { 'id': '001', 'name': 'Tom', 'email': '[email protected]' } 

• Clique sur le Envoyer bouton.

Lorsque nous cliquons sur le bouton Envoyer, cela affiche Statut : 200 OK . Cela signifie que la demande a été exécutée avec succès.

Étape 21 : Ouvrez le navigateur et appelez l'URL http://localhost:8080. Il renvoie l'utilisateur que nous avons inséré dans la base de données.