Unsere Datenschutzrichtlinie wird in Kürze aktualisiert. Bitte sehen Sie sich die Vorschau an.

Java 7 Grundkurs

JPA praktisch

Testen Sie unsere 2016 Kurse

10 Tage kostenlos!

Jetzt testen Alle Abonnements anzeigen
In diesem umfangreichen, praktischen Beispiel vermittelt der Autor, aufbauend zum vorhergehenden Video, wie Sie diese Zugriffe praktisch umsetzen - Datenbank, Persistence Provider und Entities eingeschlossen.
16:16

Transkript

Das Java Persistence API ermöglicht es, Java-Objekte mit Hilfe eines Entity-Managers in eine Datenbank hineinzuschreiben und auch wieder daraus herauszuholen. Um das Ganze praktisch umzusetzen, brauchen wir natürlich zuerst einmal ein Datenbanksystem. Ich verwende hier die Java DB, auch unter dem Namen "Derby" bekannt. Zum einen, weil sie seit Java 6 beim JDK dabei ist, und zum zweiten, weil sie so nett integriert ist. Als Nächstes benötigen wir einen JDBC-Treiber, um aus Java heraus auf die Datenbank zugreifen zu können. Einen solchen Treiber gibt es im Prinzip für jedes Datenbanksystem und er kümmert sich um die Details der Kommunikation mit dem Datenbanksystem. Nach oben stellt er dann eine einheitliche Schnittstelle zur Verfügung, die unabhängig davon ist, welche Datenbank ich darunter verwende. Damit nun der EntityManager unsere Java-Objekte tatsächlich auf die Datenbanktabellen abbilden kann, müssen noch zwei weitere Voraussetzungen erfüllt sein: Zuerst einmal müssen wir unsere Java-Objekte als "Entities" markieren, damit der EntityManager mit ihnen klar kommt. Das machen wir mit der Annotation "@Entity" direkt an unsere Java-Klasse. Außerdem muss der EntityManager in der Lage sein, die einzelnen Instanzen unserer Entity-Klasse voneinander zu unterscheiden. Auch das Datenbanksystem benötigt eine Möglichkeit, die einzelnen Einträge in einer Tabelle auseinanderhalten zu können. Was wir brauchen, ist also eine eindeutige ID, im Datenbankbereich auch Primärschlüssel genannt. Um dem EntityManager mitzuteilen, welches der vielen Attribute unserer Klasse denn nun der Primärschlüssel ist, setzen wir auch da eine Annotation davor, nämlich "@ID". Nachdem wir nun unsere Entity-Klassen entsprechend markiert haben, müssen wir dem EntityManager noch sagen, wie er an die Datenbank herankommen soll. Er muss also wissen, auf welchem Server sich die Datenbank befindet und wie die Zugangsdaten lauten. Diese Konfigurationsinformationen packen wir in eine XML-Datei mit dem Namen "Persistence.xml". Außerdem müssen wir dort noch reinschreiben, welche Entity-Klassen in diese Datenbank sollen, denn prinzipiell wäre es ja möglich, dass eine Anwendung auf mehrere Datenbanken zugreifen muss und dass einige der Entities in die eine Datenbank kommen und einige in die andere. Diese Informationen kommen, wie gesagt, in diese XML-Datei hinein. Beginnen wir unser kleines Beispiel mit dem Anlegen der Datenbank. Dazu klicke ich hier im NetBeans oben links auf das dritte Tab, "Services". Sollte bei Ihnen ein solche Tab nicht vorhanden sein, dann können Sie es über "Window" - "Services" erreichen. Der erste Punkt heißt "Databases", den klappen wir einmal auf. Dort steht bereits Java DB drin. Wenn Sie mit der rechten Maustaste auf "Java DB" klicken, und auf "Properties", dann können Sie auch sehen, wo Java DB hin installiert wurde. Wie Sie sehen können, ist es bei mir tatsächlich beim JDK dabeigewesen. Sollte bei Ihnen hier gar nichts drinstehen, dann haben Sie vermutlich noch kein Java DB oder Derby auf Ihrem Rechner. In diesem Fall können Sie sich unter "db.apache.org" eine herunterladen. Sie bekommen dann ein ZIP-File, das können Sie entpacken und dann können Sie NetBeans hier in diesem Dialog sagen, wo Sie es hin entpackt haben. Außerdem benötigt Derby noch ein Verzeichnis, in dem es seine Datenbankdateien ablegen kann. Standardmäßig ist das hier das Verzeichnis ".netbeansderby", und das lasse ich auch einmal so. Okay, legen wir uns also eine Datenbank an. Rechte Maustaste auf "Java DB" - "Create database". Als Datenbankname verwenden wir einfach einmal den Namen "Beispiel", Benutzername und Passwort können Sie prinzipiell frei wählen, ich nehme hier einmal "Demo" und "Demo", "OK". Derby startet und die Datenbank wird angelegt. Da ist sie schon. Wir können jetzt zur Datenbank verbinden, indem wir hier mit der rechten Maustaste daraufklicken und auf "Connect". Dann ist es nicht mehr hier so unterbrochen. Jetzt können wir hier aufklappen und können uns die Tabellen anschauen. Wir haben natürlich noch keine Tabellen angelegt, das hier sind alles nur Systemtabellen. Später werden hier dann aber Tabellen erscheinen. Nun können wir uns ein Java-Projekt anlegen. Also wieder auf das "Projects"-Tab und hier oben "Pfeil", "New Project" auswählen. Eine Java-Anwendung, und wir nennen sie "JPA Demo". Nun können wir unsere Entity-Klassen anlegen. Da JPA nicht Teil der Java-Standardbibliothek ist, enthält die Standardbibliothek auch keinen PersistenceProvider. Wir müssen unserem Projekt also die entsprechenden Bibliotheken zusätzlich hinzufügen. Das macht NetBeans aber quasi im Vorbeigehen, wenn wir die Entity-Klasse anlegen, genau so wie die Erzeugung der "Persistence.xml". Erstellen wir uns also unsere Entity-Klasse. Ich klicke hier mit der rechten Maustaste darauf, dann sage ich "New". Ich könnte jetzt ganz normal "Java-Class" auswählen, denn solche Entities sind ja ganz normale Java-Klassen. Dann würde aber der eben erwähnte Automatismus nicht greifen. Deshalb wähle ich stattdessen hier unten "Entity-Class". Wenn es bei Ihnen hier nicht drinstehen sollte, dann klicken Sie auf "Other" und dann wählen Sie hier aus der Kategorie "Persistence" auf der rechten Seite "Entity-Class". Wenn ich jetzt auf "Next" drücke, dann bin ich an der gleichen Stelle, als hätte ich hier oben links rechte Maustaste, "New" - "Entity-Class" gesagt. Jetzt brauchen wir einen Namen für unsere Klasse. Machen wir das so wie in der Grafik, nennen wir die Klasse "Person". Einen Paketnamen müssen wir ebenfalls angeben, sonst kommen wir hier gar nicht weiter, also "com.video2brain.java7.jpademo". Als Primärschlüsseltyp steht hier "Long", das können wir so lassen. Wichtig ist, dass hier unten das Häkchen gesetzt ist, "Create persistence unit", damit wird nämlich die XML-Datei erzeugt. Drücken wir auf "Next". Jetzt müssen wir für die Persistenzeinheit einen Namen angeben. NetBeans schlägt hier standardmäßig vor "Projektname" und "PU" hintendran, also "Persistence Unit", das können wir so lassen. Jetzt müssen wir noch auswählen, welchen PersistenceProvider  wir nehmen möchten. EclipseLink ist die Referenzimplementierung für einen JPA2, wir könnten aber auch andere verwenden, Hibernate z. B. oder TopLink. Wir bleiben einfach einmal bei der Standardeinstellung EclipseLink. Schließlich müssen wir noch auswählen, auf welche Datenbank zugegriffen werden soll, da wählen wir unsere "Beispiel"-Datenbank. Nun gibt es hier unten noch eine lustige Einstellung, die "Table generation strategy" bei "Create" verwendet der PersistenceProvider die vorhandenen Tabellen und legt dann neue an, wenn ihm noch welche fehlen. "Drop and create" legt ebenfalls fehlende Tabellen automatisch an, löscht aber alle Tabellen bei einem Neuverbinden. Das ist z. B. für Testzwecke recht hilfreich. Für den produktiven Einsatz sind beide Einstellungen aber nicht so gut geeignet, da wählen wir normalerweise "Non". Da wir momentan noch gar keine Tabellen haben, wählen wir "Create" und dann wird die benötigte Tabelle automatisch angelegt. Jetzt können wir auf "Finish" drücken, und dann wird das Bestellte geliefert. Jetzt wurden zwei Dateien generiert, nämlich die Entity-Klasse, die wir uns gleich noch anschauen, und die Datei "Persistence.xml". Für diese Datei hat NetBeans hier einen passenden Editor. Wir können die Datei aber auch direkt im XML angucken. Klicke ich hier oben auf "XML", und dann sieht sie so aus. Hier wird also die Persistenzeinheit definiert, die "JPA Demo PU" heißt. Dann wird hier festgelegt, dass wir EclipseLink benutzen möchten und dass die Klasse "Person" in diese Persistenzeinheit hineingespeichert werden soll. Nun kommen die Zugangsdaten für die Datenbank, also die URL zur Datenbank, Passwort, Benutzername, der Treiber, das ist der Derby-Treiber, und hier unten wird die "Table generation strategy" eingestellt, nämlich auf "Create". Sie könnten die Datei natürlich auch prinzipiell selbst tippen, aber so ist es ja viel bequemer. So, hier ändern wir jetzt nichts mehr, können wir also wieder zumachen. Jetzt schauen wir uns noch die generierte Entity-Klasse an, die Klasse heißt "Person", ist ein Entity. Hier haben wir den Primärschlüssel, der heißt "ID", und da steht auch "@ID" daran. Jetzt kommt hier noch eine Annotation, und die heißt "@GeneratedValue", und als "Strategy" ist hier "GenerationType.Auto" eingestellt. Das heißt auf Deutsch nichts anderes, als dass sich das Datenbanksystem bitte möglichst selbst um die Vergabe dieser IDs kümmern soll, damit wir das nicht machen müssen. Zusätzlich zum Generieren dieser beiden Dateien wurde noch eine Änderung am Projekt vorgenommen: Hier bei "Libraries", also Bibliotheken, wenn wir das einmal aufklappen, sehen wir nämlich, dass jetzt die EclipseLink-Bibliotheken bereits zum Projekt dazugehören. Das ist unser PersistenceProvider, und da holen wir uns nachher auch den EntityManager her. Was hier allerdings noch fehlt, ist der JDBC-Treiber. Den müssen wir manuell hinzufügen. Das machen wir einmal. Rechte Maustaste auf "Libraries" und dann "Add JAR" - "Folder" und jetzt navigieren Sie dorthin, wo Ihre Java DB hininstalliert ist. Wenn Sie es selbst installiert haben, dann müssen Sie den entsprechenden Pfad wählen, wenn Sie das zum Java dazugelieferte nehmen, dann müssen Sie halt zum Java-Installationspfad navigieren. Standardmäßig ist das Folgende: "C:/Programme/Java/JDK17/DB/Lib". Hier wählen Sie nun "derbyclient.jar" aus und klicken auf "Öffnen". Damit ist alles vorbereitet, jetzt können wir auf die Datenbank zugreifen. Bauen wir uns also eine Klasse mit einer Mengenmethode. "New" - "Java-Class", nenne sie "JPA Demo", "Finish". Und hier brauchen wir eine "Name", also "psvm", Tab. Für den Zugriff auf die Datenbank brauchen wir einen EntityManager. Den können wir uns aber nicht einfach selbst bauen, sondern den müssen wir uns von einer EntityManagerFactory holen. Bauen wir uns also zuerst eine solche. "EntityManagerFactory", da haben wir es, aus dem Paket "javax.persistence", nennen wir sie "EMF". Wir bekommen die über eine statische Methode in der Klasse "Persistence", und die Methode heißt "CreateEntityManagerFactory". Als Parameter möchte diese Methode gerne den Namen der Persistenzeinheit haben, so wie es in der "persistence.xml" drinsteht. Schauen wir also zur Sicherheit noch einmal rein. Hier steht es: "Persistence Unit Name", das ist er. Am besten "Kopieren" und "Einfügen", natürlich in Anführungszeichen. So, Semikolon. Nun haben wir die Factory, jetzt können wir uns den EntityManager holen. Ich nenne ihn "EM", und den kriegen wir von der Factory über die Methode "CreateEntityManager". Jetzt brauchen wir noch ein Objekt, das wir in die Datenbank werfen können. Das wäre dann also eine Instanz unserer Klasse "Person". In "Person" ist bis jetzt aber noch nicht wirklich etwas darin, außer der ID. Also fügen wir hier noch ein Attribut hinzu, machen wir es einfach, nennen wir es einfach "Name" und für diesen Namen brauchen wir noch die passenden Getter und Setter, können wir uns generieren lassen, drücken wir Alt+Einfügen. Dann kriegen wir so ein Mini-Menü und da haben wir hier "Getter and Setter", auswählen, ein Häkchen bei "Name" und "Generate". Schon haben wir einen Get- und einen Set-Name. Bauen wir uns also eine Person: "Person p = new Person" und geben ihr einen Namen. Set "Name auswählen", z. B. "Klaus". Damit kommen wir zum eigentlichen In-die-Datenbank-Schreiben. Schreibvorgänge können nur innerhalb einer laufenden Transaktion durchgeführt werden, und für die Erzeugung dieser sind wir selbst verantwortlich. Das geht aber recht einfach. Wir gehen einfach zum EntityManager,  rufen die Methode "Get transaction" auf und dann bekommen wir eine Transaktion zurück, von der können wir dann Beginn aufrufen. Jetzt läuft die Transaktion, und wir können jetzt, ich mache es hier unten einmal zu, wir können jetzt im EntityManager unser Personenobjekt übergeben und danach die Transaktion beenden, "getTransaction().commit()". Damit ist der Vorgang abgeschlossen, wir müssen EntityManager noch schließen, mit "Close", und auch die Factory möchte noch geschlossen werden. Üblicherweise holt man sich für die gesamte Java-Anwendung nur einmal eine Factory, aus dieser dann aber regelmäßig neue EntityManager. Jetzt können wir die Anwendung ausführen, indem wir hier auf den grünen Knopf drücken. Wir sehen jetzt hier unten ein paar Statusmeldungen. Ich mache das einmal größer. EclipseLink meldet sich, ist hochgefahren, dann steht hier: "Login successful", das heißt, die Persistenzeinheit konnte erfolgreich geöffnet werden. Und hier steht dann: "Logout successful", das ist die Stelle, an der wir dann "Close" aufgerufen haben. Machen wir es wieder kleiner. Unser Klaus ist also vermutlich in die Datenbank geschrieben worden. Schauen wir einmal nach. Gehen wir hier auf "Services", hier haben wir die Datenbank. Dann drücken wir einmal auf die rechte Maustaste und dann hier "Refresh", dann sollte hier ein neues Schema "Demo" auftauchen. Aufklappen, da haben wir die "Tables", klappen wir auch auf und jetzt gibt es hier die Table "Personen", mit der rechten Maustaste und dem "View data" können wir in die Tabelle hineinschauen und dann sehen wir hier tatsächlich mit der ID1 steht hier Klaus drin. Um den Klaus auszulesen aus der Datenbank, sieht das Ganze fast genau so aus, nur dass wir hier halt kein Objekt erzeugen selbst, und dass wir zum Lesen auch keine Transaktion benötigen. Deshalb kommentiere ich diesen Teil hier einmal aus. Es bleibt also nur die Erzeugung des EntityManagers, bzw. das Holen von der Factory und das Schließen des EntityManagers. Dazwischen kommt jetzt eine Zeile, nämlich "Person p = em.find" mit "Find" können wir ein Objekt finden in der Datenbank. "Find" möchte gerne zwei Parameter haben, der erste ist der Typ, das wäre also in unserem Fall "Person", da schreiben wir hier in "Person.class" das ist der Typ, der zurückgegeben werden soll, sonst würden wir einfach nur "Object" kriegen und dann müssten wir zu Fuß casten, das ist immer recht hässlich. Als zweiten Parameter müssen wir jetzt die ID angeben, den Primärschlüssel. Das war im Prinzip eine 1. Ich sage "im Prinzip", denn es war kein "Int", sondern ein "Long". Also müssen wir hier "1L" hinschreiben. Das Autoboxing macht daraus dann ein Long-Objekt und dieses Long-Objekt wird dann als ID verwendet. Dann geben wir die Person noch aus, um zu sehen, ob es auch geklappt hat. "getName" sollte reichen. Und wir sehen, hier steht ein bisschen Logtext, und dann kommt hier aber unser Text "Person", "Klaus". Damit haben Sie nun gesehen, wie Sie mit JPA auf Datenbanken zugreifen können. Sie brauchen dazu eine Datenbank, z. B. Derby, einen Persistenzprovider, z. B. EclipseLink, und dann brauchen Sie Entities wie unsere Person. Für den Zugriff auf die Datenbank holen Sie sich von der EntityManagerFactory einen EntityManager und über dessen Methoden können Sie dann Objekte in die Datenbank hineingeben oder herausholen.

Java 7 Grundkurs

Machen Sie sich mit den Grundlagen der Java-Programmierung vertraut und lernen Sie die Syntax der Sprache sowie das Konzept der objektorientierten Softwareentwicklung kennen.

8 Std. 32 min (66 Videos)
Derzeit sind keine Feedbacks vorhanden...
 
Hersteller:
Software:
Exklusiv für Abo-Kunden
Ihr(e) Trainer:
ISBN-Nummer:978-3-8273-6149-3
Erscheinungsdatum:28.11.2011
Laufzeit:8 Std. 32 min (66 Videos)

Dieser Online-Kurs ist als Download und als Streaming-Video verfügbar. Die gute Nachricht: Sie müssen sich nicht entscheiden - sobald Sie das Training erwerben, erhalten Sie Zugang zu beiden Optionen!

Der Download ermöglicht Ihnen die Offline-Nutzung des Trainings und bietet die Vorteile einer benutzerfreundlichen Abspielumgebung. Wenn Sie an verschiedenen Computern arbeiten, oder nicht den ganzen Kurs auf einmal herunterladen möchten, loggen Sie sich auf dieser Seite ein, um alle Videos des Trainings als Streaming-Video anzusehen.

Wir hoffen, dass Sie viel Freude und Erfolg mit diesem Video-Training haben werden. Falls Sie irgendwelche Fragen haben, zögern Sie nicht uns zu kontaktieren!