Mi az a JPA (Java Persistence API)?

A JPA a Java alkalmazásokban az adatok persistenciájának kezelésére szolgáló API-specifikáció. Ez egy szabványos módszert kínál a Java objektumok relációs adatbázisokba (vagy más adattárolókba) történő leképezésére és visszaadására. A JPA a Java EE (most Jakarta EE) platform része, és önálló alkalmazásokban is használható.

A JPA fő komponensei:

• Entity: Általános Java osztályok (POJO-k), amelyeket az @Entity annotációval láttak el, és amelyek az adatbázisban tárolt adatokat reprezentálják.
• EntityManager: Interfész az persistencia kontextussal való interakcióhoz. Az entitások keresésére, létrehozására, frissítésére és törlésére szolgál.
• Persistence Context: Az EntityManager által kezelt entitások halmaza. Figyeli az entitások változásait az adatbázissal való szinkronizálás előtt.
• JPQL (Java Persistence Query Language): Egy objektum-orientált lekérdező nyelv, amely hasonlít az SQL-re, de entitásokkal és azok kapcsolataival dolgozik a táblák és oszlopok helyett.
• Criteria API: Egy objektum-orientált API dinamikus lekérdezések végrehajtására.
• persistence.xml: Konfigurációs fájl, amely leírja a persistencia egységeket (persistence units) és azok tulajdonságait (pl. adatbázis kapcsolati adatok, térképezési stratégiák).

A JPA nem egy konkrét ORM (Object-Relational Mapping) implementáció, hanem szerződéseket és API-kat határoz meg. Ezt a specifikációt több különböző szolgáltató valósítja meg, amelyek közül a legnépszerűbbek:

• Hibernate
• EclipseLink
• Apache OpenJPA

Az entitás meghatározásának példája:

// Entitás, amely a `products` táblázat rekordját reprezentálja
@Entity
// A táblázat neve az adatbázisban
@Table(name = "products")
public class Product {

    // Elsődleges kulcs
    @Id
    // Az elsődleges kulcs generálási stratégiája
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // `name` oszlop a táblában
    private String name;

    // `price` oszlop a táblában
    private BigDecimal price;

    // Konstruktorok, getterek és setterek
    // ...
}

EntityManager használatának példája:

// EntityManager beszerzése az EntityManagerFactory-ből
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPersistenceUnit");
EntityManager em = emf.createEntityManager();

try {
    // Tranzakció indítása
    em.getTransaction().begin();

    // Új entitás létrehozása
    Product newProduct = new Product();
    newProduct.setName("Laptop");
    newProduct.setPrice(new BigDecimal("1200.00"));

    // Entitás mentése az adatbázisba
    em.persist(newProduct);

    // Entitás keresése elsődleges kulcs alapján
    Product foundProduct = em.find(Product.class, 1L);
    System.out.println("Talált termék: " + foundProduct.getName());

    // JPQL lekérdezés végrehajtása
    List<Product> allProducts = em.createQuery("SELECT p FROM Product p", Product.class).getResultList();
    for (Product p : allProducts) {
        System.out.println(p.getName());
    }

    // Tranzakció commitálása
    em.getTransaction().commit();

} catch (Exception e) {
    // Hiba esetén a tranzakció visszavonása
    if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
    }
    e.printStackTrace();
} finally {
    // EntityManager lezárása
    em.close();
    // EntityManagerFactory lezárása
    emf.close();
}

A JPA fő célja az alkalmazások fejlesztésének megkönnyítése, amelyek adatbázisokkal dolgoznak, az alacsony szintű JDBC és SQL részletek absztrakciójával, objektum-orientált megközelítést kínálva a persistenciához. Ez növeli a kód hordozhatóságát és csökkenti a konkrét adatbázishoz való kötöttségét.