Java einfach erklärt

Plain Java

Grundlagen zu JPA-Entities

Java Persistence API (JPA) ist eine Java-Spezifikation, die die Möglichkeit bietet, Datenbanken in Java-Anwendungen auf eine objektorientierte Weise zu verwenden. JPA ermöglicht es Entwicklern, Java-Objekte direkt in Datenbanktabellen zu speichern und abzurufen, ohne sich um SQL-Code oder Datenbankdetails kümmern zu müssen. In diesem Artikel werden die Grundlagen von JPA-Entities erklärt, einem wichtigen Konzept in der JPA-Welt.

Was sind JPA-Entities?

In JPA stellen Entities die grundlegenden Bausteine dar, die Datenbankdaten in Java-Anwendungen repräsentieren. Eine JPA-Entity ist im Wesentlichen eine Java-Klasse, die als Repräsentation einer Tabelle in der Datenbank fungiert. Jedes Entity-Objekt entspricht einer Zeile in der Tabelle. Mit anderen Worten, Entities sind POJOs (Plain Old Java Objects), die zur Speicherung und Abfrage von Daten aus der Datenbank verwendet werden.

Hier ist ein einfaches Beispiel für eine JPA-Entity-Klasse:

@Entity
@Table(name = "person")
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private int age;

    // Konstruktor, Getter und Setter
}Code-Sprache: PHP (php)

In diesem Beispiel repräsentiert die Klasse Person eine Tabelle namens „person“ in der Datenbank. Die Annotationen @Entity und @Table werden verwendet, um JPA mitzuteilen, dass diese Klasse eine Entity ist und mit der Tabelle „person“ in der Datenbank verknüpft ist.

Die Annotation @Id zeigt an, dass das Feld id das Primärschlüsselfeld ist, das eindeutige Werte für jede Zeile in der Tabelle identifiziert. Die Annotation @GeneratedValue gibt an, dass der Wert für das Feld id automatisch generiert wird.

Eigenschaften von JPA-Entities

JPA-Entities haben einige wichtige Eigenschaften und Verhaltensweisen, die es zu beachten gilt:

1. Persistenz

Entities sind persistent, was bedeutet, dass sie über ihren Lebenszyklus hinaus in der Datenbank gespeichert bleiben. Wenn Sie eine Instanz einer Entity-Klasse erstellen und sie in einer Transaktion speichern, wird diese Änderung in der Datenbank festgehalten.

EntityManager entityManager = ... // EntityManager initialisieren
Person person = new Person();
person.setName("John");
person.setAge(30);

entityManager.getTransaction().begin();
entityManager.persist(person); // Speichern der Entity in der Datenbank
entityManager.getTransaction().commit();Code-Sprache: JavaScript (javascript)

2. Lebenszyklus

Entities durchlaufen verschiedene Zustände während ihres Lebenszyklus:

  • New: Eine Entity ist neu erstellt und nicht mit der Datenbank verknüpft.
  • Managed: Eine Entity ist mit einem aktiven JPA-Context (EntityManager) verknüpft und wird von diesem verwaltet.
  • Detached: Eine Entity war zuvor verwaltet, ist aber nicht mehr mit einem EntityManager verbunden.
  • Removed: Eine Entity wird aus der Datenbank entfernt.

Der EntityManager steuert den Übergang zwischen diesen Zuständen.

3. Beziehungen

Entities können Beziehungen zueinander haben, um komplexe Datenstrukturen zu modellieren. Diese Beziehungen können eins zu eins, eins zu viele, viele zu eins oder viele zu viele sein. Hier ist ein einfaches Beispiel für eine Beziehung zwischen Person– und Address-Entities:

@Entity
public class Person {
    // ...
    @OneToMany(mappedBy = "person")
    private List<Address> addresses;
    // ...
}

@Entity
public class Address {
    // ...
    @ManyToOne
    @JoinColumn(name = "person_id")
    private Person person;
    // ...
}Code-Sprache: PHP (php)

In diesem Beispiel kann eine Person mehrere Address-Objekte haben, während eine Address immer nur zu einer Person gehört.

4. Abfrage

Mit JPA können Sie mithilfe der JPQL (Java Persistence Query Language) oder Criteria-API komplexe Abfragen erstellen, um Daten aus der Datenbank abzurufen und zu filtern.

TypedQuery<Person> query = entityManager.createQuery("SELECT p FROM Person p WHERE p.age > :age", Person.class);
query.setParameter("age", 25);
List<Person> resultList = query.getResultList();Code-Sprache: HTML, XML (xml)

In diesem Beispiel wird eine JPQL-Abfrage erstellt, um alle Personen abzurufen, deren Alter größer als 25 ist.

Entity-Beziehungen

Wie bereits erwähnt, können Entities Beziehungen zueinander haben. Diese Beziehungen können unidirektional oder bidirektional sein und müssen sorgfältig modelliert werden, um die Konsistenz der Datenbank zu gewährleisten.

Unidirektionale Beziehung

Eine unidirektionale Beziehung bedeutet, dass eine Entity-Instanz auf eine andere Entity-Instanz verweisen kann, aber die andere Entity-Instanz nicht auf die erste verweisen kann. In unserem vorherigen Beispiel mit Person und Address hatten wir eine unidirektionale Beziehung, da Address auf Person verwies, aber nicht umgekehrt.

Bidirektionale Beziehung

Eine bidirektionale Beziehung bedeutet, dass Entities aufeinander verweisen können. Dies erfordert zusätzliche Konfiguration, um sicherzustellen, dass die Beziehungen in beiden Richtungen konsistent bleiben.

Hier ist ein Beispiel für eine bidirektionale Beziehung zwischen Author und Book:

@Entity
public class Author {
    // ...
    @OneToMany(mappedBy = "author")
    private List<Book> books;
    // ...
}

@Entity
public class Book {
    // ...
    @ManyToOne
    @JoinColumn(name = "author_id")
    private Author author;
    // ...
}Code-Sprache: PHP (php)

In diesem Fall kann eine Author-Instanz eine Liste von Book-Instanzen haben, und jede Book-Instanz verweist auf ihren Author. Dies ermöglicht es, von Author zu Book und umgekehrt zu navigieren.

Verwendung von JPA-Entities

Um JPA-Entities in Ihrer Java-Anwendung zu verwenden, müssen Sie eine Implementierung von JPA (z. B. Hibernate, EclipseLink oder OpenJPA) in Ihr Projekt integrieren und einen EntityManager erstellen. Der EntityManager ist für die Verwaltung von Entities verantwortlich und bietet Methoden zum Speichern, Aktualisieren, Löschen und Abfragen von Daten.

Hier ist ein einfaches Beispiel, wie Sie den EntityManager verwenden können:

// EntityManagerFactory erstellen (einmalig während des Anwendungsstarts)
EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-persistence-unit");

// EntityManager erstellen (pro Transaktion oder Anfrage)
EntityManager em = emf.createEntityManager();

// Transaktion starten
em.getTransaction().begin();

// Entity erstellen und speichern
Person person = new Person();
person.setName("Alice");
person.setAge(28);
em.persist(person);

// Transaktion abschließen
em.getTransaction().commit();

// Entity abfragen
Person retrievedPerson = em.find(Person.class, 1L); // Hierbei wird die Person mit der ID 1 abgerufen

// EntityManager und EntityManagerFactory schließen
em.close();
emf.close();Code-Sprache: JavaScript (javascript)

In diesem Beispiel wird eine EntityManagerFactory erstellt, um den EntityManager zu erstellen. Dann wird eine Transaktion gestartet, eine Person-Entity erstellt und gespeichert. Schließlich wird die Transaktion abgeschlossen, die Person-Entity abgerufen und die Ressourcen freigegeben.

Best Practices und Tipps

Beim Arbeiten mit JPA-Entities gibt es einige bewährte Praktiken und Tipps, die Ihnen helfen können, effiziente und konsistente Anwendungen zu erstellen:

  1. Transaktionsmanagement: Achten Sie darauf, Transaktionen sorgfältig zu verwalten, um Datenkonsistenz sicherzustellen. Verwenden Sie em.getTransaction().begin() zum Starten einer Transaktion und em.getTransaction().commit() zum Abschließen.
  2. Lazy Loading: Verwenden Sie Lazy Loading, um die Leistung Ihrer Anwendung zu verbessern. Dadurch werden Beziehungen zwischen Entities erst geladen, wenn sie benötigt werden.
  3. Equals und Hashcode: Implementieren Sie die equals()– und hashCode()-Methoden in Ihren Entity-Klassen, um sicherzustellen, dass Entity-Instanzen korrekt verglichen und in Sammlungen verwendet werden können.
  4. Caching: Verwenden Sie den Second-Level-Cache, um häufig abgerufene Daten zu speichern und die Datenbankzugriffe zu minimieren.
  5. Validierung: Führen Sie Datenvalidierung auf Entity-Ebene durch, um sicherzustellen, dass die Datenbank konsistente Daten enthält.
  6. DTOs (Data Transfer Objects): Verwenden Sie DTOs, um die Übertragung von Daten zwischen Schichten zu vereinfachen und unnötige Datenbankzugriffe zu vermeiden.
  7. Testing: Schreiben Sie Unit- und Integrationstests für Ihre Entity-Klassen, um sicherzustellen, dass sie wie erwartet funktionieren.

Unterstützte Datenbanken

Die Java Persistence API (JPA) ist eine Spezifikation für ORM (Object-Relational Mapping), die es ermöglicht, Java-Objekte mit relationalen Datenbanken zu verknüpfen. JPA ist datenbankagnostisch, was bedeutet, dass es mit einer Vielzahl von Datenbanksystemen verwendet werden kann, solange ein kompatibler JDBC-Treiber vorhanden ist.

Hier ist eine Liste gängiger relationaler Datenbanksysteme, die mittels JPA angebunden werden können:

Open-Source-Datenbanken

  1. MySQL
  2. PostgreSQL
  3. MariaDB
  4. SQLite
  5. Apache Derby
  6. H2 Database
  7. Firebird

Kommerzielle Datenbanken

  1. Oracle Database
  2. Microsoft SQL Server
  3. IBM Db2
  4. SAP HANA
  5. Teradata
  6. Amazon Aurora

Cloud-Datenbanken (mit JDBC-Support)

  1. Google Cloud SQL (unterstützt MySQL und PostgreSQL)
  2. Amazon RDS (unterstützt verschiedene Engines wie MySQL, PostgreSQL, Oracle, SQL Server)
  3. Microsoft Azure SQL Database

NoSQL-Datenbanken (mit speziellen JPA-Erweiterungen)

Einige NoSQL-Datenbanken können mit JPA verwendet werden, wenn ein entsprechender Treiber oder eine Middleware-Lösung verfügbar ist. Beispiele:

  1. MongoDB (über spezielle JPA-Implementierungen wie Hibernate OGM)
  2. Cassandra
  3. Neo4j

JPA-Implementierungen

JPA selbst ist nur eine Spezifikation. Die Verbindung zu den Datenbanken wird durch JPA-Implementierungen ermöglicht. Zu den häufig verwendeten Implementierungen gehören:

  • Hibernate
  • EclipseLink
  • Apache OpenJPA
  • DataNucleus

Voraussetzung

Um eine Datenbank mittels JPA anzubinden, ist ein passender JDBC-Treiber erforderlich. Der Treiber wird in der Konfigurationsdatei (z. B. persistence.xml) zusammen mit den Verbindungsinformationen eingebunden.

Fazit

JPA-Entities sind eine wesentliche Komponente bei der Verwendung von JPA zur Datenbankinteraktion in Java-Anwendungen. Sie ermöglichen es Entwicklern, Datenbankdaten auf eine objektorientierte Weise zu modellieren und zu verwenden. Mit den richtigen Best Practices und Kenntnissen können Sie JPA-Entities effektiv nutzen, um leistungsfähige und konsistente Anwendungen zu erstellen.