45.3 Verwendung des Java Persistenz API

• 45.3 Verwendung des Java Persistenz API
  • 45.3.1 Der EntityManager
  • 45.3.2 Transaktionen mit dem EntityManager
  • 45.3.3 Anlegen eines neuen Datensatzes
  • 45.3.4 Laden eines Datensatzes
  • 45.3.5 Löschen eines Datensatzes

Nachdem die Java-Klasse Directory mit Metainformationen zur abgebildeten Tabelle ausgestattet und der Zugang zur Datenbank mit Hilfe des Persistence Descriptor konfiguriert ist, können wir nun mit der Klasse arbeiten.

45.3.1 Der EntityManager

Von diesem Moment an können wir die im Hintergrund arbeitende Datenbank im Grunde vergessen und uns ganz auf die Arbeit mit den Java-Objekten konzentrieren. Die Transformation der Java-Operationen auf ihre SQL-Pendants und zurück übernimmt die Persistenzschicht, auf die Sie mit Hilfe des EntityManager zugreifen können. Listing 45.4 zeigt, wie Sie ein EntityManager-Objekt erzeugen:

001 /* Listing4504.java */ 002 003 import javax.persistence.*; 004 005 public class Listing4504 006 { 007 public static void main(String[] args) 008 { 009 //Erzeugen einer EntityManagerFactory mit Hilfe des symbolischen 010 //Namens aus dem Persistence 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 }

Listing4504.java

Listing 45.4: Zugriff auf den EntityManager

Zunächst erzeugen wir eine EntityManagerFactory, die dazu verwendet wird, einen EntityManager für den Zugriff auf die Persistenzschicht zu erzeugen. Hierfür verwenden wir in Zeile 012 den symbolischen Namen des Persistence Descriptor aus Zeile 007 des Listing 45.3.

Ist der EntityManager erzeugt, können wir mit seiner Hilfe nun alle lesenden und schreibenden Operationen auf der Datenbank ausführen.

Zwei wichtige Hinweise seien an dieser Stelle angemerkt: Erstens greifen sowohl der EntityManager als auch die EntityManagerFactory auf die Datenbank zu und belegen dabei Ressourcen. Um diese zurückzugeben rufen wir am Ende eines Programms die Methode close auf. Zweitens wird der EntityManager innerhalb einer Java-EE-Anwendung nicht manuell über die EntityManagerFactory, sondern vom Application Server (z.B. JBoss oder Glassfish) erzeugt. Wenn Sie die JPA in einer Java-EE-Umgebung einsetzen, sollten Sie Ihren Quellcode entsprechend anpassen.

Warnung

45.3.2 Transaktionen mit dem EntityManager

Auch die in Abschnitt 42.4.3 vorgestellten Datenbanktransaktionen lassen sich mit dem EntityManager leicht realisieren. Hierzu erzeugen Sie eine EntityTransaction, starten diese mit der Methode begin und arbeiten nun innerhalb einer Transaktion. Die Transaktion schließen Sie durch Aufruf der Methode commit ab oder setzen Sie über die Methode rollback zurück.

001 /* Listing4505.java */ 002 003 import javax.persistence.*; 004 005 public class Listing4505 006 { 007 public static void main(String[] args) 008 { 009 //Erzeugen einer EntityManagerFactory mit Hilfe des symbolischen 010 //Namens aus dem Persistence 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 }

Listing4505.java

Listing 45.5: Transaktionen im EntityManager

Das Java Persistenz API gestattet Datenbankzugriffe, auch wenn diese nur lesend zugreifen, nur innerhalb einer Transaktion. Wenn Ihre Datensätze also nicht den Weg in die Datenbank finden, sollten Sie zunächst überprüfen, ob Sie zunächst eine Transaktion begonnen und diese mit einem commit abgeschlossen haben. In Listing 45.5 wird die Transaktion in Zeile 020 begonnen und in Zeile 026 mit einem commit abgeschlossen.

Warnung

45.3.3 Anlegen eines neuen Datensatzes

Beginnen wir zunächst mit dem Anlegen eines neuen Datensatzes. Dies wurde in Listing 42.5 im JDBC-Kapitel mit Hilfe eines INSERT-Statements realisiert. Mit dem Java Persistenz API verwenden wir einfach den Konstruktor der Klasse Directory, um ein neues Java-Objekt zu erzeugen und speichern dieses mit Hilfe des EntityManager. Der Eintrag soll dabei den Verzeichnisnamen temp und die Id 0 bekommen, die wir natürlich über die Set-Methoden des Java-Objekts definieren.

001 /* Listing4506.java */ 002 003 import javax.persistence.*; 004 005 public class Listing4506 006 { 007 public static void main(String[] args) 008 { 009 //Erzeugen einer EntityManagerFactory mit Hilfe des symbolischen 010 //Namens aus dem Persistence 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 Directory dir = new Directory(); 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 }

Listing4506.java

Listing 45.6: Anlegen eines Datensatzes

Die Anweisungen von Zeile 023 bis Zeile 028 genügen, um einen neuen Datensatz in die Datenbank einzutragen. Zunächst erzeugen wir ein Java-Objekt über dessen Konstruktor und speichern dieses anschließend mit der Methode persist des EntityManager in der Datenbank. Wir benötigen für diese Operation kein Wissen über die im Hintergrund arbeitende Datenbank und müssen auch keinerlei SQL-Kommandos formulieren. Den Aufbau der Datenbankverbindung und die Formulierung eines passenden INSERT-Statements übernimmt das Persistenz API für uns.

45.3.4 Laden eines Datensatzes

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

001 /* Listing4507.java */ 002 003 import javax.persistence.*; 004 005 public class Listing4507 006 { 007 public static void main(String[] args) 008 { 009 //Erzeugen einer EntityManagerFactory mit Hilfe des symbolischen 010 //Namens aus dem Persistence 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 Directory-Objekts mit der Id=0 023 Directory dir = manager.find(Directory.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 }

Listing4507.java

Listing 45.7: Laden eines Datensatzes

Statt das Java-Objekt selbst zu erzeugen verwenden wir in Zeile 023 die Methode find des EntityManager, um den Datensatz aus der Datenbank zu laden. Diese Methode erhält als ersten Parameter die gesuchte Klasse und als zweiten Parameter die Id (0) des zu suchenden Datensatzes. Der EntityManager wird anschließend ein entsprechendes SELECT-Statement formulieren und versuchen, den Datensatz aus der Tabelle dir auszulesen. Findet er den gesuchten Datensatz, liefert er ihn als Instanz der Klasse Directory zurück, andernfalls ist der Rückgabewert null. In Abschnitt 45.5 lernen Sie eine Möglichkeit kennen, mit der Sie Datensätze nicht nur nach deren Id, sondern über beliebige Eigenschaften suchen können.

45.3.5 Löschen eines Datensatzes

Auch das Löschen eines Datensatzes ist mit Hilfe des Persistenz API kein Problem. Dies demonstrieren wir, indem wir Listing 45.7 erweitern und den gefundenen Datensatz mit Hilfe der Methode remove der Klasse EntityManager aus der Tabelle dir entfernen.

001 /* Listing4508.java */ 002 003 import javax.persistence.*; 004 005 public class Listing4508 006 { 007 public static void main(String[] args) 008 { 009 //Erzeugen einer EntityManagerFactory mit Hilfe des symbolischen 010 //Namens aus dem Persistence 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 Directory-Objekts mit der Id=0 023 Directory dir = manager.find(Directory.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 }

Listing4508.java

Listing 45.8: Löschen eines Datensatzes

Durch den Aufruf der Methode remove des EntityManager wird ein entsprechendes DELETE erzeugt und der Eintrag in der Tabelle dir gelöscht.