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 Javaklasse Directory geschrieben und mit Metainformationen ausgestattet ist und der Zugang zur Datenbank mit Hilfe des Persistenz Descriptors 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 Javaobjekten konzentrieren. Die Transformation der Javaoperationen auf ihre SQL-Pendants und zurück übernimmt die Persistenzschicht, auf die Sie mit Hilfe des EntityManager zugreifen können. Das folgende Listing demonstriert den Zugriff darauf:.

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 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 }

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 Persistenz Descriptors 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.

Der EntityManager und die EntityManagerFactory greifen auf die Datenbank zu und belegen dabei Ressourcen. Um diese zurückzugeben rufen wir am Ende eines Programms die Methode close auf, ganz ähnlich wie im JDBC-Kapitel gezeigt.

Warnung

45.3.2 Transaktionen mit dem EntityManager

Auch die in Abschnitt 42.4.3 vorgestellten Datenbank-Transaktionen lassen sich mit dem EntityManager leicht realisieren. Hierzu erzeugen wir eine EntityTransaction, starten diese mit der Methode begin und schließen sie mit der Methode commit ab oder setzen sie mit einem 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 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 }

Listing4505.java

Listing 45.5: Transaktionen im EntityManager

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. Hier verwenden wir einfach den Konstruktor der Klasse Directory, um ein neues Javaobjekt 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-Objektes 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 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 JavaObjektes 023 Directory dir = new Directory(); 024 dir.setDid(0); 025 dir.setDname("temp"); 026 027 //Speichern des JavaObjektes 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 einen 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. Wir erzeugen lediglich ein Javaobjekt und übergeben dieses der Methode persist des Entity Managers. Der Aufbau der Datenbankverbindung und die Formulierung eines passenden INSERT-Statements bleiben ganz unter dem »Deckmantel« des Persistenz API verborgen.

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 daraus 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 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 //Laden des Directory-Objektes mit der Id=0 019 Directory dir = manager.find(Directory.class, 0); 020 021 //Ausgabe des gefundenen Objektes 022 System.out.println(dir); 023 024 //Freigabe der Ressourcen des EntityManagers 025 manager.close(); 026 027 //Schließen der EntityManagerFactory und Freigeben der 028 //belegten Ressourcen 029 emf.close(); 030 } 031 }

Listing4507.java

Listing 45.7: Laden eines Datensatzes

Statt das Javaobjekt selbst zu erzeugen verwenden wir in Zeile 019 die Methode find des EntityManager, um den Datensatz aus der Datenbank zu laden. Diese Methode erhält als ersten Parameter die mit der zu durchsuchenden Tabelle verknüpfte Klasse und als zweiten Parameter die Id des zu suchenden Datensatzes. Der EntityManager wird damit ein entsprechendes SELECT-Statement formulieren und versuchen, die Daten aus der Tabelle dir auszulesen. Findet er den gewünschten Datensatz, liefert er ihn als Instanz der Klasse Directory zurück, anderenfalls ist der Rückgabewert null.

45.3.5 Löschen eines Datensatzes

Auch das Löschen eines Datensatzes ist mit Hilfe des Persistenz API kein Problem. Das 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 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 Directory-Objektes 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: Laden eines Datensatzes

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