Cos'è JPA (Java Persistence API)?

JPA è una specifica API per la gestione della persistenza dei dati nelle applicazioni Java. Fornisce un modo standard per mappare gli oggetti Java sui database relazionali (o altri sistemi di archiviazione) e viceversa. JPA fa parte della piattaforma Java EE (ora Jakarta EE) e può essere utilizzata anche in applicazioni standalone.

Componenti chiave di JPA:

• Entity: Classi Java normali (POJO), contrassegnate con l’annotazione @Entity, che rappresentano i dati nel database.
• EntityManager: Interfaccia per interagire con il contesto di persistenza. Usata per cercare, creare, aggiornare e eliminare entità.
• Contesto di persistenza: Insieme di entità gestite da EntityManager. Qui vengono monitorate le modifiche alle entità prima di sincronizzarle con il database.
• JPQL (Java Persistence Query Language): Linguaggio di query orientato agli oggetti, simile a SQL, ma che opera con entità e le loro relazioni invece di tabelle e colonne.
• Criteria API: API orientata agli oggetti per eseguire query dinamiche.
• persistence.xml: File di configurazione che descrive le unità di persistenza (persistence units) e le loro proprietà (ad esempio, informazioni di connessione al database, strategie di mapping).

JPA non è un’implementazione concreta di ORM (Object-Relational Mapping), ma definisce contratti e API. Esistono diversi provider di JPA che implementano questa specifica, tra cui i più popolari:

• Hibernate
• EclipseLink
• Apache OpenJPA

Esempio di definizione di entità:

// Entità che rappresenta una riga nella tabella `products`
@Entity
// Nome della tabella nel database
@Table(name = "products")
public class Product {

    // Chiave primaria
    @Id
    // Strategia di generazione della chiave primaria
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // Colonna `name` nella tabella
    private String name;

    // Colonna `price` nella tabella
    private BigDecimal price;

    // Costruttori, getters e setters
    // ...
}

Esempio di utilizzo di EntityManager:

// Ottenere EntityManager da EntityManagerFactory
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPersistenceUnit");
EntityManager em = emf.createEntityManager();

try {
    // Inizio transazione
    em.getTransaction().begin();

    // Creazione di una nuova entità
    Product newProduct = new Product();
    newProduct.setName("Laptop");
    newProduct.setPrice(new BigDecimal("1200.00"));

    // Salvataggio dell’entità nel database
    em.persist(newProduct);

    // Ricerca di un’entità tramite chiave primaria
    Product foundProduct = em.find(Product.class, 1L);
    System.out.println("Prodotto trovato: " + foundProduct.getName());

    // Esecuzione di una query JPQL
    List<Product> allProducts = em.createQuery("SELECT p FROM Product p", Product.class).getResultList();
    for (Product p : allProducts) {
        System.out.println(p.getName());
    }

    // Commit della transazione
    em.getTransaction().commit();

} catch (Exception e) {
    // Rollback in caso di errore
    if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
    }
    e.printStackTrace();
} finally {
    // Chiusura di EntityManager
    em.close();
    // Chiusura di EntityManagerFactory
    emf.close();
}

L’obiettivo principale di JPA è semplificare lo sviluppo di applicazioni che lavorano con database, astrando i dettagli di basso livello del lavoro con JDBC e SQL, fornendo un approccio orientato agli oggetti alla persistenza. Ciò aumenta la portabilità del codice e riduce la sua dipendenza da un database specifico.