Wat is JPA (Java Persistence API)?

JPA is een API-specificatie voor het beheer van gegevenspersistentie in Java-toepassingen. Het biedt een standaardmanier om Java-objecten te mappen naar relationele databases (of andere opslagplaatsen) en vice versa. JPA maakt deel uit van het Java EE-platform (nu Jakarta EE) en kan ook worden gebruikt in standalone-toepassingen.

Belangrijke componenten van JPA:

• Entity: Gewone Java-klassen (POJO's), gemarkeerd met de annotatie @Entity, die gegevens in de database vertegenwoordigen.
• EntityManager: Interface voor interactie met de persistentiecontext. Wordt gebruikt voor het zoeken, maken, bijwerken en verwijderen van entiteiten.
• Persistentiecontext: Verzameling van entiteiten die worden beheerd door EntityManager. Hier worden wijzigingen in entiteiten gevolgd voordat ze worden gesynchroniseerd met de database.
• JPQL (Java Persistence Query Language): Objectgeoriënteerde querytaal, vergelijkbaar met SQL, maar die opereert met entiteiten en hun relaties in plaats van tabellen en kolommen.
• Criteria API: Objectgeoriënteerde API voor het uitvoeren van dynamische queries.
• persistence.xml: Configuratiebestand dat de persistentie-eenheden (persistence units) en hun eigenschappen beschrijft (bijvoorbeeld, informatie over databaseverbinding, mappingstrategieën).

JPA is geen concrete ORM-implementatie (Object-Relational Mapping), maar definieert contracten en API. Er zijn verschillende JPA-aanbieders die deze specificatie implementeren, de populairste zijn:

• Hibernate
• EclipseLink
• Apache OpenJPA

Voorbeeld van het definiëren van een entiteit:

// Entiteit die een record in de tabel `products` vertegenwoordigt
@Entity
// Naam van de tabel in de database
@Table(name = "products")
public class Product {

    // Primaire sleutel
    @Id
    // Strategie voor het genereren van de primaire sleutel
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // Kolom `name` in de tabel
    private String name;

    // Kolom `price` in de tabel
    private BigDecimal price;

    // Constructeurs, getters en setters
    // ...
}

Voorbeeld van het gebruik van EntityManager:

// Verkrijg een EntityManager uit de EntityManagerFactory
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPersistenceUnit");
EntityManager em = emf.createEntityManager();

try {
    // Begin transactie
    em.getTransaction().begin();

    // Maak een nieuwe entiteit
    Product newProduct = new Product();
    newProduct.setName("Laptop");
    newProduct.setPrice(new BigDecimal("1200.00"));

    // Sla de entiteit op in de database
    em.persist(newProduct);

    // Zoek een entiteit op basis van de primaire sleutel
    Product foundProduct = em.find(Product.class, 1L);
    System.out.println("Gevonden product: " + foundProduct.getName());

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

    // Commit transactie
    em.getTransaction().commit();

} catch (Exception e) {
    // Rollback bij fout
    if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
    }
    e.printStackTrace();
} finally {
    // Sluit EntityManager
    em.close();
    // Sluit EntityManagerFactory
    emf.close();
}

Het hoofddoel van JPA is het vereenvoudigen van de ontwikkeling van applicaties die werken met databases, door de laag-niveau details van JDBC en SQL te abstraheren en een objectgeoriënteerde aanpak voor persistentie te bieden. Dit verhoogt de overdraagbaarheid van de code en vermindert de afhankelijkheid van een specifieke database.