WiTa Datenbank Anbindung (Handout)

WiTa – Datenbankanbindung:
Interfaces, Methoden und Attribute
1 Inhaltsverzeichnis
1
2
Inhaltsverzeichnis............................................................................................................... 1
Speichern............................................................................................................................ 2
2.1
Interfaces .................................................................................................................... 2
2.1.1
Storeable............................................................................................................. 2
2.1.2
Createable........................................................................................................... 2
2.1.3
Updateable.......................................................................................................... 3
2.2
Hilfsmethoden ............................................................................................................ 3
2.2.1
executeCommand ............................................................................................... 3
2.2.2
executeCreate ..................................................................................................... 4
3
Laden.................................................................................................................................. 5
3.1
Interfaces .................................................................................................................... 5
3.1.1
Restoreable ......................................................................................................... 5
3.2
Hilfsmethoden ............................................................................................................ 5
3.2.1
genericFind......................................................................................................... 5
3.2.2
calculateQuery.................................................................................................... 6
3.2.3
getMemberFromDatabase .................................................................................. 6
4
Hilfsstrukturen.................................................................................................................... 7
4.1
Interfaces .................................................................................................................... 7
4.1.1
SimpleIntId......................................................................................................... 7
4.2
Hilfsmethoden ............................................................................................................ 7
4.2.1
getConnection..................................................................................................... 7
4.2.2
getQuery ............................................................................................................. 7
4.2.3
getCompString ................................................................................................... 8
4.2.4
makeStringFuzzy................................................................................................ 8
4.2.5
makeSQLString.................................................................................................. 8
4.3
Hilfsattribute............................................................................................................... 9
4.3.1
sqlNames ............................................................................................................ 9
4.3.2
[Attribut-Name]Id .............................................................................................. 9
1
2 Speichern
2.1 Interfaces
2.1.1 Storeable
Name
Methoden
Attribute
Verwendung
Erläuterung
Beispiel
de.uni_marburg.wita.sql.Storeable
1. public String getCreateString()
2. public String getUpdateString()
3. public String getRemoveString()
Alle (in Db) speicherbaren Klassen sollten dieses Interface
implementieren.
Die Methoden liefern jeweils die entsprechende SQL-Statements der
Operationen:
getCreateString Æ INSERT INTO (…) VALUES (…)
getUpdateString Æ UPDATE … SET … WHERE …
getRemoveString Æ DELETE FROM … WHERE …
de.uni_marburg.wita.orga.StandardTextTemplate (einfach)
de.uni_marburg.wita.orga.Person (komplex)
2.1.2 Createable
Name
Methoden
Attribute
Verwendung
Erläuterung
Beispiel
de.uni_marburg.wita.sql.Createable
1. public void create()
2. public void remove()
Dieses Interface sollten nur speicherbaren Klassen implementieren, die
unabhängig von anderen Klassen existieren (d.h. unter anderem, dass sie
nicht stark aggregiert werden). Für abhängige Klassen übernimmt ein
„Master“-Klasse die Funktionalität dieses Interfaces:
add[Klassen-Name](…)
remove[Klassen-Name](…)
Die Methoden speichern/löschen ein Objekt in/aus einer Datenbank. Die
Implementierung des Interfaces durch eine Klasse bedeutet insbesondere,
dass Objekte dieser Klasse selbständig gespeichert werden können soll
(siehe „Verwendung“).
Die Methoden verwenden insbesondere getCreateString und
getRemoveString des Storable-Interfaces.
de.uni_marburg.wita.orga.StandardTextTemplate (einfach)
de.uni_marburg.wita.orga.Congress (komplex)
2
2.1.3 Updateable
Name
Methoden
Attribute
Verwendung
Erläuterung
Beispiel
de.uni_marburg.wita.sql.Updateable
1. public void update()
Alle (in Db) speicherbaren Klassen sollten dieses Interface
implementieren.
Die Methode macht den aktuellen Zustand eines Objektes persistent in der
Datenbank (Æ speichert). Das Objekt muss zuvor in der Datenbank
gespeichert worden sein: mit der Objekt-eigenen create() bzw. einer
add[Objekt-Name](…) Methode des Master-Objektes (vgl. Verwendung
beim Createable-Interface).
Die Methode verwendet insbesondere getUpdateString des StorableInterfaces.
de.uni_marburg.wita.orga.StandardTextTemplate (einfach)
de.uni_marburg.wita.orga.Congress (komplex)
2.2 Hilfsmethoden
2.2.1 executeCommand
Name
Varianten
Verwendung
(allgemein)
Verwendung
(Variante 1)
Verwendung
(Variante 2)
Verwendung
(Variante 3)
de.uni_marburg.wita.sql.Engine.executeCommand
1. public static void executeCommand(
String sqlString, Logger logger)
2. public static void executeCommand(
String[] sqlString, Logger logger)
3. public static void executeCommand(
String[] sqlStrings, Logger logger, Connection connect, boolean
commit)
Diese Methode wird allgemein dazu verwendet, SQL-Statements
aufzuführen, die keine speziellen Ergebnisse zurückliefern (wie z.B.
UPDATE und DELETE).
String sqlString: dieser Paramter sollte ein SQL-konformes Statement
enthalten.
Logger logger: ein Logger für Debug-Informationen (kann auch null sein)
Beispiel: in de.uni_marburg.wita.orga.Congress.update()
String[] sqlString: ein Sting-Array mit SQL-konformen Statements. Alle
Statements des Arrays werden innerhalb einer Transaktion ausgeführt und
– falls von der Datenbank unterstützt – als Batch-Vorgang.
Beispiel: in de.uni_marburg.wita.orga.Congress.remove()
Connection connect: ein Connection-Objekt, das mittels der Methode
de.uni_marburg.wita.sql.Engine.getConnection() geholt werden kann.
Diese Variante dient dazu, eigene Transaktionen zusammenzustellen:
Zuerst wird ein Connection-Objekt geholt und die Autocommit-Funktion
ausgeschaltet (setAutoCommit(false)). Dann kann diese Variante der
Methode (und die 2. Variante von executeCreate) mehrmals auf dem
selben Connection-Objekt ausgeführt werden, wobei der letzte booleanParameter commit mit false aufgerufen wird. Das letzte Mal, wenn die
Methode aufgerufen wird, wird dann die Transaktion abgeschlossen, indem
der Parameter commit mit true aufgerufen wird.
Beispiel: in de.uni_marburg.wita.orga.Congress.update()
3
2.2.2 executeCreate
Name
Varianten
Verwendung
(allgemein)
Verwendung
(Variante 1)
Verwendung
(Variante 2)
de.uni_marburg.wita.sql.Engine.executeCreate
1. public static int executeCreate(
Storeable ObjectToStore, Logger logger)
2. public static int executeCreate(
Storeable ObjectToStore, Logger logger, Connection connect,
boolean commit)
Diese Methode wird im allgemeinen in einer create()-Methode (vgl.
Createable-Interface) verwendet.
Insbesondere wird die getCreateString-Methode verwendet.
Falls das (param) ObjectToStore Objekt außerdem das
de.uni_marburg.wita.orga.SimpleIntId-Interface implementiert, so wird die
id des Objektes automatisch mit der von der Datenbank erzeugten id
belegt.
Als Rückgabe-Wert hat diese Methode die von der Datenbank erzeugte id
(da gültige ids echt größer 0 sind, bedeutet 0 als Rückgabe-Wert ein Fehler,
bzw. dass (param) ObjectToStore das SimpleIntId-Interface nicht
unterstützt).
Storeable ObjectToStore: dieser Paramter ist ein Objekt, das das StoreableInterface implementiert.
Logger logger: ein Logger für Debug-Informationen (kann auch null sein)
Beispiel: in de.uni_marburg.wita.orga. StandardTextTemplate.create()
Diese Variante der Methode kann dazu verwendet werden, eigene
Transaktionen zusammenzustellen (siehe executeCommand, Verwendung
(Variante 3)).
4
3 Laden
3.1 Interfaces
3.1.1 Restoreable
Name
Methoden
Attribute
Verwendung
Erläuterung
Beispiel
de.uni_marburg.wita.sql.Restoreable
1. public void restore(ResultSet source)
Alle (in Db) speicherbaren Klassen sollten dieses Interface
implementieren.
Die Methode füllt aus dem (param) ResultSet source die einzelnen
Attribute des Objekts.
de.uni_marburg.wita.orga.Person
3.2 Hilfsmethoden
3.2.1 genericFind
Name
Varianten
Verwendung
(allgemein)
de.uni_marburg.wita.sql.Engine.genericFind
1. public static Collection genericFind(
String queryString, String restoreableClassName, Logger logger)
Diese Methode wird zum Laden bzw. Suchen von Objekten in der
Datenbank verwendet.
Die Suche läuft über den (param) String queryString, der ein SQLkonformer Query sein sollte z.B.:
SELECT [fields] FROM [database_table [AS [alias-name]]] WHERE
[search_condition [AND [search_condition]]] ORDER BY [order]
Mit dem (param) String restoreableClassName gibt man den Namen des
Objekt-Typs an, den man sucht; d.h. der Klassen-Name inkl. der
vollständigen Package-Angabe (z.B. „de.uni_marburg.wita.orga.Person“).
Der (param) Logger logger ist optional (d.h. darf auch null sein) und dient
der Ausgabe von (Debug-) Informationen.
Die Methode gibt eine Collection zurück, die mit Objekten vom Type
(param) restoreableClassName sind und dabei den Such-Kriterien des
Paramters queryString gerecht werden. Falls es keine solche Objekte in der
Datenbank gibt, wird eine leere Collection zurückgegeben.
5
3.2.2 calculateQuery
Name
Varianten
Verwendung
(allgemein)
de.uni_marburg.wita.sql.Engine.calculateQuery
1. public static Object calculateQuery(String sqlQuery, boolean
longOrDouble, Logger logger)
Mit dieser Methode können (Zahlen-) Werte, die Datenbank-intern (d.h.
über ein SQL-Statement) berechnet werden, abgefragt werden.
Die Abfrage läuft über den (param) String sqlQuery, der SQL-konform
sein sollte z.B.:
SELECT sum([fields]) FROM [database] WHERE [search_condition
[AND [search_condition]]]
Mit (param) boolean longOrDouble gibt man an, welche Art von Wert
berchnet wird:
Bei true wird ein ganzzahliger Wert erwartet, bei false ein gebrochener.
Entsprechend ist der Rückgabe-Wert bei true ein java.lang.Long Objekt
und bei false ein java.lang.Double Objekt.
Der (param) Logger logger ist optional (d.h. darf auch null sein) und dient
der Ausgabe von (Debug-) Informationen.
Die Methode gibt ein Objekt zurück: falls (param) longOrDouble true ein
java.lang.Long, falls false ein java.lang.Double, wobei die Objekte jeweils
den durch die Methode berechneten Wert enthalten.
Falls der Rückgabe-Wert -1 ist, könnte das auf einen Fehler hindeuten (es
könnte aber auch wirklich -1 berechnet worden sein).
3.2.3 getMemberFromDatabase
Name
Varianten
Verwendung
(allgemein)
de.uni_marburg.wita.sql.Engine.getMemberFromDatabase
1. public static Object getMemberFromDatabase(
String sqlQuery, String restoreableObjectName, Logger logger)
Diese Methode ist zum Laden von Storeable Objekt-Feldern/Attributen aus
der Datenbank gedacht.
Die Suche nach dem richtigen Objekt läuft über den (param) String
sqlQuery, der ein SQL-konformer Query sein sollte, wobei in der WHEREKlausel nach dem Primär-Schlüssel des Objekts gesucht werden sollte z.B.:
SELECT [fields] FROM [database_table] WHERE [object_id=value].
Mit dem (param) String restoreableClassName gibt man den Namen des Objekt-Typs an, den man
sucht; d.h. der Klassen-Name inkl. der vollständigen Package-Angabe (siehe genericFind).
Der (param) Logger logger ist optional (d.h. darf auch null sein) und dient der Ausgabe von (Debug) Informationen (siehe genericFind).
Die Methode ist ähnlich der genericFind-Methode. Da aber mit dem
Primär-Schlüssel nach einem Objekt gesucht wird sollte das ResultSet des
SQL-Querys auch nur eine Zeile (row) enthalten. Weshalb auch nur ein
Objekt vom Typ (param) restoreableObjectName statt einer Collection
zurückgegeben wird. Im Unterschied zu genericFind wird auch keine
Exception geworfen (Fehlermeldungen werden gegebenenfalls über den
(param) logger ausgegeben).
6
4 Hilfsstrukturen
4.1 Interfaces
4.1.1 SimpleIntId
Name
Methoden
Attribute
Verwendung
Erläuterung
Beispiel
de.uni_marburg.wita.orga.SimpleIntId
1. public int getId()
2. public void setId(int identity)
Alle (in Db) speicherbaren Klassen sollten dieses Interface
implementieren, solange sie keine Assoziations-Klassen sind. Mit
Ausnahme der Assoziations-Klassen werden Klassen mit Hilfe einer
„künstlichen“ int-Objekt-ID eindeutig identifiziert. Die Objekt-ID wird in
der Regel vom Datenbank-System beim speichern (INSERT) erzeugt (Æ
AUTO_INCREMENT).
Mit den Methoden wird die Objekt-ID gesetzt (vgl. executeCreate(…))
bzw. kann abgefragt werden.
de.uni_marburg.wita.orga.Person
4.2 Hilfsmethoden
4.2.1 getConnection
Name
Varianten
Verwendung
(allgemein)
de.uni_marburg.wita.sql.Engine.getConnection
1. public static Connection getConnection()
Mit dieser Methode kann ein java.sql.Connection Objekt für die zum
Speichern benutzte Datenbank angefordert werden.
Das Connection Objekt kann i.d.R. dazu benutzt werden, um eigne
Transaktionen zusammen zustellen (siehe executeCommand, 3. Variante
und executeCreate, 2. Variante). Ansonsten sollte man möglichst die
vorhandenen Methoden benutzen, ohne die JDBC-Funktionalität direkt zu
nutzen.
4.2.2 getQuery
Name
Varianten
Verwendung
(allgemein)
Verwendung
(Variante 1)
Verwendung
(Variante 2)
Verwendung
(Variante 1)
de.uni_marburg.wita.sql.Engine.getQuery
1. public static String getQuery(String toQuery)
2. public static String getQuery(java.sql.Date toQuery)
3. public static String getQuery(boolean toQuery)
Diese Methoden wandeln Java Datentypen in Stringrepräsentationen um,
die direkt in einem SQL-Statement verwendet werden können.
(Parameter: String) „Test“ Æ (Rückgabe: String) „’[Test]’”
(wobei [Test] dem Rückgabe-String der Methode makeStringFuzzy enspricht)
(Parameter: Date) [Date-Obj.] Æ (Rückgabe: String) „’[Date-Patterned]’”
(wobei [Date-Patterned] der Mustervorgabe von
de.uni_marburg.wita.sql.Engine.DATABASE_DATE_FORMAT entspricht)
(Parameter: boolean) [true] Æ (Rückgabe: String) „1”
(Parameter: boolean) [false] Æ (Rückgabe: String) „0”
7
4.2.3 getCompString
Name
Varianten
Verwendung
(allgemein)
Verwendung
(Variante 1)
Verwendung
(Variante 2)
de.uni_marburg.wita.sql.Engine.getCompString
1. public static String getCompString(byte comparatorType)
2. public static String getCompString(boolean exactMatching)
Diese Methoden geben dem - Parameter entsprechend - eine
Stringrepräsentation eines bestimmten Vergleichs-Operators zurück, der
z.B. in einer WHERE-Klausel eines SQL-Statements verwendet werden
kann.
Sollte für Vergleichs-Operatoren von Zahlen bzw. Daten verwendet
werden (siehe Java-Docs für Informationen bzgl. der Parameter-Werte)
Sollte für Vergleichs-Operatoren von Zeichenketten verwendet werden
(siehe Java-Docs für Informationen bzgl. der Parameter-Werte)
4.2.4 makeStringFuzzy
Name
Varianten
Verwendung
(allgemein)
de.uni_marburg.wita.sql.Engine.makeStringFuzzy
1. public static String makeStringFuzzy(String toLoose)
Diese Methode ersetzt die üblichen Wildcards (für ein Suche: * ?) mit den
für die Datenbank-üblichen Wildcards (z.B. % _)
4.2.5 makeSQLString
Name
Varianten
Verwendung
(allgemein)
de.uni_marburg.wita.sql.Engine.makeSQLString
1. public static String makeSQLString(String[] fieldList, String prefix,
String separator)
Diese Methode konstuiert aus den Parametern einen String wie folgt:
Die Strings des Parameters fieldList werden hintereinander geschrieben,
wobei sie jeweils (param) prefix als Präfix erhalten und voneinander durch
(param) separator getrennt werden.
Beispiel: fieldList={„eins“, „zwei“, „drei“}, prefix= „Obj.“, separator= „; “
Æ Rückgabe-String: „Obj.eins; Obj.zwei; Obj.drei“
Mit dieser Methode und dem Objekt-Feld sqlNames (z.B. in Address) einer
speicherbaren Klasse als Parameter fieldList kann in einfacher Weise die
Projektion in einem SQL-Statement zusammengestellt werden (wobei mit
prefix die Datenbank-Tabelle bzw. ihr Alias gesetzt werden können):
SELECT addr.street, …, addr.faxNumber FROM Address AS addr
Dazu muß der Methode Address.sqlNames als fieldList, „addr.” als prefix
und „,” als separator übergeben werden.
8
4.3 Hilfsattribute
4.3.1 sqlNames
Name
Varianten
Verwendung
(allgemein)
de.uni_marburg.wita.orga.*.sqlNames
1. [private|public] final static transient String[] sqlNames
In diesem Attribute sollten alle Attribute der Klasse, die in der Datenbank
gespeichert werden aufgezählt werden.
Die „Aufzählung“ als Strings sollten jeweils die Spalten-Namen der
Datenbank-Tabelle sein, in der das jeweilige Attribut gespeichert wird:
(Attribut) street Æ (Spalten-Name) street_name
Î (sqlName-Eintrag) street_name
4.3.2 [Attribut-Name]Id
Name
Varianten
Verwendung
(allgemein)
de.uni_marburg.wita.orga.*.[Attribut-Name]Id
1. private transient int [Attribut-Name]Id
Für Attribute eines Objekts, die in einer eignen Datenbank-Tabelle
gespeichert werden, wird zusätzlich zum Attribut ein int-Attribut angelegt,
das die ID des Attributs enhält (vgl. auch SimpleIntId-Interface).
Beispiel: in BankDetail
(Attribut)
private Person owner
(Hilfsattribut) private transient int ownerId
Dieses (Hilfs-) Attribut wird benötigt, um das eigentliche Attribut (per
lazy-loading) aus der Datenbank zuholen ( siehe auch
BankDetail.getPerson() ).
Das Attribut [Attribute-Name]Id sollte nur in den create() (oder
add[Object-Name](…)) bzw. update() Methoden gesetzt werden (Æ nicht
in der set[Attribute-Name]([Attribut-Type]) Methode).
9