47.3 Verwendung des Java Persistenz API

• 47.3 Verwendung des Java Persistenz API
  • 47.3.1 Der EntityManager
  • 47.3.2 Transaktionen mit dem EntityManager
  • 47.3.3 Anlegen eines neuen Datensatzes
  • 47.3.4 Laden eines Datensatzes
  • 47.3.5 Löschen eines Datensatzes

47.3.1 Der EntityManager

Nachdem die Java-Klasse Verzeichnis mit Metainformationen zur abgebildeten Tabelle ausgestattet und der Zugang zur Datenbank mit Hilfe des Persistenz Descriptor konfiguriert wurde, können wir die im Hintergrund arbeitende Datenbank im Grunde vergessen und uns ganz auf die Arbeit mit den Java-Klassen bzw. -Objekten konzentrieren. Die Transformation der Java-Operationen auf ihre SQL-Pendants und zurück übernimmt die Persistenzschicht, auf die wir mit Hilfe des EntityManager zugreifen können:

001 /* Listing4704.java */ 002 003 import javax.persistence.*; 004 005 public class Listing4704 006 { 007 public static void main(String[] args) 008 { 009 //Erzeugen einer EntityManagerFactory mit Hilfe des symbolischen 010 //Namens aus dem Persistenz Descriptor (persistence.xml) 011 EntityManagerFactory emf = 012 Persistence.createEntityManagerFactory("persistenceExample"); 013 014 //Erzeugen eines EntityManagers für den Zugriff auf 015 //die Datenbank 016 EntityManager manager = emf.createEntityManager(); 017 018 //An dieser Stelle können Sie mit Hilfe des EntityManagers auf 019 //die Datenbank zugreifen 020 021 //Freigabe der Ressourcen des EntityManagers 022 manager.close(); 023 024 //Schließen der EntityManagerFactory und Freigeben der 025 //belegten Ressourcen 026 emf.close(); 027 } 028 }

Listing4704.java

Listing 47.4: Zugriff auf den EntityManager

Zunächst erzeugen wir eine EntityManagerFactory, die dazu verwendet wird, einen EntityManager zu erzeugen. Hierfür verwenden wir in Zeile 012 den symbolischen Namen des Persistenz Descriptor aus Zeile 007 des Listing 47.3. Ist der EntityManager erzeugt, können wir mit seiner Hilfe nun alle lesenden und schreibenden Operationen auf der Datenbank ausführen. Da sowohl der EntityManager als auch die EntityManagerFactory auf die Datenbank zugreifen und Ressourcen belegen, müssen wir diese am Ende eines Programms durch Aufruf von close zurückgeben.

47.3.2 Transaktionen mit dem EntityManager

Das Java Persistenz API gestattet Datenbankzugriffe nur innerhalb von Transaktionen (siehe auch Abschnitt 44.4.3) - selbst wenn diese nur lesend sind. Derartige Datenbanktransaktionen lassen sich mit dem EntityManager jedoch leicht realisieren, indem wir eine EntityTransaction erzeugen und mit der Methode begin starten. Alle folgenden Zugriffe und Manipulationen erfolgen dann so lange innerhalb der Transaktion, bis diese durch Aufruf der Methode commit abgeschlossen oder via rollback zurückgesetzt wird.

001 /* Listing4705.java */ 002 003 import javax.persistence.*; 004 005 public class Listing4705 006 { 007 public static void main(String[] args) 008 { 009 //Erzeugen einer EntityManagerFactory mit Hilfe des symbolischen 010 //Namens aus dem Persistenz Descriptor (persistence.xml) 011 EntityManagerFactory emf = 012 Persistence.createEntityManagerFactory("persistenceExample"); 013 014 //Erzeugen eines EntityManagers für den Zugriff auf 015 //die Datenbank 016 EntityManager manager = emf.createEntityManager(); 017 018 //Beginn einer neuen Transanktion 019 EntityTransaction tx = manager.getTransaction(); 020 tx.begin(); 021 022 //An dieser Stelle können Sie mit Hilfe des EntityManagers auf 023 //die Datenbank zugreifen 024 025 //Abschluss der Transaktion mit einem Commit 026 tx.commit(); 027 028 //Freigabe der Ressourcen des EntityManagers 029 manager.close(); 030 031 //Schließen der EntityManagerFactory und Freigeben der 032 //belegten Ressourcen 033 emf.close(); 034 } 035 }

Listing4705.java

Listing 47.5: Transaktionen im EntityManager

47.3.3 Anlegen eines neuen Datensatzes

Das Anlegen eines neuen Datensatzes haben wir in Listing 44.5 im JDBC-Kapitel mit Hilfe eines INSERT-Statements realisiert. Bei Verwendung des Java Persistenz API verwenden wir den Konstruktor der Klasse Verzeichnis, um ein neues Java-Objekt zu erzeugen, und speichern es anschließend mit Hilfe der Methode persist des EntityManager ab. Die einzelnen Member-Variablen haben wir zuvor durch Aufruf der Setter-Methoden gesetzt.

001 /* Listing4706.java */ 002 003 import javax.persistence.*; 004 005 public class Listing4706 006 { 007 public static void main(String[] args) 008 { 009 //Erzeugen einer EntityManagerFactory mit Hilfe des symbolischen 010 //Namens aus dem Persistenz Descriptor (persistence.xml) 011 EntityManagerFactory emf = 012 Persistence.createEntityManagerFactory("persistenceExample"); 013 014 //Erzeugen eines EntityManagers für den Zugriff auf 015 //die Datenbank 016 EntityManager manager = emf.createEntityManager(); 017 018 //Beginn einer neuen Transanktion 019 EntityTransaction tx = manager.getTransaction(); 020 tx.begin(); 021 022 //Erzeugen eines neuen Java-Objekts 023 Verzeichnis dir = new Verzeichnis(); 024 dir.setDid(0); 025 dir.setDname("temp"); 026 027 //Speichern des Java-Objekts mit Hilfe des EntityManagers 028 manager.persist(dir); 029 030 //Abschluss der Transaktion mit einem Commit 031 tx.commit(); 032 033 //Freigabe der Ressourcen des EntityManagers 034 manager.close(); 035 036 //Schließen der EntityManagerFactory und Freigeben der 037 //belegten Ressourcen 038 emf.close(); 039 } 040 }

Listing 47.6: Anlegen eines Datensatzes

Wie man sieht, reichen die Anweisungen von Zeile 023 bis Zeile 028, um einen neuen Datensatz anzulegen. Wir benötigen keinerlei Wissen über die im Hintergrund arbeitende Datenbank und müssen auch keinerlei SQL-Kommandos formulieren. All diese Details nimmt uns das Persistenz API ab.

47.3.4 Laden eines Datensatzes

Nachdem wir den Datensatz in der Datenbank gespeichert haben, möchten wir ihn nun auch wieder aus dieser laden können. Dafür können wir beispielsweise die Methode find des EntityManager verwenden:

001 /* Listing4707.java */ 002 003 import javax.persistence.*; 004 005 public class Listing4707 006 { 007 public static void main(String[] args) 008 { 009 //Erzeugen einer EntityManagerFactory mit Hilfe des symbolischen 010 //Namens aus dem Persistenz Descriptor (persistence.xml) 011 EntityManagerFactory emf = 012 Persistence.createEntityManagerFactory("persistenceExample"); 013 014 //Erzeugen eines EntityManagers für den Zugriff auf 015 //die Datenbank 016 EntityManager manager = emf.createEntityManager(); 017 018 //Beginn einer neuen Transanktion 019 EntityTransaction tx = manager.getTransaction(); 020 tx.begin(); 021 022 //Laden des Verzeichnis-Objekts mit der Id=0 023 Verzeichnis dir = manager.find(Verzeichnis.class, 0); 024 025 //Ausgabe des gefundenen Objekts 026 System.out.println(dir); 027 028 //Abschluss der Transaktion mit einem Commit 029 tx.commit(); 030 031 //Freigabe der Ressourcen des EntityManagers 032 manager.close(); 033 034 //Schließen der EntityManagerFactory und Freigeben der 035 //belegten Ressourcen 036 emf.close(); 037 } 038 }

Listing4707.java

Listing 47.7: Laden eines Datensatzes

Statt das Java-Objekt selbst zu erzeugen, rufen wir find auf, um den Datensatz aus der Datenbank zu laden. find erhält als ersten Parameter die gesuchte Klasse und als zweiten Parameter den eindeutigen Schlüssel des zu ladenden Datensatzes (in diesem Fall die Nummer 0).

Der EntityManager wird nun ein entsprechendes SELECT-Statement formulieren und versuchen, den Datensatz aus der Tabelle dir auszulesen. Findet er den gesuchten Datensatz, liefert er ihn als Objekt der Klasse Verzeichnis zurück, andernfalls ist der Rückgabewert null. Wir werden später Möglichkeiten kennenlernen, mit denen Datensätze nicht nur nach ID, sondern nach beliebigen Kriterien gesucht werden können.

47.3.5 Löschen eines Datensatzes

Um einen Satz aus der Datenbank zu löschen, bietet der EntityManager die Methode remove:

001 /* Listing4708.java */ 002 003 import javax.persistence.*; 004 005 public class Listing4708 006 { 007 public static void main(String[] args) 008 { 009 //Erzeugen einer EntityManagerFactory mit Hilfe des symbolischen 010 //Namens aus dem Persistenz Descriptor (persistence.xml) 011 EntityManagerFactory emf = 012 Persistence.createEntityManagerFactory("persistenceExample"); 013 014 //Erzeugen eines EntityManagers für den Zugriff auf 015 //die Datenbank 016 EntityManager manager = emf.createEntityManager(); 017 018 //Beginn einer neuen Transanktion 019 EntityTransaction tx = manager.getTransaction(); 020 tx.begin(); 021 022 //Laden des Verzeichnis-Objekts mit der Id=0 023 Verzeichnis dir = manager.find(Verzeichnis.class, 0); 024 025 if (dir != null) { 026 //Löschen des Datensatzes aus der Datenbank 027 manager.remove(dir); 028 } 029 030 //Abschluss der Transaktion mit einem Commit 031 tx.commit(); 032 033 //Freigabe der Ressourcen des EntityManagers 034 manager.close(); 035 036 //Schließen der EntityManagerFactory und Freigeben der 037 //belegten Ressourcen 038 emf.close(); 039 } 040 }

Listing4708.java

Listing 47.8: Löschen eines Datensatzes