Was ist JPA (Java Persistence API)?

JPA ist eine API-Spezifikation für die Verwaltung der Persistenz von Daten in Java-Anwendungen. Sie bietet eine standardisierte Methode, Java-Objekte auf relationale Datenbanken (oder andere Datenspeicher) abzubilden und umgekehrt. JPA ist Teil der Java EE-Plattform (jetzt Jakarta EE) und kann auch in eigenständigen Anwendungen verwendet werden.

Wichtige Komponenten von JPA:

• Entity: Normale Java-Klassen (POJO), markiert mit der Annotation @Entity, die Daten in der Datenbank repräsentieren.
• EntityManager: Schnittstelle zur Interaktion mit dem Persistenzkontext. Wird verwendet, um Entitäten zu suchen, zu erstellen, zu aktualisieren und zu löschen.
• Persistenzkontext: Menge der von EntityManager verwalteten Entitäten. Hier werden Änderungen an Entitäten verfolgt, bevor sie mit der Datenbank synchronisiert werden.
• JPQL (Java Persistence Query Language): Objektorientierte Abfragesprache, ähnlich SQL, arbeitet aber mit Entitäten und deren Beziehungen anstelle von Tabellen und Spalten.
• Criteria API: Objektorientierte API zur Ausführung dynamischer Abfragen.
• persistence.xml: Konfigurationsdatei, die die Persistenzeinheiten (persistence units) und deren Eigenschaften beschreibt (z.B. Verbindungsinformationen zur Datenbank, Mappingstrategien).

JPA ist keine konkrete ORM-Implementierung (Object-Relational Mapping), sondern definiert Verträge und API. Es gibt verschiedene JPA-Anbieter, die diese Spezifikation umsetzen, die beliebtesten sind:

• Hibernate
• EclipseLink
• Apache OpenJPA

Beispiel für die Definition einer Entität:

// Entität, die einen Eintrag in der Tabelle `products` repräsentiert
@Entity
// Name der Tabelle in der Datenbank
@Table(name = "products")
public class Product {

    // Primärschlüssel
    @Id
    // Strategie zur Generierung des Primärschlüssels
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // Spalte `name` in der Tabelle
    private String name;

    // Spalte `price` in der Tabelle
    private BigDecimal price;

    // Konstruktoren, Getter und Setter
    // ...
}

Beispiel für die Verwendung von EntityManager:

// Erhalt eines EntityManager aus der EntityManagerFactory
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPersistenceUnit");
EntityManager em = emf.createEntityManager();

try {
    // Beginn der Transaktion
    em.getTransaction().begin();

    // Erstellen einer neuen Entität
    Product newProduct = new Product();
    newProduct.setName("Laptop");
    newProduct.setPrice(new BigDecimal("1200.00"));

    // Speichern der Entität in der Datenbank
    em.persist(newProduct);

    // Suche nach einer Entität anhand des Primärschlüssels
    Product foundProduct = em.find(Product.class, 1L);
    System.out.println("Gefundenes Produkt: " + foundProduct.getName());

    // Ausführen einer JPQL-Abfrage
    List<Product> allProducts = em.createQuery("SELECT p FROM Product p", Product.class).getResultList();
    for (Product p : allProducts) {
        System.out.println(p.getName());
    }

    // Transaktion committen
    em.getTransaction().commit();

} catch (Exception e) {
    // Transaktion bei Fehler zurücksetzen
    if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
    }
    e.printStackTrace();
} finally {
    // EntityManager schließen
    em.close();
    // EntityManagerFactory schließen
    emf.close();
}

Das Hauptziel von JPA ist es, die Entwicklung von Anwendungen zu vereinfachen, die mit Datenbanken arbeiten, indem die Low-Level-Details der Arbeit mit JDBC und SQL abstrahiert werden und ein objektorientierter Ansatz für die Persistenz bereitgestellt wird. Dies erhöht die Portabilität des Codes und verringert die Abhängigkeit von einer bestimmten Datenbank.