Java Persistence API (JPA) mit H2 In-Memory-Datenbank

Java Persistence API (JPA)

Java Persistence API (JPA) ist ein Spezifikationsstandard, der den Zugriff von Java-Anwendungen auf relationale Datenbanken in einer objektrelationalen Mapping (ORM) Weise regelt. In diesem Beitrag fokussieren wir uns auf die Grundlagen der Verwendung von JPA mit einer H2 In-Memory-Datenbank.

Schritt 1: Einbindung der JPA-Bibliothek

Um JPA in Ihrem Projekt nutzen zu können, benötigen Sie zuerst die JPA-Bibliothek und die Implementierung Ihrer Wahl. Ein gängiger Ansatz ist die Verwendung von Hibernate als JPA-Implementierung. Wenn Sie Maven verwenden, können Sie dies durch Hinzufügen der folgenden Abhängigkeiten in Ihre pom.xml erreichen:

  <dependency>

    <groupId>org.hibernategroupId>

    <artifactId>hibernate-entitymanagerartifactId>

    <version>5.4.27.Finalversion>

  dependency>

  <dependency>

    <groupId>com.h2databasegroupId>

    <artifactId>h2artifactId>

    <version>1.4.200version>

  dependency>

Schritt 2: Erstellen der JPA-Konfiguration

In vielen modernen Java-Anwendungen, insbesondere in jenen, die sich mit Datenbankinteraktionen befassen, spielt die Java Persistence API (JPA) eine entscheidende Rolle. JPA ermöglicht es Entwicklern, Datenbanktransaktionen nahtlos in ihre Java-Anwendungen zu integrieren, ohne sich direkt mit SQL auseinandersetzen zu müssen. Eine der Kernkomponenten dieses Frameworks ist die persistence.xml-Datei, die wir im Folgenden diskutieren werden.

  "http://xmlns.jcp.org/xml/ns/persistence"

            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

            xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"

            version="2.1">

      "myPU">

            "javax.persistence.jdbc.url" value="jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1"/>

            "javax.persistence.jdbc.driver" value="org.h2.Driver"/>

            "javax.persistence.jdbc.user" value="sa"/>

            "javax.persistence.jdbc.password" value=""/>

            "hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/>

            "hibernate.hbm2ddl.auto" value="update"/>

Was ist die persistence.xml?

Die persistence.xml ist die Hauptkonfigurationsdatei für JPA. Sie enthält Informationen darüber, wie Ihre Anwendung mit der Datenbank interagiert, einschließlich Details wie Datenbank-URL, Treiber, Benutzername, Passwort und viele andere spezifische Einstellungen.

Wo sollte diese Datei platziert werden?

Diese Datei sollte im Verzeichnis META-INF innerhalb des src/main/resources-Ordners Ihres Maven- oder Gradle-Projekts platziert werden. Wenn Sie dieses Verzeichnis nicht in Ihrem Projekt sehen, können Sie es manuell erstellen. Die Struktur sollte wie folgt aussehen:

IhrProjekt/
│
├── src/
│ ├── main/
│ │ ├── java/
│ │ └── resources/
│ │ └── META-INF/
│ │ └── persistence.xml
│ ...

Was sagt uns die persistence.xml?

Das Beispiel ist für eine Anwendung konfiguriert, die eine H2 in-memory Datenbank verwendet und Hibernate als JPA-Implementierung einsetzt.

Datenbankdetails: Es wird eine H2 in-memory Datenbank mit der URL jdbc:h2:mem:testdb und dem Benutzernamen „sa“ (ohne Passwort) verwendet.
Hibernate-Einstellungen: Das Beispiel verwendet Hibernate-spezifische Einstellungen, wie den H2-Dialekt und die automatische Aktualisierung der Datenbankstruktur basierend auf den JPA-Entities.

Dieses XML-Snippet ist eine Konfiguration für die Java Persistence API (JPA). JPA ist eine Spezifikation für das Objekt-Relationale Mapping (ORM) in Java. Es ermöglicht Java-Anwendungen, Objekte mit relationalen Datenbanktabellen zu mappen und Datenbankabfragen mit Java-Objekten anstelle von SQL durchzuführen.

Erläuterung der einzelnen Einträge:

Deklaration und Schema-Informationen:

Das Dokument definiert den `persistence` Namespace und verwendet das JPA 2.1 Schema.

Der `version=“2.1″ Attributwert zeigt an, dass es die Version 2.1 der JPA-Spezifikation verwendet.
persistence-unit Ein `persistence-unit` definiert eine Einheit von ORM innerhalb einer Anwendung. In diesem Fall hat die `persistence-unit` den Namen „myPU“.

Eigenschaften

Innerhalb der `properties` Sektion gibt es mehrere `property` Elemente, die verschiedene Konfigurationsdetails für die JPA-Einheit angeben:

`javax.persistence.jdbc.url`: Die URL der Datenbank. Hier wird eine in-memory H2-Datenbank verwendet (`jdbc:h2:mem:testdb`) und
`DB_CLOSE_DELAY=-1` stellt sicher, dass die Datenbank nicht geschlossen wird, wenn die letzte Verbindung beendet ist.
`javax.persistence.jdbc.driver`: Der JDBC-Treiber für die Datenbank. Hier ist es der H2-Datenbanktreiber.
`javax.persistence.jdbc.user`: Der Benutzername für die Datenbankverbindung. In diesem Fall „sa“, was der Standardbenutzer für die H2-Datenbank ist.
`javax.persistence.jdbc.password`: Das Passwort für die Datenbankverbindung. Hier ist es leer, da die H2-Datenbank standardmäßig kein Passwort erfordert.
`hibernate.dialect`: Gibt den Dialekt an, den Hibernate (ein populäres JPA-Implementierung) verwenden soll.
Der angegebene Wert ist der Dialekt für die H2-Datenbank.
`hibernate.hbm2ddl.auto`: Dies ist eine Hibernate-spezifische Eigenschaft.
Der Wert „update“ bedeutet, dass Hibernate versucht, die Datenbankstruktur automatisch basierend auf den definierten JPA-Entities zu aktualisieren.

Was ist noch zu beachten?

Nachdem Sie die persistence.xml in Ihrem Projekt platziert haben:

Abhängigkeiten überprüfen: Stellen Sie sicher, dass Sie alle notwendigen Bibliotheken und Abhängigkeiten in Ihrer pom.xml oder build.gradle haben, einschließlich der H2-Datenbank und Hibernate.

JPA-Entities erstellen: Entwerfen Sie Ihre Datenbank-Entities als Java-Klassen und annotieren Sie sie entsprechend mit JPA-Annotationen wie @Entity, @Table, @Id usw.
EntityManager verwenden: Erstellen Sie in Ihrem Code einen EntityManager, um CRUD-Operationen (Create, Read, Update, Delete) auf Ihren Datenbank-Entities auszuführen.

Tests durchführen: Da es sich um eine in-memory Datenbank handelt, sind die Daten flüchtig. Das bedeutet, dass sie verloren gehen, wenn die Anwendung beendet wird. Es ist ideal für Tests, aber für eine Produktionsumgebung sollten Sie auf eine robustere Datenbank wie PostgreSQL, MySQL oder Oracle umsteigen.

Schritt 3: EntityManager erstellen

Die Klasse EntityManager ist das zentrale Interface von JPA. Sie erstellen einen EntityManager mit Hilfe der EntityManagerFactory, die Sie mit Ihrer Persistence Unit initialisieren können:

  EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPU");

  EntityManager em = emf.createEntityManager();

Schritt 4: Interaktion mit der Datenbank

Mit JPA können Sie Ihre Datenbankobjekte als Java-Klassen modellieren. Sie können dann diese Objekte verwenden, um mit Ihrer Datenbank zu interagieren.

Nehmen wir an, Sie haben eine Klasse Person:

Sie könnten dann eine neues Person-Objekt erstellen und in Ihrer Datenbank speichern

In diesem Code starten wir eine neue Transaktion, erstellen und speichern eine „neue Person“, und schließen dann die Transaktion:

  @Entity

  public class Person {

    @Id

    @GeneratedValue

    private Long id;

    private String name;

    private Integer age;

    // Getters und Setters ...

  }

  // ...

  em.getTransaction().begin();

  Person person = new Person();

  person.setName("Max Mustermann");

  person.setAge(30);

  em.persist(person);

  em.getTransaction().commit();

Mit JPA können Sie viel mehr als nur einfache CRUD-Operationen durchführen. Sie können auch komplexe Abfragen schreiben, Beziehungen zwischen Entitäten verwalten und vieles mehr. Der Schlüssel liegt in der Fähigkeit, Ihre Datenbankoperationen in einer objektorientierten Weise zu schreiben, die gut zu Java passt.

Bis zum nächsten Mal – Happy Coding!

← JDBC-Verbindung mit H2 In-Memory-Datenbank

Java Best Practices →