JPA Spring Boot

Qu'est-ce que JPA ?

JPA Spring Boot Java Specification pour la gestion des applications Javarelationles données. Il nous permet d'accéder et de persister les objets Java/les données entre les classes et les bases de données relationnelles. JPA suitMapping objet-relationnel(ORM). C'est un ensemble d'interfaces. Il fournit également des fonctionnalités en temps réel EntityManager API pour traiter les requêtes et les transactions sur les objets de base de données. Il utilise un langage de requête orienté objet et indépendant de la plate-forme JPQL (Java Persistence Query Language).

En matière de persistance, il couvre trois domaines:

Java Persistence API objet-relationnelméta-donnéesin persistence Les API définies dans le paquet

JPA n'est pas un cadre. Il définit des concepts qui peuvent être mis en œuvre dans n'importe quel cadre.

Pourquoi devrions-nous utiliser JPA?

Compared to JDBC, JPA is simpler, cleaner, and less labor-intensive, with SQL and hand-written mappings. JPA is suitable for complex applications that are not performance-oriented. Compared to JDBC, the main advantage of JPA is that in JPA, data is represented by objects and classes, while in JDBC, data is represented by tables and records. It uses POJO to represent persistent data, thus simplifying database programming. JPA also has other advantages:

JPA évite d'utiliser des dialectes spécifiques à la base de données SQL pour écrire des DDL. À la place, il permet de mapper en XML ou en utilisant des annotations Java. JPA nous permet d'éviter d'écrire des DML en utilisant des dialectes spécifiques à la base de données SQL. JPA nous permet de sauvegarder et de charger des objets Java et des graphiques sans utiliser aucun langage DML.Lorsque nous devons exécuter une requête JPQL, elle nous permet d'exprimer la requête en utilisant des entités Java plutôt que des tables et des colonnes (natifs) SQL.

Fonctionnalités JPA

JPA a les fonctionnalités suivantes:

C'est un dépôt puissant et personnalisél'abstraction de mappage objet. Il prend en chargePersistance transverse. Cela signifie qu'une entité peut être stockée partiellement dans MySQL et Neo4dans le j(gestionnaire de bases de données graphiques).Il génère dynamiquement des requêtes à partir des noms de méthodes de requête.Les classes de domaine fournissent des attributs de base.Il prend en charge l'audit transparent.Possibilité d'intégrer le code de stockage personnalisé.Il est facile de l'intégrer avec Spring Framework via des espaces de noms personnalisés.

Architecture JPA

JPA est une source pour stocker les entités métier en tant qu'entités relationnelles. Il montre comment définir un POJO comme une entité et comment gérer les entités par relation.

La figure suivante décrit l'architecture de niveau de classe de JPA, qui décrit les classes et les interfaces centrales de JPA. javax persistancePaquet. L'architecture JPA comprend les unités suivantes:

Persistence: C'est une classe qui contient des méthodes statiques pour obtenir des instances d'EntityManagerFactory. EntityManagerFactory: C'est une classe usine pour EntityManager. Elle crée et gère plusieurs instances d'EntityManager. EntityManager: C'est une interface. Elle contrôle les opérations de persistance sur les objets. Elle est applicable aux instances Query. @Entity marque: Les entités sont des objets persistants stockés en tant que enregistrements dans la base de données. Unité de persistance: Il définit un ensemble de toutes les classes d'entité. Dans l'application, l'instance EntityManager les gère. Un ensemble de classes d'entité représente les données contenant dans un seul entrepot de données. EntityTransaction: . Elle a une relation avec la classe EntityManagerun à unrelation. Pour chaque EntityManager, les opérations sont maintenues par la classe EntityTransaction. Requête: Cette interface est implémentée par chaque fournisseur JPA pour obtenir des objets de relation qui correspondent aux conditions.

relation de classe JPA

Les classes et les interfaces que nous avons discutées plus haut conservent une relation. La figure suivante montre la relation entre les classes et les interfaces.

La relation entre EntityManager et EntityTransaction estun à un. Chaque opération EntityManager a une instance de EntityTransaction. La relation entre EntityManageFactory et EntityManager estun à un. C'est la classe usine de l'instance EntityManager. La relation entre EntityManager et Query estun à un. Nous pouvons utiliser l'instance de la classe EntityManager pour exécuter un nombre illimité de requêtes. La relation entre EntityManager et Entity estun à un. L'instance EntityManager peut gérer plusieurs entités.

implémentation JPA

JPA est une API open source. Il existe divers fournisseurs d'entreprise, tels que Eclipse, RedHat, Oracle, etc., qui fournissent de nouveaux produits en ajoutant JPA. Il existe plusieurs cadres d'implémentation populaires de JPA, tels que Hibernate, EclipseLink, DataNucleus etc. Il est également appeléMapping objet-relationnel(Outils ORM).

Mapping objet-relationnel (ORM)

Dans l'ORM, la correspondance des objets Java aux tables de base de données (et vice versa) est appeléeMapping objet-relationnel (ORM). L'ORM mapping joue le rôle debase de données relationnelleet (tables et enregistrements) Application Javaun pont entre (classes et objets).

Dans l'image ci-dessous, la couche ORM est une couche d'adaptateur. Elle adapte le langage du diagramme d'objets au langage SQL et des tables relationnelles.

La couche ORM existe entre l'application et la base de données. Elle convertit les classes et les 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 de persistance deviendra le nom de la table, et les champs deviendront des colonnes. Une fois l'application établie, chaque ligne de table correspond à un objet.

la version JPA

Les premières versions d'EJB définissaient une couche persistante intégrée à la couche logique des affaires. Utilisant javax.ejb.EntityBean interface. La norme 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 définie comme JPA 1.0 (Java Persistence API). La norme de l'API a été publiée avec2006de5mois11le 220 du JAVA EE5publié avec la norme

2019en Jakarta Persistence . La dernière version de JPA est 2.2 . Il prend en charge les fonctionnalités suivantes:

Java 8et API de données et de temps CDI injection dans AttributeConvertesIl rend l'annotation @Repeatable

Les différences entre JPA et Hibernate

JPA: JPA est une norme Java pour accéder, gérer et persister les données entre les objets Java et les bases de données relationnelles. C'est la méthode standard ORM.

Hibernate: C'est un outil ORM open source léger utilisé pour stocker des objets Java dans des systèmes de bases de données relationnelles. C'est un fournisseur JPA. Il suit une méthode universelle fournie par JPA.

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

Données JPA du lanceur Spring Boot

Spring Boot fournit les dépendances启动程序 spring-boot-starter-data-jpa pour utiliser efficacement les bases de données relationnelles avec l'application Spring Boot. spring-boot-starter-data-JPA utilise internement Spring-boot-les dépendances JPA.

<dependency>　　
<groupId>org.springframework.boot</groupId>　　
<artifactId>spring-boot-starter-data-jpa</artifactId>　　
<version>2.2.2.RELEASE</version>　　
</dependency>

Exemple Spring Boot JPA

Nous créons une application Spring Boot qui se connecte à la base de données en utilisant JPA. Dans l'exemple suivant, nous utilisons une base de données en mémoire Apache Derby。

Apache Derby : C'est un embeddedLogiciel open sourceBase de données relationnelle entièrement implémentée en Java. Il est sous licence Apache License 2Disponible sous .0. Voici les avantages d'Apache Derby:

Facile à installer, déployer et utiliser.Il est basé sur Java, JDBC et les normes SQL.Il fournit un pilote JDBC embarqué qui nous permet d'embedder Derby dans toute solution basée sur Java.Il prend également en charge les clients via le pilote JDBC du client réseau Derby et le serveur réseau Derby./mode serveur.

Spring Boot peut configurer automatiquement la base de données embarquée, par exemple H2，HSQL,et Bases de données Derby . Nous n'avons pas besoin de fournir d'URL de connexion. Nous devons simplement inclure la dépendance de construction de la base de données embarquée à utiliser.

Dans Spring Boot, il suffit d'ajouter dans pom Derby Dépendances pour intégrer facilement la base de données Apache Derby. fichier xml.

<dependency>
<groupId>org.apache.derby</groupId>
<artifactId>derby</artifactId>
<scope>runtime</scope>
</dependency>

Étapes1: Ouvrir Spring Initializr https://start.spring.io/.

Étapes2: Choisir la dernière version de Spring Boot 2.3.0(SNAPSHOT)

Étapes3: FournirGroupNom. Nous avons fourni com.w3codebox.

Étapes4: FournirArtifact ID. Nous avons fourni apache-derby-example .

Étapes5: Ajouter des dépendances: Spring Web, Spring Data JPAet Base de données Apache Derby.

Étapes6: Cliquez sur Generate (Généré) bouton. Lorsque nous cliquons sur le bouton "Générer", il emballera le projet dans un fichier Jar et le téléchargera sur le système local.

Étapes7: Extraire Fichier Jar et le coller dans l'espace de travail STS.

Étapes8: Importer

Fichier->Importer->Projet Maven existant->Parcourir->Choisir le dossier apache-derby-example->Terminé

Il faut un certain temps pour l'importation.

Étapes9: dans le dossier src/main/javadans la création de nom com.w3codebox.model du paquet.

Étapes10: dans le paquet com.w3codebox.model dans la création de nom UserRecord de la classe, puis exécuter ce qui suit:

Définir trois variables id, name, and email.Générer Getter et Setter.
Cliquez avec le bouton droit sur le fichier-> Source-> Générer Getter et Setter Définir le constructeur par défaut.Using annotations La classe comme@Entity marque. Using annotations @Id marque Id Marquer comme clé primaire.

UserRecord.java

package com.w3codebox.model;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity　　
public class UserRecord　
{　
@Id　　
private int id;　　
private String name;　　
private String email;
//default constructor　　
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;　　
}　　
}

Étapes11: in src/main/Create a folder named com.w3codebox.controller du paquet.

Étapes12: dans le paquet com.w3codebox.controller dans la création de nom UserController Controller class, and perform the following operations:

Using annotations @RestController Mark the class as a controller.Using annotations @Autowired Automatically connect class UserService .Nous avons défini deux mappings, un mapping pourRécupérer tous les utilisateurs，另一个映射用于Ajouter un utilisateur.

UserController.java

package com.w3codebox.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.w3codebox.model.UserRecord;
import com.w3codebox.service.UserService;
import java.util.List;　　
@RestController　　
public class UserController　
{　　
@Autowired　　
private UserService userService;　　　
@RequestMapping("/")　　
public List<UserRecord> getAllUser()
{　　
return userService.getAllUsers();　　
}　　　　　
@RequestMapping(value="/add-user", method=RequestMethod.POST)　　
public void addUser(@RequestBody UserRecord userRecord)
{　　
userService.addUser(userRecord);　　
}　　　　　
}

Étapes13: dans le dossier src/main/Créer un nom dans Java com.w3codebox.service du paquet.

Étapes14: dans le paquet com.w3codebox.service dans la création de nom UserController de la classe Service, et exécuter les opérations suivantes:

En utilisant l'annotation @ServiceMarquer cette classe comme service. Connexion automatique UserRepository Définir une méthode getAllUsers()Cette méthode retourne la liste suivante: Définir un autre nom de méthode addUser()pour enregistrer les enregistrements d'utilisateur.

UserService.java

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

Étapes15: dans le dossier src/main/javadans la création de nom com.w3codebox.repository du paquet.

Étapes16: dans le paquet com.w3codebox.repository dans la création de nom UserRepository l'interface de stockage, et étend CrudRepository .

UserRepository.java

package com.w3codebox.repository;　　
import org.springframework.data.repository.CrudRepository;
import com.w3codebox.model.UserRecord;　　
public interface UserRepository extends CrudRepository<UserRecord, String>　
{　　
}

Étapes17: Maintenant, ouvrez ApacheDerbyExampleApplication.java Le fichier. Il a été créé par défaut lors de la configuration de l'application.

ApacheDerbyExampleApplication.java

package com.w3codebox;
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 configuré toutes les classes et les packages nécessaires selon les exigences. Veuillez noter que nous n'avons pas fourni de base de données.URL de connexion . Après avoir terminé toutes les étapes ci-dessus, le répertoire du projet est le suivant:

Lançons l'application.

Étapes18: Ouvrez ApacheDerbyExampleApplication.java Fichier et exécutez-le en tant qu'application Java.

Le19Étape: Ouvrez un navigateur et appellez l'URL http://localhost:8080/。 Comme aucun utilisateur n'a été ajouté à la liste, une liste vide est retournée.

Pour ajouter un utilisateur à la base de données, nous utiliseronsEnvoyer POST Requête Postman.

Étapes20: OuvrezPostman， puis exécutez les opérations suivantes:

Sélectionnez POST Appel de l'URL http://localhost:8080/add-user。CliquezBody Sélectionnez le contenu-Type en tant queJSON (application/json).Insérez les données à insérer dans la base de données. Nous avons inséré les données suivantes:

{
"id": "00"1",
"name": "Tom",
"email": "[email protected]"
}

CliquezEnvoyerbouton.

Lorsque nous cliquons sur le bouton "Envoyer", il afficheStatut: 200 OK . Cela signifie que la requête a été exécutée avec succès.

Étapes21: Ouvrez un navigateur et appellez l'URL http: //localhost: 8080. Il retourne les utilisateurs que nous avons insérés dans la base de données.