Ce este JPA (Java Persistence API)?

JPA este o specificație API pentru gestionarea persistenței datelor în aplicațiile Java. Oferă o metodă standard de mapare a obiectelor Java în bazele de date relaționale (sau alte depozite de date) și invers. JPA face parte din platforma Java EE (acum Jakarta EE) și poate fi utilizată și în aplicații standalone.

Componentele cheie ale JPA:

• Entitate: Clase Java normale (POJO-uri), marcate cu adnotarea @Entity, care reprezintă date în bază de date.
• EntityManager: Interfață pentru interacțiunea cu contextul de persistență. Este folosit pentru căutarea, crearea, actualizarea și ștergerea entităților.
• Contextul de persistență: Set de entități gestionate de EntityManager. Aici sunt urmărite modificările entităților înainte de sincronizarea cu baza de date.
• JPQL (Java Persistence Query Language): Limbaj de interogare orientat pe obiecte, similar cu SQL, dar care operează cu entități și relațiile lor în loc de tabele și coloane.
• Criteria API: API orientat pe obiecte pentru executarea interogărilor dinamice.
• persistence.xml: Fișier de configurare care descrie unitățile de persistență (persistence units) și proprietățile acestora (de exemplu, informații despre conexiunea la bază de date, strategii de mapare).

JPA nu este o implementare concretă ORM (Object-Relational Mapping), ci doar definește contracte și API. Există diverși furnizori de JPA care implementează această specificație, cei mai populari fiind:

• Hibernate
• EclipseLink
• Apache OpenJPA

Exemplu de definire a unei entități:

// Entitate care reprezintă o înregistrare în tabelul `products`
@Entity
// Numele tabelului în bază de date
@Table(name = "products")
public class Product {

    // Cheie primară
    @Id
    // Strategia de generare a cheii primare
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // Coloana `name` în tabel
    private String name;

    // Coloana `price` în tabel
    private BigDecimal price;

    // Constructori, getters și setters
    // ...
}

Exemplu de utilizare a EntityManager:

// Obținerea unui EntityManager din EntityManagerFactory
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPersistenceUnit");
EntityManager em = emf.createEntityManager();

try {
    // Începutul unei tranzacții
    em.getTransaction().begin();

    // Crearea unei noi entități
    Product newProduct = new Product();
    newProduct.setName("Laptop");
    newProduct.setPrice(new BigDecimal("1200.00"));

    // Salvarea entității în bază
    em.persist(newProduct);

    // Căutarea unei entități după cheia primară
    Product foundProduct = em.find(Product.class, 1L);
    System.out.println("Produs găsit: " + foundProduct.getName());

    // Executarea unei interogări JPQL
    List<Product> allProducts = em.createQuery("SELECT p FROM Product p", Product.class).getResultList();
    for (Product p : allProducts) {
        System.out.println(p.getName());
    }

    // Confirmarea tranzacției
    em.getTransaction().commit();

} catch (Exception e) {
    // Rularea înapoi a tranzacției în caz de eroare
    if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
    }
    e.printStackTrace();
} finally {
    // Închiderea EntityManager
    em.close();
    // Închiderea EntityManagerFactory
    emf.close();
}

Scopul principal al JPA este de a simplifica dezvoltarea aplicațiilor care lucrează cu baze de date, prin abstractizarea detaliilor de nivel inferior ale lucrului cu JDBC și SQL, oferind o abordare orientată pe obiecte pentru persistență. Acest lucru crește portabilitatea codului și reduce dependența de o bază de date specifică.