Qu'est-ce que JPA (Java Persistence API) ?

JPA est une spécification d’API pour la gestion de la persistance des données dans les applications Java. Elle fournit une méthode standard pour mapper des objets Java vers des bases de données relationnelles (ou autres stockages de données) et vice versa. JPA fait partie de la plateforme Java EE (maintenant Jakarta EE) et peut également être utilisée dans des applications autonomes.

Composants clés de JPA :

• Entité : Classes Java normales (POJO), marquées avec l’annotation @Entity, représentant des données dans la base.
• EntityManager : Interface pour interagir avec le contexte de persistance. Utilisée pour rechercher, créer, mettre à jour et supprimer des entités.
• Contexte de persistance : Ensemble d’entités gérées par EntityManager. Il suit les changements des entités avant leur synchronisation avec la base.
• JPQL (Java Persistence Query Language) : Langage de requête orienté objet, similaire à SQL, mais opérant avec des entités et leurs relations plutôt qu’avec des tables et colonnes.
• Criteria API : API orientée objet pour exécuter des requêtes dynamiques.
• persistence.xml : Fichier de configuration décrivant les unités de persistance et leurs propriétés (par exemple, informations de connexion à la base, stratégies de mappage).

JPA n’est pas une implémentation concrète de ORM (Object-Relational Mapping), mais définit des contrats et une API. Il existe plusieurs fournisseurs de JPA qui implémentent cette spécification, parmi les plus populaires :

• Hibernate
• EclipseLink
• Apache OpenJPA

Exemple de définition d’entité :

// Entité représentant une ligne dans la table `products`
@Entity
// Nom de la table dans la base
@Table(name = "products")
public class Product {

    // Clé primaire
    @Id
    // Stratégie de génération de la clé primaire
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // Colonne `name` dans la table
    private String name;

    // Colonne `price` dans la table
    private BigDecimal price;

    // Constructeurs, getters et setters
    // ...
}

Exemple d’utilisation de EntityManager :

// Obtention d’un EntityManager à partir de EntityManagerFactory
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPersistenceUnit");
EntityManager em = emf.createEntityManager();

try {
    // Début de la transaction
    em.getTransaction().begin();

    // Création d’une nouvelle entité
    Product newProduct = new Product();
    newProduct.setName("Laptop");
    newProduct.setPrice(new BigDecimal("1200.00"));

    // Sauvegarde de l’entité dans la base
    em.persist(newProduct);

    // Recherche d’une entité par clé primaire
    Product foundProduct = em.find(Product.class, 1L);
    System.out.println("Produit trouvé : " + foundProduct.getName());

    // Exécution d’une requête JPQL
    List<Product> allProducts = em.createQuery("SELECT p FROM Product p", Product.class).getResultList();
    for (Product p : allProducts) {
        System.out.println(p.getName());
    }

    // Validation de la transaction
    em.getTransaction().commit();

} catch (Exception e) {
    // Annulation de la transaction en cas d’erreur
    if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
    }
    e.printStackTrace();
} finally {
    // Fermeture de l’EntityManager
    em.close();
    // Fermeture de l’EntityManagerFactory
    emf.close();
}

L’objectif principal de JPA est de simplifier le développement d’applications travaillant avec des bases de données, en abstraisant les détails de bas niveau du travail avec JDBC et SQL, en fournissant une approche orientée objet pour la persistance. Cela augmente la portabilité du code et réduit sa dépendance à une base de données spécifique.