Title: Objektrelationales Mapping in Datenbanksystemen - Einführung mit dem Hibernate Framework

Authors: Arabella Jackszis (Author); Melina Eleftheriadis (Author); Mareike Focken (Author); Thomas C. Rakow (Author)
Licence: CC BY-SA 4.0
Licence terms: Ausgenommen aus der Lizenz sind alle Logos.

Titel: ORM

Objektrelationales Mapping in Datenbanksystemen

Einführung mit dem Hibernate Framework

Objektrelationales Mapping in Datenbanksystemen - Eine Einführung mit Hibernate

Credits: by Arabella Jackszis (Author); Melina Eleftheriadis (Author); Mareike Focken (Author); licence CC BY-SA 4.0; Ausgenommen von der Lizenz sind alle Logos.

Autor*innen
Arabella Jackszis, Bachelorabeit SoSe 2019
Melina Eleftheriadis
Mareike Focken
Thomas C. Rakow

Unbenannt: Text

Bearbeitungszeit
ist individuell,
empfohlen: ca. 90 - 120 Minuten.

[Image: DH.nrw und MKW]

[Image: EILD.nrw OER for Databases]

[Image: HSD FBM]

Unbenannt: Text

Inhalte sind lizenziert unter CC BY SA 4.0

Unbenannt: Text

Ausgenommen aus der Lizenz sind alle Logos.

Lernziele

Nach der Bearbeitung des Lernprogramms...

... kennen Sie den Nutzen objektrelationaler Mapper,

... kennen Sie den Anwendungsbereich objektrelationaler Mapper,

... kennen Sie die Funktionsweise objektrelationaler Mapper,

... kennen Sie das Framework Hibernate,

... können Sie Hibernate in einfachen Programmen verwenden.

Voraussetzungen: Sie kennen die Konzepte der objektorientierten Programmierung und relationalen Datenverwaltung.

Motivation

Damit Sie eine Anwendung mit Datenpersistierung in einer objektorientierten Sprache entwickeln können, sollten Sie sowohl mit Objektorientierung als auch mit relationaler Datenverwaltung vertraut sein. Die objektorientierte Anwendung muss auf die relationale Datenbank abgebildet werden. Implementieren Sie Geschäftslogik z. B. in Java, werden für die Persistierung der Daten zusätzlich Tabellen und Afragen in SQL benötigt. Es ist natürlich möglich, beides selbst zu programmieren - erforderlich ist dafür das entsprechende Wissen und Zeit.

Der Einsatz von objektrelationalen Mappern bietet Erleichterung für Entwickler*innen: Bei der Programmierung muss die objektorientierte Welt nicht verlassen werden, denn die Abbildung der Anwendungslogik auf eine Datenbank wird auf Basis von Vorgaben automatisch generiert.

In diesem Tutorial lernen Sie, was objektrelationales Mapping ist, wie es funktioniert, und erhalten eine Einführung in das Framework Hibernate.

Viel Spaß!

Überblick

In diesem Tutorial werden folgende Fragen beantwortet:

1. Einführung: Wofür braucht man objektrelationale Mapper?
2. Funktionsweise: Was machen objektrelationale Mapper?
3. Anwendung: Wie verwende ich das Framework Hibernate?

Sie erhalten im ersten Abschnitt eine kurze Einführung in die Problematik, die durch objektrelationale Mapper gelöst wird. Im zweiten Abschnitt lernen Sie dann die Funktionsweise objektrelationaler Mapper kennen. Ein Framework, das das Mapping für Java-Anwendungen übernimmt, ist Hibernate. Im dritten Abschnitt lernen Sie Hibernate und dessen Verwendung kennen. In der Zusammenfassung am Ende können Sie Ihr Wissen überprüfen.

Also, los gehts!

Einführung: Wofür braucht man objektrelationale Mapper?

Funktionsweise: Was machen objektrelationale Mapper?

Anwendung: Wie verwende ich das Framework Hibernate?

1. Einführung

Einführung

Wofür braucht man objektrelationale Mapper?

Die Konzepte der objektorientierten Programmierung und der relationalen Datenverwaltung zu kennen ist eine notwendige Voraussetzung für das Verständnis objektrelationaler Mapper. Daher beginnen wir mit einer kurzen Wiederholung.

1.1 Objektorientierung: Test

1. Einführung

1. Einführung

Objektorientierung: Vorkenntnisse einschätzen

Wiederholung OOP1

Q: Was wird durch ein Objekt gekapselt?
- Alle Objekt-Daten (correct)
- Nur Methoden
- Nur Attribute
- Instanzen von Klassen

Q: Von wo aus darf auf private Variablen zugegriffen werden?
- Von Methoden aus, die innerhalb desselben Objekts definiert sind. (correct)
- Nur von der Main-Methode der Hauptklasse aus.
- Von überall aus.

Q: Wofür gibt es das Kapselungs-Prinzip?
- Um die Daten eines Objektes vor dem Zugriff von außen zu schützen. (correct)
- Um Daten schnell modifizieren zu können.
- Um Beziehungen zwischen Daten verschiedener Objekte herstellen zu können.

Q: Wie kann von außen auf Objektdaten zugegriffen werden, ohne die Kapselung zu durchbrechen?
- Gar nicht. Ein Objekt kann aber damit beauftragt werden, etwas mit den Daten zu tun. (correct)
- Mithilfe von get-Methoden.
- Es kann ohne Probleme auf die Daten zugegriffen werden.
- Gar nicht. Daten können weder abgefragt noch modifiziert werden.

Feedback (0 to 20%): Schauen Sie sich die objektorientierte Programmierung auf jeden Fall mal an, bevor Sie dieses Tutorial machen. Es ist wichtig, die Grundlagen zu verstehen, damit Sie sich mit objektrelationalen Mappern auseinandersetzen können.
Feedback (21 to 40%): Lesen Sie sich die folgende Folie genau durch und versuchen Sie, das Konzept zu verstehen. Es könnte Ihnen auch helfen, nochmal in die Unterlagen aus OOP1 zu schauen.
Feedback (41 to 60%): Ganz ok. Schauen Sie die folgende Folie noch einmal genau an, um das Konzept zu wiederholen.
Feedback (61 to 80%): Sehr gut. Überfliegen Sie die folgende Folie noch einmal, um sich an die letzten Details zu erinnern.
Feedback (81 to 100%): Perfekt! Sie können die folgende Folie überspringen, denn Sie kennen sich mit der objektorientierten Programmierung sehr gut aus.

1.1 Objektorientierung: Wiederholung

1. Einführung

1. Einführung

Objektorientierte Programmierung

Objekte sind Instanzen von Klassen. In OOP1 haben Sie das Kapselungsprinzip kennen gelernt. Dabei werden Daten innerhalb von Objekten gekapselt, um sie vor dem Zugriff von außen zu schützen.

Ein Zugriff auf die Objekt-Daten ist nur durch Methoden erlaubt, die innerhalb dieses Objekts definiert sind. Ein Objekt kann damit beauftragt werden, etwas mit den eigenen Daten zu tun. So erfolgt der Datenzugriff kontrolliert – Chaos und Fehler werden vermieden.

[Image: Objektorientierte Programmierung: UML-Klassendiagramm Person]

Klassen können auch von anderen Klassen erben: Die Eigenschaften (Variablen und Methoden) der Elternklasse werden übernommen. Vererbung ermöglicht Polymorphismus: den Einsatz von Methoden mit gleicher Signatur, die an die jeweiligen Objekte angepasste Ergebnisse liefern.

Im Schaubild erben die Klassen Dozent und Student von der Klasse Person. D. h. sie besitzen zusätzlich zu den eigenen Eigenschaften die Variablen name und adresse, sowie die Methode aendereAdresse().

1.2 Relationen: Test

1. Einführung

1. Einführung

Relationale Datenverwaltung: Vorkenntnisse einschätzen

Relationale Datenspeicherung

Q: Welche Aussage ist richtig?
- Relationale Datenbanken sind Sammlungen von Tabellen (Relationen). (correct)
- Ein kompletter Datensatz ist eine Spalte in der Tabelle.
- Ein anderer Begriff für Spalte ist Tupel.
- Ein anderer Begriff für Zeile ist Attribut.

Q: Wann sind Daten redundanzfrei?
- Wenn sie an nur einer Stelle in der Datenbank gespeichert sind. (correct)
- Wenn sie an mehreren Stellen in der Datenbank gespeichert sind.
- Wenn sie durch ein oder mehrere Backups gesichert sind.
- Wenn sie durch ein Backup gesichert sind.

Q: Ähnlich wie bei der objektorientierten Programmierung gibt es in relationalen Datenbanken ein Konzept für Vererbung.
- Falsch. (correct)
- Richtig.

Feedback (0 to 20%): Schauen Sie sich relationale Datenbanksysteme auf jeden Fall mal an, bevor Sie dieses Tutorial machen. Es ist wichtig, die Grundlagen zu verstehen, damit Sie sich mit objektrelationalen Mappern auseinandersetzen können.
Feedback (21 to 40%): Lesen Sie sich die folgende Folie genau durch und versuchen Sie, das Konzept zu verstehen. Es könnte Ihnen auch helfen, nochmal in die Unterlagen aus DBS1 anzuschauen.
Feedback (41 to 60%): Ganz ok. Schaue Sie sich die folgende Folie noch einmal genau an, um das Wichtigste zu wiederholen.
Feedback (61 to 80%): Sehr gut. Überfliegen Sie die folgende Folie noch einmal, um sich an die letzten Details zu erinnern.
Feedback (81 to 100%): Perfekt! Sie können die folgende Folie überspringen, denn Sie kennen sich mit relationalen Datenbanken sehr gut aus.

1.2 Relationen: Wiederholung

1. Einführung

1. Einführung

Relationale Datenverwaltung

Daten werden in tabellarischer Form abgelegt. Jede Spalte ist ein Attribut (z. B. Name). Eine Zeile enthält einen Datensatz und bildet ein Tupel.

Relationen können Beziehungen zueinander haben. Die Relation Seminare hat eine Beziehung zur Relation Dozenten. Diese Beziehung wird durch die Attribute DOZENT_ID hergestellt. Anstatt den Namen des Dozenten in die Relation Seminare zu schreiben, wird nur die ID referenziert. Die Daten müssen nur an einer Stelle gespeichert und geändert werden (Redundanzfreiheit). Werden Daten hingegen repliziert (anstatt referenziert) und sollen geändert werden, müssen Änderungen an allen Stellen vorgenommen werden.

[Image: Relationen]

1.3 Ausgangspunkt: 3-Schichten-Architektur

1. Einführung

1. Einführung

Unbenannt: Text

Ausgangspunkt: 3-Schichten-Architektur

[Image: 3 Schichten Architektur]

Um zu verstehen, wofür man objektrelationale Mapper braucht, sehen wir uns die Ausgangssituation und das zu lösende Problem an.

Die Funktionen einer Software sind in mehrere Schichten eingeteilt.

Das Schaubild rechts zeigt eine 3-Schichten-Architektur (Benutzungsoberfläche,  Fachkonzept und Datenhaltung) und wie die Daten innerhalb dieser Schichten behandelt werden.

1.3 Ausgangspunkt: Objekte vs. Relationen

1. Einführung

1. Einführung

Unbenannt: Text

Ausgangspunkt: Objekte vs. Relationen

[Image: 2 Konzepte]

In den verschiedenen Schichten werden die Daten auf unterschiedliche Art und Weise behandelt. Das Schaubild zeigt die Daten innerhalb der Geschäftslogik und der Datenhaltungsschicht.

Die Geschäftslogik arbeitet mit Objekten, die einen Zustand (Variablen) und ein Verhalten (Methoden) haben. In der Datenbank sind die Daten als Tupel in Relationen gespeichert.

1.4 Objekte vs. Relationen

1. Einführung

1. Einführung

Unbenannt: Text

Eigenschaften: Objekte vs. Relationen

Objekte und Relationen sollen innerhalb einer Software gemeinsam untergebracht werden. Die beiden Konzepte weisen jedoch grundlegende Unterschiede auf:

Unterschiede Objekte und Relationen

Eigenschaft | Objekte | Relationen
1. Identität | ist unabhängig vom Inhalt des Objekts | wird durch Daten bestimmt
2. Struktur | Daten (Variablen) und Verhalten (Methoden) | tabellarische Form, möglichst redundanzfrei
3. Zugriff | nur über Methoden, die Teil des Objekts sind | freier Zugriff durch Operatoren
4. Vererbung | vorhanden | nicht vorhanden

1.5 Problem: Impedance Mismatch

1. Einführung

1. Einführung

Unbenannt: Text

Problem: Impedance Mismatch

Aufgrund dieser Unterschiede zwischen Objekten und Relationen ist es nicht ohne zusätzliche Werkzeuge möglich, objektorientierte Programmiersprachen in Verbindung mit relationalen Daten zu verwenden.

[Image: Impedance Mismatch]

Unbenannt: Text

Objekte

Unbenannt: Text

Relationen

Dieser Bruch wird "Impedance Mismatch" genannt.

1.6 Lösung: ORM

1. Einführung

1. Einführung

Lösung: Objektrelationale Mapper (ORM)

Hier kommen objektrelationale Mapper (ORM) ins Spiel. Sie bilden die Objekte auf entsprechende Relationen ab.

Aufgrund dieses Datenmappings (Abbildung) ist die Software in sich klar strukturiert und dem Entwickler wird Programmieraufwand erspart. Daraus ergibt sich auch ein geringeres Fehlerpotential.

Neben objektrelationalen Mappern gibt es noch alternative Konzepte, wie zum Beispiel objekrelationales SQL oder objektorientierte Datenbankmanagementsysteme. In diesem Tutorial konzentrieren wir uns jedoch auf objektrelationale Mapper.

1.7 Zusammenfassung Einführung

1. Einführung

1. Einführung

Unbenannt: Text

Zusammenfassung Einführung

Wofür braucht man ORM?

Zusammenfassung: Wofür braucht man ORMs?

Fülle die Lücken mit den passenden Wörtern.

Q: Software besteht häufig aus drei verschiedenen Schichten. Die Benutzungsoberfläche sorgt für die Darstellung der Daten. Die Geschäftslogik (Fachkonzept) arbeitet mit Daten in Form von [...]. In der Datenbank (Datenhaltung) werden die Daten in [...] gespeichert.

Zwischen diesen beiden Konzepten gibt es einen Bruch, welcher als [...] bezeichnet wird. ORM lösen das Problem durch die [...] von Objekten auf entsprechende Relationen, auch bezeichnet als Datenmapping.
A: Objekten; Relationen/Tabellen; Impedance Mismatch; Abbildung

2. Funktionsweise

1. Einführung

1. Einführung | 2. Funktionsweise

Funktionsweise

Wie funktionieren objektrelationale Mapper?

In diesem Abschnitt lernen Sie das Konzept objektrelationaler Mapper kennen.

2.1 Übersetzungsarbeit

1. Einführung

1. Einführung | 2. Funktionsweise

2. Funktionsweise

Übersetzungsarbeit

Objektrelationale Mapper übersetzen objektorientierte Sprache in die relationale Welt. Sie bilden Klassen auf Relationen ab und stellen sicher, dass dabei die Beziehungen gewahrt werden. Das Beispiel im Schaubild zeigt die Abbildung der Klasse Kunde auf die Relation KUNDE.

Diese Übersetzungsarbeit kann von Frameworks übernommen werden. Für Java ist das Hibernate und für C# NHibernate oder das Entity Framework.

Das Mapping erspart dem Entwickler Zeit und Programmieraufwand, der entstehen würde, wenn das Datenmodell durch SQL-Skripte manuell implementiert werden müsste.

Unbenannt: Text

objektorientiert

[Image: Abbildung]

Unbenannt: Text

relational

2.2 Automatisierte Übersetzug

1. Einführung

1. Einführung | 2. Funktionsweise

2. Funktionsweise

Automatisierte Übersetzung

Die Übersetzungsarbeit wird durch Frameworks erleichtert, aber nicht komplett übernommen. Entwickler müssen folgende Informationen im Framework implementieren, damit die automatisierte Übersetzung ausgeführt werden kann:

Unbenannt: Text

1. Die Verbindungsdetails zur Datenbank müssen angegeben werden.
Das kann optional in einer Konfigurationsdatei passieren.
2. Für abzubildende Klassen müssen Mapping-Informationen angegeben werden.
In Hibernate kann das pro Klasse per Annotation erfolgen, oder alternativ in einer XML-Datei.
3. Das Framework muss die zu mappenden Klassen kennen.
In Hibernate kann das durch einen Eintrag der annotierten Klassen in der Konfigurationsdatei (hibernate.cfg.xml) erfolgen, oder alternativ über den Aufruf von API-Methoden.

→ Daraufhin erstellt das Framework die entsprechenden SQL-Befehle automatisch.

2. Zusammenfassung Funktionsweise

1. Einführung

1. Einführung | 2. Funktionsweise

2. Funktionsweise

Unbenannt: Text

Zusammenfassung Funktionsweise

Was machen objektrelationale Mapper?

Zusammenfassung Funktionsweise

Q: Welche Informationen müssen Entwickler im ORM-Framework implementieren?
- Verbindungsdetails zur Datenbank. (correct) (Richtig! Die Angabe der Verbindungsdetails zur Datenbank ist notwendig, da sie die Speicherung der automatisiert erstellten Relationen in der Datenbank ermöglicht. Die Verbindungsdetails können z. B. in der Konfigurationsdatei angegeben werden.) (if not chosen: Wie stellen Sie eine Verbindung zur Datenbank her? Die Angabe der Verbindungsdetails zur Datenbank ist notwendig, da sie die Speicherung der automatisiert erstellten Relationen in der Datenbank ermöglicht. Die Verbindungsdetails können z. B. in der Konfigurationsdatei angegeben werden.)
- Annotationen zur Markierung von Klassen, die auf Relationen abgebildet werden sollen. (correct) (Richtig! Die Annotationen müssen implementiert werden. Sie enthalten die notwendigen Informationen für die Abbildung auf Relationen, damit die automatische Übersetzung durch das Framework ausgeführt werden kann.) (if not chosen: Die Annotationen müssen implementiert werden. Sie enthalten die notwendigen Informationen für die Abbildung auf Relationen, damit die automatische Übersetzung durch das Framework ausgeführt werden kann.)
- Annotationen zur Markierung von Datenbankverbindungen in der Konfigurationsdatei. (Leider nicht korrekt! Annotationen an Klassen ermöglichen das Mapping der Objekte mit den zu erstellenden Relationen. Die Verbindung zur Datenbank, in der die Relationen gespeichert werden sollen, kann in der Konfigurationsdatei angegeben werden.) (if not chosen: Annotationen an Klassen ermöglichen das Mapping der Objekte mit den zu erstellenden Relationen. Die Verbindung zur Datenbank, in der die Relationen gespeichert werden sollen, kann in der Konfigurationsdatei angegeben werden.)
- Ein SQL-Skript für die Übersetzung von objektorientierter Sprache in das relationale Datenmodell. (Leider nicht korrekt. Es ist möglich, ein Skript für die Übersetzung zu schreiben, aber es ist nicht notwendig: Die mit Annotationen markierten Klassen werden durch das Framework automatisch in das relationale Datenmodell übersetzt.) (if not chosen: Es ist möglich, ein Skript für die Übersetzung zu schreiben, aber es ist nicht notwendig: Die mit Annotationen markierten Klassen werden durch das Framework automatisch in das relationale Datenmodell übersetzt.)

3. Hibernate

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate

2. Funktionsweise

Hibernate

 Wie verwende ich Hibernate?

In diesem Abschnitt lernen Sie die Verwendung von Annotationen zur einfachen Abbildung von Klassen auf Relationen und zur Realisierung von Vererbungsbeziehungen kennen, und Sie werden in die Abfragesprache HQL eingeführt.

3. Hibernate Einführung

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate

2. Funktionsweise

2. Funktionsweise

Hibernate

Hibernate ist ein Framework für Objektrelationales Mapping (ORM). Es erleichtert die Programmierung von Anwendungen, die Persistenz erreichen sollen: Die Daten sind über den Anwendungsprozess hinaus verfügbar. Hibernate implementiert die Java Persistence API, ist also ein JPA Provider, und arbeitet mit einfachen Klassen in Java, sogenannten POJOs (Plain Old Java Objects). Jede Klasse oder Datenstruktur kann ohne den Einsatz von Interfaces oder Basisklassen persistent gemacht werden.

In die Java-Klassen werden JPA-Annotationen eingefügt, um zu steuern, welche Daten mit welcher Strategie in der Datenbank persistiert werden. Soll eine Änderung am Datenmodell vorgenommen werden, muss also lediglich die entsprechende Klasse geändert werden – die Abbildung auf Relationen in der Datenbank übernimmt Hibernate.

In einer Konfigurationsdatei können abzubildende Klassen eingetragen und weitere Einstellungen vorgenommen werden.

Auf den folgenden Folien lernen Sie die wichtigsten Annotationen kennen und es wird erklärt, wie der Zugriff auf die Datenbank erfolgt.

3.1 Hibernate - Annotationen

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Annotationen

2. Funktionsweise

2. Funktionsweise

Annotationen

Die Annotationen werden direkt in der Java-Klasse eingefügt. Sie sagen Hibernate, wie das Mapping erfolgen soll.

Sehr häufig werden die folgenden Annotationen verwendet:

@Entity
@Table
@Id
@Column

Diese und außerdem die @Temporal Annotation werden auf den folgenden Folien vorgestellt. Es gibt viele weitere Annotationen, die Sie in der vollständigen Dokumentation finden.

Wie Beziehungen und Vererbungen markiert werden müssen, folgt im Anschluss.

3.1.1 Simple Annotationen: @Entity

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Annotationen

2. Funktionsweise

2. Funktionsweise

Simple Annotationen: @Entity

Unbenannt: Text

Entitäten ( = Entitätsklassen) haben die Eigenschaft, Objekte in einer Datenbank repräsentieren zu können. Eine Entität wird typischerweise auf eine Tabelle abgebildet, und Instanzen einer Entität entsprechen einer Zeile in dieser Tabelle.

Unbenannt: Text

Entitäten unterstützen Klassenvererbung und Polymorphismus. Sie können:

- Entitätsklassen und Nicht-Entitätsklassen erweitern
- von Entitätsklassen und Nicht-Entitätsklassen erweitert werden
- abstrakt oder konkret sein

@Entity

- spezifiziert die annotierte Klasse als Entität, die auf eine Relation abgebildet wird

Unbenannt: Text

@Entity
public class Kunde { //... }

Unbenannt: Text

Die mit @Entity annotierte Klasse Kunde wird auf eine Relation "Kunde" abgebildet.

3.1.1 Simple Annotationen: @Table

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Annotationen

2. Funktionsweise

2. Funktionsweise

Simple Annotationen: @Table

@Table

- optional
- wird verwendet, um Eigenschaften der Tabelle festzulegen, sofern sie sich von den Default-Werten unterscheiden sollen

Unbenannt: Text

Im Codebeispiel wird durch @Table(name="CUSTOMER") der Name der Relation als "CUSTOMER" festgelegt. Der Default ohne Attribut-Angabe wäre der Name der Klasse: "Kunde".

Unbenannt: Text

@Entity
@Table(name="CUSTOMER")
public class Kunde { //... }

Unbenannt: Text

Die mit @Entity annotierte Klasse Kunde wird auf eine Relation CUSTOMER abgebildet.

3.1.1 Simple Annotationen: @Id, @Column

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Annotationen

2. Funktionsweise

2. Funktionsweise

Simple Annotationen: @Id, @Column

sddfg

@Id

- markiert den Primärschlüssel
- optional: automatische Inkrementierung mittels @GeneratedValue und @GenericGenerator (siehe Beispiel)

@Column

- optional
- wird verwendet, um Eigenschaften der Spalte festzulegen, sofern sie sich von den Default-Werten unterscheiden sollen.

Unbenannt: Text

Im Codebeispiel wird durch @Column(name="KUNDE_ID") der Name der Spalte in der Relation als "KUNDE_ID" festgelegt. Der Default ohne Attribut-Angabe wäre der Name der Instanzvariable: "id".

Unbenannt: Text

@Id
@GeneratedValue(generator="increment")
@GenericGenerator(name="increment", strategy="increment")
@Column(name="KUNDE_ID")
private int id;

3.1.1 Simple Annotationen: @Temporal

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Annotationen

2. Funktionsweise

2. Funktionsweise

Simple Annotation: @Temporal

sddfg

Unbenannt: Text

@Temporal

- muss für Variablen vom Datentyp Date oder Calendar verwendet werden

Unbenannt: Text

@Temporal(TemporalType.TIMESTAMP)
private Date date;

3.1.1 Simple Annotationen: Beziehungen

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Annotationen

2. Funktionsweise

2. Funktionsweise

Beziehungen

Für die Umsetzung von Beziehungen gibt es drei Annotationen. In einigen Fällen müssen zusätzliche Relationen erstellt werden, die nicht als Klasse vorhanden sind, um Beziehungen angemessen abbilden zu können,

Für die One-To-One Beziehung (1:1) mit der Annotation @OneToOne wird ein zusätzlicher Fremdschlüssel erstellt.

Bei der One-To-Many Beziehung (1:n, bzw. n:1) mit den Annotationen @OneToMany bzw. @ManyToOne gibt es zwei Umsetzungsmöglichkeiten: Entweder erhält die Einer-Relation einen zusätzlichen Fremdschlüssel, oder es wird eine Zuordnungsrelation erstellt. Diese beinhaltet dann die IDs beider Relationen.

Auch bei Many-To-Many Beziehungen (n:n), die mit der Annotation @ManyToMany markiert werden, wird eine Zuordnungsrelation erstellt. Um die Relationen miteinander zu verbinden und im Zuge dessen die Zuordnungsrelation zu erstellen, wird die Annotation @JoinTable verwendet:

Unbenannt: Text

@ManyToMany
@JoinTable(
        name="<Name der Zuordnungstabelle>",
        joinColumns={@JoinColumn(name="<Attributname>", nullable=false, updatable=false)},
        inverseJoinColumns={@JoinColumn(name="<Attributname>",nullable=false,updatable=false)})

3.1.1 Zusammenfassung Simple Annotationen

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Annotationen

2. Funktionsweise

2. Funktionsweise

Unbenannt: Text

Zusammenfassung Simple Annotationen

Hibernate Annotationen Test

Q: Welche der folgenden Annotationen markiert den Primärschlüssel?
- @Id (correct)
- @Key
- @Primary

Q: Mit welcher Annotation legt man fest, dass eine bestimmte Klasse auf eine Relation abgebildet werden soll?
- @Entity (correct)
- @Table
- @Temporal

Q: Es gibt drei Annotationen für die Umsetzung von Beziehungen. Welche davon gibt es NICHT?
- One-To-All (correct)
- Many-To-Many
- One-To-Many

Q: Welche der folgenden @Temporal Annotationen gibt es nicht?
- @Temporal(TemporalType.SECOND) (correct)
- @Temporal(TemporalType.TIMESTAMP)
- @Temporal(TemporalType.DATE)
- @Temporal(TemporalType.TIME)

Feedback (0 to 25%): Vielleicht sollten Sie das Kapitel nochmal anschauen.
Feedback (26 to 50%): Nicht schlecht... aber da ist noch Luft nach oben.
Feedback (51 to 75%): Sie haben das Thema schon grob verstanden. Beschäftigen Sie sich aber noch mit den Feinheiten.
Feedback (76 to 100%): Meisterleistung!

3.1.2 Vererbung - Einführung

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Unbenannt: Text

Vererbung

Unbenannt: Text

objektorientiert

Da es in relationalen Datenbanken kein äquivalentes Prinzip zur Vererbung in der Objektorientierung gibt, müssen hier Umwege gegangen werden. Dafür gibt es verschiedene Strategien, die jeweils ihre Vor- und Nachteile haben.

Fall 1: Die Elternklasse soll abgebildet werden (annotiert mit @Entity).
Durch Hinzufügen der Annotation @Inheritance wird festgelegt, dass diese Klasse außerdem ihre Eigenschaften vererben soll.

Fall 2: Die Elternklasse soll nicht abgebildet werden (ohne @Entity-Annotation).
Durch Hinzufügen der Annotation @MappedSuperclass wird festgelegt, dass diese Klasse nur ihre Eigenschaften vererben soll.

[Image: Vererbungshierarchie objektorientiert]

3.1.2 Mapping Strategien für Entitätsklassen

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Unbenannt: Text

Mapping Strategien für Vererbung

Fall 1: Die Elternklasse soll abgebildet werden (@Entity)

Die Annotation @Inheritance legt fest, dass die persistente Entitätsklasse ihre Eigenschaften vererben soll. Um zu steuern, mit welcher Strategie die Vererbung umgesetzt werden soll, kann der Annotation das Attribut strategy hinzugefügt werden.

[Image: Vererbungshierarchie]

Unbenannt: Text

@Entity
@Inheritance(strategy = InheritanceType.<MAPPING-STRATEGIE>)
public class Klasse { //... }

Unbenannt: Text

Es gibt drei Mapping Strategien: SINGLE_TABLE, TABLE_PER_CLASS und JOINED. Sie werden auf den folgenden Folien vorgestellt. Dazu wird gezeigt, wie die Vererbungshierarchie der Beispiel-Abbildung in der Datenbank aussehen würde.

3.1.2 Mapping Strategie - Single Table

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Mapping Strategie: Single Table per Class Hierarchy

Die "Single Table" Strategie entspricht der Virtuellen Fragmentierung. Es wird nur eine Relation in der Datenbank erstellt, die alle Attribute der Vererbungshierarchie enthält. Zusätzlich gibt es ein Attribut zur Unterscheidung zwischen Dozent und Student, im Default mit dem Namen DTYPE.

Datenzugriffe sind hier schnell abgearbeitet, da nur eine Relation abgefragt werden muss.

Die Abfragelogik wird bei vielen NULL-Werten komplexer. In der Instanz einer Klasse erhalten Attribute anderer Klassen den Wert NULL. Wenn in unserem Beispiel ein Student abgespeichert werden soll, besitzen die Attribute PERSONALNR und BUERO den Wert NULL.

@Inheritance(strategy = InheritanceType.SINGLE_TABLE)

Unbenannt: Text

objektorientiert

[Image: Vererbung Single Table Strategie]

Unbenannt: Text

Strategie:    Single-Table

Unbenannt: Text

Wenn kein Strategy-Attribut angegeben wird, wird SINGLE_TABLE als Default-Strategie der Inheritance-Annotation angewendet:

@Inheritance

Unbenannt: Text

relational

3.1.2 Mapping Strategie - Single Table

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Single Table Diskriminator

Unbenannt: Text

Wenn Inhalte aus mehreren Tabellen mit der Single-Table-Strategie in einer Tabelle vereint werden, kann man sie durch ein sogenanntes Diskriminator-Attribut unterscheiden. Am Wert des Attributs kann man ablesen, aus welcher Tabelle der Datensatz stammt.

Unbenannt: Text

@DiscriminatorColum

- optional
- wird verwendet, um Eigenschaften des Diskriminator-Attributs festzulegen, sofern sie sich von den Default-Werten unterscheiden sollen.

Unbenannt: Text

Der Default-Name des Diskriminator-Attributs ist "DTYPE" und die Namen der Kindklassen werden als Default-Werte verwendet.

Unbenannt: Text

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(discriminatorType = DiscriminatorType.String, name = "TYPE")
public class Person { // ... }

Unbenannt: Text

Der Relation Person wird durch @DiscriminatorColumn ein Diskriminator-Attribut namens "TYPE" mit dem Datentyp "String" hinzugefügt.

3.1.2 Mapping Strategie - Single Table - DiscriminatorValue

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

DiscriminatorValue

sddfg

Verfügt die Elternklasse über ein Diskriminator-Attribut, wird diesem Attribut in den Kindklassen ein Wert zugewiesen. Dazu wird die Annotation @DiscriminatorValue verwendet.

@Entity
@DiscriminatorValue("D")
public class Dozent extends Person {
     // ...
}

@Entity
@DiscriminatorValue("S")
public class Student extends Person {
     // ...
}

Unbenannt: Text

Instanzen der Klassen Dozent bekommen den Eintrag "D" und Instanzen der Klassen Student erhalten den Eintrag "S" im Diskriminator-Attribut der Tabelle Person. So können Dozenten und Studenten in der Tabelle Person unterschieden werden.

3.1.2 Mapping Strategie - Table per class

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Unbenannt: Text

Mapping Strategie: Table per Concrete Class

Beim Mapping mit der Strategie "Table per Concrete Class" (kurz: "Table per Class") handelt es sich um eine vertikale Abbildung ohne Fragmentierung der Objekte. Es werden alle konkreten Klassen auf jeweils eine Relation abgebildet. Die Relationen der Kindklassen erhalten zusätzlich zu den Kindklassen-Attributen auch die Attribute der Elternklasse.

Dieses Verfahren ist sehr performant.

Ein Nachteil sind jedoch die Duplizierung der Attribute (hier NAME und ADRESSE). Bei einer Modifikation an den Attributen der Elternklasse müsste jede Relation, die zu dieser Vererbungs Hierarchie gehört, auch modifiziert werden.

@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)

Unbenannt: Text

objektorientiert

[Image: Table per Class Vererbung]

Unbenannt: Text

Strategie:    Table per Class

Unbenannt: Text

relational

3.1.2 Mapping Strategie - Table per Class Codebeispiel

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Codebeispiel "Table per Class"

@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
@Entity
public class Person{
  @Id
  @GeneratedValue
  @Column(name="PERSON_ID")
  private int id;
  private String name;
  private String adresse; // ...
}

[Image: Relation PERSON]

Unbenannt: Text

Abbildung der Klasse Person auf Relation PERSON mit den Attributen der Klasse Person.

@Entity
@Table (name="DOZENT")
public class Dozent extends Person{
   private int personal_nr;
   private int buero; // ...
}

@Entity
@Table (name="STUDENT")
public class Student extends Person{
   private int matrikel_nr;
   // ...
}

[Image: Relation STUDENT]

[Image: Relation DOZENT]

Unbenannt: Text

Abbildung der Klasse Dozent auf Relation DOZENT mit den Attributen der Elternklasse Person und den Attributen der Klasse Dozent

Unbenannt: Text

Abbildung der Klasse Student auf Relation STUDENT mit den Attributen der Elternklasse Person und den Attributen der Klasse Student

3.1.2 Mapping Strategie - Joined

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

1. Einführung

2. Funktionsweise

2. Funktionsweise

Mapping Strategie: Joined Subclass

Beim Mapping mit der Strategie "Joined" handelt es sich um Vertikale Fragmentierung. Jede Klasse – auch die Elternklasse – wird auf eine Relation abgebildet. Die Vererbung wird durch Schlüssel-Fremdschlüssel-Beziehungen umgesetzt.

Diese Strategie ist vorteilhaft, wenn an den Objektdaten häufig Änderungen vorgenommen werden müssen, denn die Struktur der Vererbung wird beibehalten.

Das verschlechtert jedoch auch die Performance, da immer auf mehrere Relationen zugegriffen werden muss, um einen Datensatz abzufragen. Performanceprobleme treten verstärkt auf, wenn die Vererbungshierarchie zu umfangreich ist.

Unbenannt: Text

objektorientiert

[Image: Joined Tables Vererbung]

Unbenannt: Text

Strategie:      Joined

Unbenannt: Text

@Inheritance(strategy = InheritanceType.JOINED)

Unbenannt: Text

relational

3.1.2 Vererbung - Abstrakte Klassen

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Vererbung: Abstrake Klassen

Die drei vorgestellten Mapping Strategien "Single-Table", "Table-per-Class" und "Joined" können auch auf abstrakte Entitäsklassen angewendet werden. Sie können nicht instanziiert werden, haben jedoch alle Eigenschaften einer Entität und werden persistiert. Die Abbildung auf Relationen erfolgt wie zuvor beschrieben.

[Image: 3 Schichten Architektur]

Unbenannt: Text

?

Unbenannt: Text

- Bei "Single Table" und "Joined" enthält die Relation der (abstrakten) Elternklasse Einträge für die Instanzen der konkreten Kindklassen.
- Bei "Table-per-Conrete-Class" werden nur konkrete Klassen abgebildet. Sie enthalten alle Einträge für die Instanzen der konkreten Kindklassen. In diesem Tutorial gehen wir nicht auf die Details ein, wie Hibernate in diesem Fall intern die Abbildung der abstrakten Klasse umsetzt.

Unbenannt: Text

Benötigt man jedoch keine Abbildung der Elternklasse (abstrakt oder konkret), eignet sich die Mapping Strategie @MappedSuperclass besser.

3.1.2 Mapping Strategie - MappedSuperclass

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Fall 2: Klassen, die nicht abgebildet werden

Mit der Annotation @MappedSuperclass wird horizontale Fragmentierung umgesetzt. Diese Klasse soll nur ihre Eigenschaften vererben und wird nicht persistiert: sie wird nicht auf eine Relation abgebildet.

Eine Klasse muss beispielsweise dann nicht abgebildet werden, wenn die Eigenschaften von Entitätsklassen (z.B. polymorphe Abfragen) nicht benötigt werden.

Kindklassen werden mit den geerbten Attributen jeweils auf eine Relation abgebildet, sofern sie mit @Entity annotiert sind.

- Eine Klasse kann entweder mit @MappedSuperclass oder mit @Entity annotiert werden. Eine Kombination ist nicht möglich.

Unbenannt: Text

objektorientiert

[Image: Abstrakte Klasse: Table per Class Vererbungsstrategie]

Unbenannt: Text

Strategie:    MappedSuperclass

Unbenannt: Text

relational

3.1.2 Mapping Strategie - MappedSuperclass

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Codebeispiel "MappedSuperclass"

@MappedSuperclass
abstract class Person{
  @Id
  @GeneratedValue
  @Column(name="PERSON_ID")
  private int id;
  private String name;
  private String adresse; // ...
}

Unbenannt: Text

Die abstrakte Klasse Person wird nicht auf eine Relation abgebildet. Sie vererbt nur ihre Attribute:

@Entity
@Table (name="STUDENT")
public class Student extends Person{
   private int matrikel_nr;
   // ...
}

@Entity
@Table (name="DOZENT")
public class Dozent extends Person{
   private int personal_nr;
   private int buero; // ...
}

[Image: Relation STUDENT]

[Image: Relation DOZENT]

Unbenannt: Text

Abbildung der Klasse Dozent auf Relation DOZENT mit den Attributen der abstrakten Elternklasse Person und den Attributen der Klasse Dozent

Unbenannt: Text

Abbildung der Klasse Student auf Relation STUDENT mit den Attributen der abstrakten Elternklasse Person und den Attributen der Klasse Student

3.1.2 Mapping Strategien Überblick 1

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung Abstrakte Klassen

2. Funktionsweise

2. Funktionsweise

Mapping Strategien Überblick 1

Unbenannt: Text

Die Annotation der Elternklasse mit @Entity ermöglicht die Abbildung der Klasse, und @Inheritance ermöglicht Vererbung mit den folgenden Mapping Strategien:

Unbenannt: Tabelle

Vererbungsstrategie | Abbildung der Klassen | Abbildung der Attribute
Single Table | Abbildung aller Klassen auf insgesamt eine Relation | Die erstellte Relation enthält die Attribute der Eltern- und aller Kindklassen. Es werden Attribute zur Unterscheidung von Instanzen der Kindklassen hinzugefügt.
Table per Class | Abbildung aller konkreten Klassen auf jeweils eine Relation | Jede erstellte Relation enthält die Attribute der abgebildeten Klassen. Relationen der Kindklassen enthalten außerdem die Attribute der Elternklasse.
Joined | Abbildung aller Klassen auf jeweils eine Relation | Jede erstellte Relation enthält nur die Attribute der abgebildeten Klasse. Die Verbindung zur Elternklasse wird durch eine Schlüssel-Fremdschlüssel-Beziehung realisiert.

3.1.2 Mapping Strategien Überblick 2

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Mapping Strategien Überblick 2

Unbenannt: Text

Die folgende Mapping Strategie ermöglicht Vererbung von Klassen, die nicht abgebildet werden (ohne @Entity Annotation):

Unbenannt: Tabelle

Vererbungsstrategie | Abbildung der Klassen | Abbildung der Attribute
MappedSuperclass | Die Elternklasse wird nicht auf eine Relation abgebildet. | Die Elternklasse vererbt ihre Attribute an die Kindklassen. Kindklassen, die mit @Entity annotiert sind, werden auf eine Relation abgebildet, die die Attribute der Eltern-Klasse enthält.

3.1.2 Zusammenfassung Vererbung

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: Vererbung

2. Funktionsweise

2. Funktionsweise

Zusammenfassung Vererbung

Vererbungen-Test

Ziehe die Wörter in die richtigen Felder!

Q: In relationalen Datenbanken gibt es kein äquivalentes Prinzip zur Vererbung. Für die Darstellung einer Vererbungsbeziehung von Entitätsklassen benutzt man die Annotation [...] in Kombination mit einer von drei verschiedenen Mapping Strategien. Bei der Strategie [...] wird nur eine Relation in der Datenbank erstellt. Möchte man häufig Änderungen an den Objektdaten vornehmen, eignet sich am besten die Strategie [...]. Bei der Strategie [...] werden alle konkreten Klassen auf jeweils eine Relation abgebildet. [...] wird für nicht-persistente Elternklassen verwendet.
A: @Inheritance; SINGLE_TABLE; JOINED; TABLE_PER_CLASS; @MappedSuperclass
Feedback (0 to 50%): Eine kleine Wiederholung wäre gut.
Feedback (51 to 75%): Übung macht den Meister...
Feedback (76 to 100%): Super! Auf geht's zum nächsten Kapitel.

3.2 Datenabfrage & -modifikation

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate

2. Funktionsweise

2. Funktionsweise

Abfrage & Modifikation von Daten

Hibernate stellt Methoden bereit, die den Zugriff auf die Daten ermöglichen. Auf den folgenden Folien werden die folgenden Elemente mit Beispielen erklärt. Nutzen Sie auch die Links zur Hibernate Dokumentation.

1. Hibernate Query Language:
  - Als Abfragesprache verwendet Hibernate HQL: Hibernate Query Language.
  - Queries können selbst mit HQL erstellt werden oder werden von Hibernate automatisch erstellt.
2. Sessions: Für Abfragen und Manipulationen von Daten verwendet Hibernate Sessions.
3. Transaktionen: Für die Manipulation ist außerdem eine Transaktion nötig.
4. Cache: Die Zwischenspeicherung von Daten erhöht die Performanz der Anwendung.

3.2.1 HQL

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: HQL

2. Funktionsweise

2. Funktionsweise

Hibernate Query Language (HQL)

- HQL ist eine Abfragesprache, welche die objektorientierte Programmierung mit einer relationalen Datenbank verbindet.
- HQL basiert auf SQL.
Beispiel im Kontext der Klasse "Kunden": Die SQL-Abfrage "SELECT * FROM KUNDEN;" entspricht der HQL-Abfrage "FROM KUNDEN"
- HQL Abfragen werden von Hibernate in SQL-Abfragen übersetzt. Diese führen dann Aktionen in der Datenbank aus.

3.2.1 HQL

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: HQL

2. Funktionsweise

2. Funktionsweise

HQL Eigenschaften

- HQL ist objektorientiert und die Leistung ist gut, wenn wir unsere Front-End-Anwendung mit dem Backend verknüpfen.
- HQL verfügt über einen Cachespeicher und verbessert dadurch die Geschwindigkeit.
- HQL unterstützt Funktionen von OOP-Konzepten wie Vererbung, Polymorphismus und Assoziation.
- HQL unterscheidet zwischen Groß- und Kleinschreibung, z. B. bei Tabellennamen.

3.2.2 Session

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate

2. Funktionsweise

2. Funktionsweise

Sessions

Für eine reine Datenabfrage oder die Manipulation von Daten muss eine Session geöffnet werden. Dazu sollte es in der Software eine SessionFactory geben, die diese Session bereitstellt.

Eine SessionFactory wird folgendermaßen bereitgestellt:

Unbenannt: Text

Configuration configuration = new Configuration().configure();
ServiceRegistry serviceRegistry =
                              new StandardServiceRegistryBuilder()
                                   .applySettings(configuration.getProperties())
                                   .build();
sessionFactory = configuration.buildSessionFactory(serviceRegistry);

Unbenannt: Text

Über diese Factory kann eine Session für Abfragen und Transaktionen geöffnet werden.

3.2.2 Session - Datenabfrage

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate: HQL

2. Funktionsweise

2. Funktionsweise

Datenabfrage

Unbenannt: Text

Für eine Datenabfrage wird in der Session ein Query-Objekt in HQL erstellt und das Ergebnis ausgelesen.

Beispiel für eine FROM Abfrage

Session session = sessionFactory.openSession();
String hql = "FROM Person";
Query query = session.createQuery(hql);
List results = query.list();
session.close();

Unbenannt: Text

1. Die Session wird geöffnet.
2. Die Abfrage wird als String in HQL-Syntax erstellt.
3. Das Query-Objekt wird mit der Methode createQuery der Session-Instanz erstellt.
4. Das Ergebnis der Abfrage wird ausgelesen.
5. Die Session wird geschlossen.

Beispiel für eine SELECT Abfrage mit einer Bedingung:

Session session = sessionFactory.openSession();
String hql = "SELECT name FROM Student WHERE matrikelNr = 12345";
Query query = session.createQuery(hql);
List results = query.list();
session.close();

3.4 Transaktionen - Datenmanipulation

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate

2. Funktionsweise

2. Funktionsweise

Transaktionen

Unbenannt: Text

Sollen schreibende Vorgänge ausgeführt werden (Speichern, Modifizieren, Löschen), ist eine Transaktion erforderlich. Die dafür nötige Abfrage wird von Hibernate automatisch generiert. Der Beispiel-Code zeigt, wie eine neuer Kunde in der Datenbank gespeichert wird:

Unbenannt: Text

Session session = sessionFactory.openSession();
session.beginTransaction();
session.saveOrUpdate(new Kunde("Erika Musterfrau"));
session.getTransacction().commit();
session.close();

Unbenannt: Text

1. Die Session wird über die SessionFactory geöffnet.
2. Die Transaktion wird gestartet.
3. Die Operation wird ausgeführt (im Beispiel mit der Methode saveOrUpdate der Sessioninstanz).
4. Die Transaktion wird geschlossen und die Daten persistiert.
5. Die Session wird geschlossen.

3.5 Cache

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate

2. Funktionsweise

2. Funktionsweise

Cache

Um bei oft verwendeten oder sich ändernden Daten nicht jedes Mal auf die Datenbank zugreifen zu müssen, schreibt Hibernate diese zunächst in einen Cache. Bei der nächsten Abfrage dieses Datums muss also nur auf den Cache zugegriffen werden, was deutlich schneller ist.

Aus diesem Grund ist es jedoch wichtig, die Daten am Ende mit der Datenbank zu synchronisieren. Das erfolgt durch das Schließen der Session und der Transaktion:

session.close();
session.getTransaction().commit();

Außerdem ist es empfehlenswert mit einem try-catch-Block Fehler abzufangen. Über die Methode rollback() können diese rückgängig gemacht werden:

session.getTransaction().rollback();

3.6 Vorteile ORMs

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate

2. Funktionsweise

2. Funktionsweise

ORM: Vorteile

Sie sehen: Dem Entwickler wird viel Arbeit erspart. Um einen neuen Datensatz in der Datenbank zu speichern, ohne Hibernate zu nutzen, müsste der Entwickler eine Verbindung zur Datenbank aufbauen und den SQL-String manuell erstellen. Dabei können auch schnell Fehler gemacht werden, da die Attributnamen als String vom Compiler nicht überprüft werden. Bei einem Rechtschreibfehler würde das Programm abstürzen.

Verwendet man allerdings Hibernate, reicht es, eine Instanz der Klasse zu erstellen, die Variablen zu übergeben und innerhalb einer Transaktion die saveOrUpdate-Methode aufzurufen. Die Erstellung des SQL-Befehls erledigt Hibernate.

Auf der anderen Seite wirkt sich die automatische Generierung der SQL-Befehle negativ auf die Performance aus. Oft werden Daten abgefragt, die eigentlich nicht benötigt werden – besonders bei einer großen Menge an Daten kann das sehr lange dauern. In diesem Fall könnte man darüber nachdenken, die SQL-Befehle doch selbst zu schreiben oder Einstellungen in der Konfiguration anzupassen. Das kommt aber immer auf die konkrete Software an.

4 Zusammenfassung

2. Funktionsweise

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate

2. Funktionsweise

Zusammenfassung

Frage 1: Wofür braucht man objektrelationale Mapper?

Sie lösen den Impedance Mismatch - den Bruch zwischen Objekten und Relationen.

Frage 2: Was machen objektrelationale Mapper?

Sie bilden Objekte auf Relationen ab und erleichtern den Umgang mit der Datenbank.

Frage 3: Wie verwende ich Hibernate?

In den Klassen werden Annotationen eingefügt, die das Mapping genau definieren. Darüber hinaus können damit Beziehungen zwischen zwei Klassen hergestellt und die Mapping Strategie für die Abbildung der Vererbung ausgewählt werden.

sddfg

4.1 Karteikarten Annotationen

1. Einführung | 2. Funktionsweise | 3. Hibernate

1. Einführung

2. Funktionsweise

2. Funktionsweise

Unbenannt: Text

Lernkarten Annotationen

Unbenannt: Text

Zum Abschluss noch einpaar hilfreiche Lernkarten. Diese können Ihnen bei der Einschätzung helfen, wie gut Sie das Thema verstanden haben. Wenn Sie sich sicher fühlen, können Sie den Test am Ende des Kapitels wahrscheinlich problemlos bestehen.

Hibernate Annotations

Überlegen Sie sich die Antwort, drehen Die Karte um, und markieren, ob die Antwort richtig war.
Eine Karte gilt als gelernt, wenn sie 2x richtig beantwortet wurde.

Q: @Entity

Wofür wird diese Annotation verwendet?
A: Mit @Entity wird eine Klasse als Entität spezifiziert und auf eine Relation in der Datenbank abgebildet.

Q: @Table

Wofür wird diese Annotation verwendet?
A: Möglichkeit, um Eigenschaften der Relation festzulegen (z. B. den Namen)

Q: @Column

Wofür wird diese Annotation verwendet?
A: Möglichkeit, um Eigenschaften des Attributs festzulegen

Q: @Id

Wofür wird diese Annotation verwendet?

Wie sollte automatische Inkrementierung implementiert werden?
A: @Id markiert einen Primärschlüssel,

bei automatischer Inkrementierung sollte der GenericGenerator verwendet werden.

Q: @ManyToMany

Wofür wird diese Annotation verwendet?

Welche ähnlichen Annotationen gibt es noch?
A: Bildet eine Many-To-Many-Beziehung ab.

Außerdem gibt es noch @OneToOne, @ManyToOne und @OneToMany

Q: @Inheritance

Wofür wird diese Annotation verwendet?
A: Hiermit wird eine Vererbungshierarchie für Entitätsklassen (@Entity) abgebildet. Als Parameter kann die Mapping Strategie übergeben werden.

Q: @Temporal

Wofür wird diese Annotation verwendet?
A: Diese Annotation muss verwendet werden, wenn man Variablen vom Datentyp Date oder Calendar verwendet.

Q: Was sind die Vor- und Nachteile der SINGLE_TABLE Strategie?
A: Vorteile: Der Zugriff auf die Datenbank wird sehr schnell abgearbeitet, danur eine Relation abgearbeitet werden muss.

Nachteile:  Bei vielen NULL-Werten wird die Abfragelogik komplexer.

Q: Was passiert bei der TABLE_PER_CLASS Strategie?

Was sind die Vor- und Nachteile?
A: Alle konkreten Klassen werden auf eine eigene Tabelle abgebildet.
  Kindlassen enthalten zusätzlich zu ihren eigenen auch alle Eltern-Attribute.

Vorteil: Das Verfahren ist perfomant.

Nachteil: Ändern sich Attribute von der Elternklasse, muss jede Relation, die eine Vererbungsbeziehung zu dieser hat, auch modifiziert werden, da es sich um Duplikate der Attribute handelt.

Q: Welche drei Mapping-Strategien gibt es für die Vererbung von Entitätsklassen?
A: 1. SINGLE_TABLE

2. TABLE_PER_CLASS

3. JOINED

Q: @MappedSuperclass

Wofür wird diese Annotation verwendet?
A: Die Klasse ist keine Entität und vererbt nur ihre Eigenschaften an Kindklassen. Sie wird nicht auf eine Relation in der Datenbank abgebildet.

4.2 Zusammenfassung Test

1. Einführung

1. Einführung | 2. Funktionsweise | 3. Hibernate

2. Funktionsweise

2. Funktionsweise

Zusammenfassung

Zur Wiederholung gibt es noch eine kleine Selbstüberprüfung. Sie haben die Einführung bestanden, wenn Sie  80% der Fragen richtig beantwortet haben.

Zusammenfassung

Q: Welche Funktion haben objektrelationale Mapper in der 3-Schichten-Architektur?
- Sie verbinden das Fachkonzept mit der Datenhaltung. (correct)
- Sie verbinden die Benutzungsoberfläche mit dem Fachkonzept.
- Sie verbinden die Benutzungsoberfläche mit der Datenhaltung.
- Sie verbinden alle drei Schichten miteinander.

Q: Objektrelationale Mapper bilden Objekte auf Relationen ab, um ...
- ... den Bruch zwischen den beiden Konzepten zu überbrücken. (correct)
- ... die Menge an Code zu reduzieren.
- ... die Datenabfrage zu beschleunigen.

Q: In Hibernate wird das Mapping z. B. durch Annotationen vorgenommen. Was muss zusätzlich getan werden, damit die Abbildung funktionieren kann?
- Die Klassen müssen Hibernate bekannt gemacht werden, z. B. in der Konfigurationsdatei. (correct)
- Der Cache muss manuell erzeugt werden.
- Eine Session muss geöffnet werden.
- Eine Transaktion muss gestartet werden.

Q: Wo werden Annotationen eingefügt?
- An Instanzvariablen der Klassen. (correct)
- In der Konfigurationsdatei.
- An Methoden der Klassen.
- In der Main-Methode.

Q: Für die Vererbung bei Entitätsklassen gibt es drei verschiedene Mapping Strategien. Welche davon ist die langsamste?
- Joined (correct)
- Single Table
- Table per Class

Q: Bei welcher der drei folgenden Mapping Strategien gibt es potenziell viele NULL-Werte?
- Single Table (correct)
- Table per Class
- Joined

Q: Welche der drei folgenden Mapping Strategien ist am besten für Datenmodelle geeignet, die sich häufig ändern?
- Joined (correct)
- Single Table
- Table per Class

Q: Für welchen Zweck muss eine Transaktion geöffnet werden?
- Um Daten in der Datenbank zu modifizieren oder zu speichern. (correct)
- Um Daten aus der Datenbank abzufragen.
- Um den Cache mit der Datenbank zu synchronisieren.

Q: Welche Aufgabe übernimmt der Cache?
- Er beschleunigt Datenabfragen für die Daten, die vorher schon einmal abgefragt wurden. (correct)
- Er entlastet die Datenbank, indem er einen Teil der Daten persistent speichert.
- Er speichert die Mapping Informationen, die über die Annotationen angegeben wurden.

Q: Wofür steht HQL?
- Hibernate Query Language (correct)
- Hypertext Query Language
- Hardware Query Language

Q: Man möchte alle Eigenschaften aus der Tabelle "Firma" mithilfe von HQL ausgeben lassen.

Wählen Sie den korrekten Code aus:
- String hql = "FROM Firma"; Query query = session.createQuery(hql); List results = query.list(); (correct)
- String hql = "SELECT personalId FROM Firma"; Query query = session.createQuery(hql); List results = query.list();
- String hql = "SELECT * FROM Firma"; Query query = session.createQuery(sql); List results = query.list();

Feedback (0 to 20%): Bevor Sie mit dem Praktikum starten, sollten Sie sich dieses Tutorial noch genauer ansehen und das Wichtigste mithilfe von Fachliteratur wiederholen.
Feedback (21 to 40%): Sehen Sie sich am besten nochmal das Tutorial an, bevor Sie mit dem Praktikum beginnen.
Feedback (41 to 60%): Das war ganz ok. Überfliegen Sie die wichtigsten Folien insbesondere die Zusammenfassungen am Ende der Kapitel noch einmal.
Feedback (61 to 80%): Gut! Wenn Sie Ihre Fehler noch einmal ansehen, sind Sie bestens auf das Praktikum vorbereitet.
Feedback (81 to 100%): Sehr gut! Jetzt können Sie mit den Praktikumsaufgaben beginnen.

Ende

Das war's! Jetzt sind Sie gut auf das nächste Praktikum vorbereitet. Es wird darum gehen, im vorgegebenen Code die richtigen Annotationen einzufügen und Daten aus der Datenbank abzufragen und zu ändern.

Viel Spaß dabei!