SPRING DATA JPA – PREMIÈRE ENTITÉ

Cours Spring Data JPA

Ce cours sur Spring Data JPA couvre les concepts essentiels de la persistance des données en Java, y compris les entités, les annotations, et la configuration de Spring Boot. Vous apprendrez à utiliser le framework JPA pour gérer la persistance des objets métiers, ainsi que des exemples pratiques d'implémentation.

Pertinence de la persistance des données

La persistance des données est cruciale dans le développement d'applications, car elle permet de stocker les objets modélisés en mémoire dans des systèmes de gestion de bases de données relationnels (SGBDR). Le modèle relationnel est devenu un pilier incontournable, tandis que le modèle objet, basé sur la programmation orientée objet, offre une flexibilité et une qualité accrues.

Pour persister les données, deux approches sont possibles :

• Développer manuellement le code de projection des objets sur le support relationnel, en utilisant JDBC natif.
• Utiliser un framework de projection objet-relationnel tel qu'EclipseLink, Hibernate ou Spring Data JPA, qui implémente la spécification JavaEE JPA.

Introduction à JDBC

JDBC (Java DataBase Connectivity) est une API qui permet aux applications Java d'accéder à des bases de données. Bien que JDBC soit une solution pour manipuler les données dans une base SQL, elle présente des inconvénients, notamment l'absence de séparation entre le code technique et le code métier, rendant la couche d'accès aux données difficilement maintenable.

public void addClient(Client client) {
    Connection conn = null; 
    PreparedStatement preparedStmt = null;
    try {
        conn = DriverManager.getConnection(DB_URL, USER, PASSWORD);
        String insertSQL = "INSERT INTO CLIENT (idClient, nom, prenom, email, password, dateNaissance, profession, categorieClient) VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
        preparedStmt = conn.prepareStatement(insertSQL);
        preparedStmt.setInt(1, client.getIdClient());
        preparedStmt.setString(2, client.getNom());
        preparedStmt.setString(3, client.getPrenom());
        preparedStmt.setString(4, client.getEmail());
        preparedStmt.setString(5, client.getPassword());
        preparedStmt.setString(6, client.getDateNaissance());
        preparedStmt.setString(7, client.getProfession());
        preparedStmt.setString(8, client.getCategorieClient());
        preparedStmt.execute();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        try {
            preparedStmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Concept d'ORM

Pour surmonter les limitations de JDBC, le concept d'ORM (Object-Relational Mapping) a été introduit. L'ORM permet d'associer des classes Java à des tables de base de données, réduisant ainsi la quantité de code nécessaire pour effectuer des opérations CRUD (Créer, Lire, Mettre à jour, Supprimer).

Java Persistence API (JPA)

La Java Persistence API (JPA) est une spécification qui normalise l'utilisation des ORM. JPA nécessite un fournisseur de persistance, tel qu'Hibernate, qui implémente ses spécifications. Dans ce cours, nous utiliserons Spring Data JPA, qui repose sur Hibernate.

Entité JPA

Une entité JPA est une classe dont les instances peuvent être persistées. Elle doit être annotée avec @Entity et doit avoir au moins une propriété identifiée par l'annotation @Id. De plus, elle doit implémenter l'interface java.io.Serializable.

package tn.esprit.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
import java.util.Date;

@Entity
@Table(name = "Client")
public class Client implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="idClient")
    private Long idClient; // Clé primaire
    private String nom;
    private String prenom;
    private String email;
    private String password;
    @Temporal(TemporalType.DATE)
    private Date dateNaissance;
    // Autres attributs et méthodes
}

Annotations JPA

Les annotations JPA sont essentielles pour définir le comportement des entités. Voici quelques-unes des plus importantes :

• @Entity : Indique que la classe est une entité persistante.
• @Table : Permet de spécifier le nom de la table associée.
• @Id : Indique la clé primaire de l'entité.
• @GeneratedValue : Spécifie la stratégie de génération de la clé primaire.
• @Column : Permet de définir des propriétés spécifiques pour les colonnes.

Stratégies d'héritage JPA

JPA propose trois stratégies pour gérer l'héritage :

• Table unique : Tous les attributs de la hiérarchie sont regroupés dans une seule table.
• Table par classe concrète : Chaque classe concrète a sa propre table.
• Jointure entre sous-classes : Chaque classe a sa propre table, nécessitant des jointures pour instancier les classes filles.

Configuration de Spring Boot

Pour configurer Spring Boot avec JPA, il est nécessaire de mettre à jour le fichier application.properties avec les informations de connexion à la base de données et les paramètres JPA. Voici un exemple de configuration :

spring.datasource.url=jdbc:mysql://localhost:3306/springDB?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

Points clés à retenir

• La persistance des données est essentielle pour les applications modernes.
• JPA normalise l'utilisation des ORM et facilite la gestion des entités.
• Les annotations JPA définissent le comportement des entités et leur relation avec la base de données.
• Spring Boot simplifie la configuration et l'utilisation de JPA.

Glossaire des termes clés

• Pertinence : Importance de la persistance des données.
• ORM : Mapping Objet-Relationnel.
• JPA : Java Persistence API.
• Entité : Classe persistante.
• Annotations : Métadonnées pour configurer les entités.

Questions fréquentes

Qu'est-ce que Spring Data JPA ?

Spring Data JPA est un sous-projet de Spring Data qui facilite l'accès aux données en utilisant la Java Persistence API (JPA) pour gérer la persistance des objets métiers.

Comment configurer une entité JPA ?

Pour configurer une entité JPA, vous devez annoter la classe avec @Entity, définir une clé primaire avec @Id, et éventuellement spécifier des propriétés de colonne avec @Column.

Quelles sont les stratégies d'héritage en JPA ?

JPA propose trois stratégies d'héritage : une table unique pour toute la hiérarchie, une table par classe concrète, et des jointures entre sous-classes.

Quels sont les avantages d'utiliser JPA ?

JPA simplifie le développement en normalisant l'accès aux données, en réduisant le code nécessaire pour les opérations CRUD, et en facilitant la gestion des entités.

Comment configurer Spring Boot pour JPA ?

Pour configurer Spring Boot pour JPA, vous devez mettre à jour le fichier application.properties avec les détails de la connexion à la base de données et les paramètres JPA appropriés.