Kapitel 6 - Anbindung

Kapitel 6
Dr. Brigitte Mathiak
Anbindung an Anwendungen
WeST – Web Science & Technologies
Lernziele

• Das grundsätzlichen Problem bei der Kopplung von
objektorientierten Programmiersprachen mit relationalen
Datenbanken kennenzulernen
• Konzepte zur Anbindung von Datenbanken an Applikationen
• Selbst einfache Datenbankanbindungen programmieren zu
können
• Die grundlegende Funktionsweise von Persistenz
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
2
Impedance Mismatch zwischen OO und RM
Ein Objekt wird definiert durch:
• Identität
• Zustand
• Verhalten
• Kapselung
Eine Relation enthält Aussagen mit dem Wahrheitswert TRUE.
Beispielsweise: Es gibt einen PROFESSOR namens Sokrates,
dieser hat den RANG C4 und arbeitet im RAUM 226.
Beides ist nicht trivial kompatibel. Warum?
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
3
Impedance Mismatch zwischen OO und RM (2)

Struktur:
• Dieses Problem haben wir bereits in Kapitel 3 kennengelernt,
um von UML ins Relationenmodell zu kommen
• RM hat keine Vererbung, kein Verhalten, keine 1-zu-n oder gar
n-zu-n Beziehungen
Identität:
• Tupel haben von sich aus keine eindeutige Identität.
Datenkapselung:
• Objekte können selbst bestimmen wie sie verändert werden
Arbeitsweise:
• Relationen arbeiten global transaktionsbasiert
• Objekte sind untereinander vernetzt
Ergebnismenge:
• SQL-Anfragen liefern (Multi-)Mengen, keine Objekte
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
4
Die gute Nachricht

Alle diese Probleme sind im Einzelfall lösbar.
Die schlechte Nachricht
Entweder man muss Einschränkungen bei den Objekten
hinnehmen, die persistent sein sollen, oder es wird sehr
kompliziert und/oder unperformant.
(Oder man nimmt eine nicht-relationale Datenbank.)
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
5
Die einfache Lösung: Datenbanktreiber
http://www.jeckle.de/images/ebe/JDBCdrivers.gif
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen

6
Aus Programmierersicht
Software zur Verbindung mit
einem speziellen RDBMS (z.B. Oracle)
Driver
registriert sich
DriverManager
Verwaltet die geladenen Treiber
erstellt
Connection
Die Verbindung zur Datenbank
überträgt
Statement
Ein SQL-Statement
liefert
ResultSet
Das Ergebnis des Statements
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
7

Aus Programmierersicht
Driver
registriert sich
DriverManager
erstellt
Connection
überträgt
Class.forName (Drivername);
Connection con =
DriverManager.getConnection(
DBurl, user, password);
Statement st =
con.createStatement();
Statement
liefert
ResultSet
ResultSet results =
st.executeQuery(query);
st.close();
con.close();
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
8
Auslesen von Resultaten

String query = “SELECT PersNr, Name
FROM Professoren WHERE Rang= 'C4';”;
ResultSet results = st.executeQuery(query);
while (results.next()) {
int persNr = results.getInt(1);
String name = results.getString(2);
workWith(persNr,name);
}
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
9
Nachteile von Treibern
• Kein Syntax-Check des SQL-Statements
• Es kann nicht über Statement-Grenzen hinweg optimiert
werden. (Tatsächlich gibt es die Möglichkeit per PreparedStatement ein
Statement wiederzuverwenden, was sehr äußerst positiv auf die
Performance auswirkt. )
• Es werden keine Objekte abgespeichert, sondern nur
simple Types
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
10
Spracheinbettung (z.B. SQLJ)
• Beispiel:
#sql [ctx] { SELECT MAX(SALARY), AVG(SALARY) INTO
:maxSalary, :avgSalary FROM DSN8710.EMP };
• Spracheinbettungen und 4GL-Sprachen bieten eine bessere
Integration, weil das SQL direkt im Quellcode steht
• Ein Präprozessor übersetzt die eingebettete Befehle und fängt
damit auch Syntax-Fehler ab
• Weiterer Vorteil: Variablen können besser eingesetzt werden
Hauptnachteil:
• Sehr geringe Unterstützung von anderen Produkten, da
Spracheinbettungen als altmodisch gelten
• Die Sprache selbst wird verändert, dies kann
• zu Inkompatibilitäten mit anderen Präprozessoren führen
• Debugging deutlich schwieriger machen
Fazit: Nicht mehr state-of-the-art
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
11
Persistenzframeworks
• Grundidee: Transparente Persistenz von Objekten durch
Mapping zwischen Objekten und Relationen
• Vorgehen: Der Zustand einfacher Java Objekte (POJOs) wird
vom Framework in der Datenbank festgehalten
• Vorteil: Der Programmierer kann mit den Objekten normal
arbeiten
• Weiterer Vorteil: Das Mapping ist nicht mehr implizit in der
Geschäftslogik „versteckt“, sondern wird explizit angegeben
• Netter Nebeneffekt: Die Aufteilung in Domänenklassen, die
persistiert werden, und in andere Klassen entspricht dem MVCProgrammierparadigma
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
12
Persistenzframeworks (Beispiel Hibernate)

• Das Modell wird in Domänenklassen
festgehalten (EJBs)
• Der Zugriff auf die EJBs erfolgt von
Applikationsseite aus über DAOs
(Data Access Objects) zur Entkopplung
• Hibernate selbst greift auf die
Domänenklassen per Reflection zu
• Das Mapping zwischen Objekten und
Datenbank wird durch XML-Dateien
festgelegt (oder Annotations)
• Der Zugriff auf die Datenbank geschieht per JDBC
• Die Konfiguration sowohl des Datenbankzugriffs als auch des
Verhaltens von Hibernate wird zentral verwaltet
http://www.hibernate.org/hib_docs/v3/reference/en/html/architecture.html
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
13
Persistenzframeworks (Beispiel Hibernate; Domänenklasse)

Professoren
• Beispiel einer Domänenklasse:
PersNr
Name
Rang
Raum
2125
Sokrates
C4
226
2126
Russel
C4
232
// Markiert die Klasse als persistierbar
@Entity
// Der Default Tabellenname wäre PROFESSOR
@Table ( name = “Professoren“)
public class Professor {
@Id @GeneratedValue
Long PersNr; // Jede Klasse sollte eine ID haben
String Name;
String Rang;
Long Raum;
// leerer public Konstruktur ist notwendig für Entities
public Professoren(){};
/* getter und setter … */
}
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
14

Persistenzframeworks (Beispiel Hibernate; DAO)
Professoren
• Beispiel eines DAOs:
•
Hinweis:
getHibernateTemplate() kommt aus DAO
PersNr
Name
Rang
Raum
2125
Sokrates
C4
226
2126
Russel
C4
232
public class ProfessorDAOHibernate extends DAO
implements ProfessorDAO{
public void saveProfessor(Professor toSave){
getHibernateTemplate().saveOrUpdate(toSave);
}
public Professor getProfessorByPersNr(int PersNr){
return (Professor) getHibernateTemplate().
get(Professor.class, PersNr);
}
public void deleteProfessor(Professor toDelete){
getHibernateTemplate().delete(toDelete);
}
}
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
15
Persistenzframeworks (Beispiel Hibernate; weiterführend)

• Komplexe Anfragen können sowohl über die Hibernate eigene
Anfragesprache HQL als auch SQL gemacht werden
• Es werden mehrere Methoden angeboten 1-zu-n und n-zu-n
Beziehungen in der Datenbank darzustellen
• Sowohl andere Objekte als auch Collections werden als Attribute
akzeptiert
• Allerdings muss ein Mapping explizit angegeben werden
• Es gibt viele Tools, die den Einstieg in Hibernate erleichtern
und viele der benötigten Dateien automatisch generieren
• Domänenklassen können aus der Datenbank erzeugt werden
• Standard DAOs können generiert werden
• Das Datenbankschema kann aus den Domänenklassen generiert
werden
• Etc.
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
16
Nachteile Persistenzframeworks
• Relativ großer Overhead für kleine Projekte
• Kein direkter Zugriff auf die Datenbank
• Alles muss in Objekten gespeichert werden
Vorteile Persistenzframeworks
• Weniger Quellcode in der Persistenzschicht (-> weniger Fehler)
• Viele Konfigurationsoptionen um z.B. die Performanz zu
optimieren
• Hervorragende Umsetzung von loser Kopplung zwischen den
Komponenten Modell und Persistenz
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
17
Fazit
• Es gibt verschiedene Möglichkeiten Anwendungen an eine
relationale Datenbank anzubinden
• Das Hauptproblem ist dabei der Impedance Mismatch zwischen
objektorientierter und relationaler Welt
• Der einfachste Weg ist es direkt per Treiber mit der Datenbank
zu kommunizieren
• Eine etwas bessere Integration bieten Spracheinbettungen
• Persistenzframeworks erlauben es das Mapping zwischen den
Objekten und der Datenbank festzulegen. So kann der
Programmierer direkt mit den Objekten arbeiten.
Datenbanken, WS 2012/13 Kapitel 6: Anbindung an Anwendungen
18