JAXenter

Seit der Einführung der objektorientierten Programmierung ist es oft der Wunsch eines Programmierers, die in einer Datenbank enthaltenen Datensätze auf ein Objekt abzupictureen. Optimal wäre dieses Problem gelöst, wenn die Umwandlung weitgehend automatisch geschehen würde und die Anwendung keinen großen Programmieraufwand erfordert.

Diejenigen unter Ihnen, die sich bereits mit dem objekt-relationalen Mapping beschäftigt haben, werden früher oder später auf Castor gestoßen sein. Neben dem reinen Mapping liefert Castor noch ein Reihe von zusätzlichen Enterprise-Features.

In diesem Beitrag soll es um das freie Tool Osage gehen, das JDBC-basiertes objekt-relationales Mapping bietet und auf zusätzliche Features weitgehend verzichtet. Osage ist vollkommen in Java implementiert und fügt sich somit optimal in die Konzepte der Java-Plattform ein.

Objekt-relationales Mapping

Zunächst wollen wir an dieser Stelle einmal klären, worum es beim objekt-relationalen Mapping überhaupt geht. Ausgangssituation ist zunächst eine Datenbank, die die benötigten Datensätze liefert. Aufgabe der objekt-relationalen Abpictureung ist es nun, den Datensatz auf ein Objekt abzupictureen. Hierzu liefert Ihnen Osage die benötigte Unterstützung. Sie brauchen sich deshalb nicht mit SQL-Anweisungen und der JDBC-Programmierung auseinander zu setzen. Dies hat den Vorteil, dass keinerlei SQL-Anfragen in Ihrem Programm fest codiert sind. Stattdessen werden die Anweisungen dynamisch zur Laufzeit generiert. Hierdurch lässt sich der Quellcode zudem wesentlich reduzieren. Da Osage den Datenbankzugriff vollkommen durch JDBC umsetzt, sind Programme, die auf Osage setzen, unabhängig von der eingesetzten Datenbank.

XML-Unterstützung inbegriffen

Um die Fähigkeiten von Osage abzurunden ist natürlich vollständiger XML-Support in das Projekt integriert. Hierdurch erhalten Sie die Möglichkeit, Datensätze direkt nach XML zu überführen. Auch die andere Richtung ist selbstverständlich möglich, um aus einer XML-Quelle direkt in die Datenbank schreiben zu können.

Doch bevor wir nun mitten in die Anwendung von Osage einsteigen wollen, muss das Paket natürlich erst einmal installiert sein. Alle Information zur Installation finden Sie im folgenden Abschnitt.

Installation

Zu finden ist das Programmpaket auf http://osage.sourceforge.net. Der Download erfolgt als gepacktes Zip-Archiv. Entpacken Sie die Archivdatei in ein Verzeichnis Ihrer Wahl und wechseln Sie anschließend in das neu erstellte Unterverzeichnis osage-1.0pre10. Osage benötigt eine Reihe von Jar-Archiven, die jedoch alle im Verzeichnis lib mitgeliefert werden, sodass keine weiteren Installationen nötig sind. Der Übersetzungsvorgang erfolgt per Ant-Buildfile build.xml. Aufzurufen ist Ant über das Shellskript build.sh bzw. build.bat unter Windows. Da sich die Datei ant.jar bereits im lib-Verzeichnis befindet, braucht auch Ant nicht gesondert installiert werden. Nach dem Aufruf des entsprechenden build-Skriptes sollte sich die Datei osage-1.0pre10.jar im aktuellen Verzeichnis befinden. Die Installation ist somit abgeschlossen. Bevor wir den ersten Einsatz von Osage weiter vorbereiten, ist es zunächst einmal erforderlich, eine Datenbank zur Verfügung zu stellen. Für die Beispiele in diesem Beitrag verwenden wir ein Postgres-System unter Linux. Die Installation ist nachfolgend kurz beschrieben.

PostgreSQL einrichten.

Die Installation eines Postgres-Systems stellt sicherlich kein großes Problem dar und dürfte vielen Lesern bereits bekannt sein. Dennoch folgt zunächst eine kurze Anleitung. Die aktuelle Version von Postgres beziehen Sie bitte von einem Mirror der Seite <font>http://www.postgresql.org.</font> Sie haben die Wahl zwischen binären RPM-Paketen und dem gepackten Sourcecode im *.tar.gz-Format.

Das Installieren der RPM-Versionen dürfte keine Probleme bereiten, entscheiden Sie sich für das Übersetzen der Quellen, ist die Installation auch in wenigen Schritten erledigt.

Wechseln Sie hiezu in das Verzeichnis, in dem der Sourcecode entpackt worden ist und starten Sie den Konfigurationsvorgang mit dem Befehl:

1. ./configure

Wurden alle benötigten Komponeten gefunden, starten Sie anschließend den Übersetzungsvorgang mittels:

1. gmake
2. gmake install

Sie benötigen nun einen User der Besitzer der Datenbank sein soll. Aus Sicherheitsgründen darf hier nicht der Superuser root verwendet werden. Beispielsweise kann stattdessen ein User postgres durch

1. adduser postgres

angelegt werden.

Nun muss noch das Datenverzeichnis der Datenbank angelegt werden. Gewöhnlich wird das Verzeichnis bei einer Standardinstallation unter | usr | local | pgsql | data erstellt. Dieser Schritt muss zunächst als User root erfolgen:

1. mkdir /usr/local/pgsql/data

Anschließend können die Besitzrechte dieses Verzeichnisses auf den User der Datenbank geändert werden:

1. chown postgres /usr/local/pgsql/data
2. su - postgres

Sie sind nun als User postgres eingeloggt und können die Datenbank starten. Da Postgres im Folgenden zum ersten Mal gestartet wird, muss das Datenverzeichnis zunächst durch den Befehl initdb initialisiert werden, bevor anschließend der Postmaster-Prozess gestartet werden kann.

1. /usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data
2. /usr/local/pgsql/bin/postmaster -D /usr/local/pgsql/data &

Der Postmaster-Prozess (der im Hintergrund gestartet wird) bekommt ebenfalls durch den Parameter -D das aktuelle Datenverzeichnis übergeben. Nun sollte der Datenbankserver laufen und benutzbar sein. Wir überprüfen unsere hoffentlich erfolgreiche Installation durch das Anlegen einer neuen Datenbank:

1. /usr/local/pgsql/bin/createdb test

Wird keine Fehlermeldung ausgegeben, sollte es Ihnen anschließend möglich sein, mit dem Client psql auf die gerade erstellte Datenbank mit dem Namen test zugreifen zu können:

1. /usr/local/bin/psql test

Ist bis hierhin alles ohne Fehler verlaufen, darf ich Sie nun zu einem laufenden Postgres-System beglückwünschen. Hiermit haben wir die Grundlage für die folgenden Beschreibungen geschaffen.

Konfiguration der Datenbankverbindung

Mit einem lauffähigen Datenbanksystem ist die Arbeit natürlich noch nicht ganz abgeschlossen, schließlich müssen noch Tabellen angelegt und gefüllt, sowie die Verbindung zur Datenbank unter Osage konfiguriert werden. Um die Schritte an einem Beispiel erläutern zu können, verwenden wir an dieser Stelle die beigefügten Beispieldateien unter dem Verzeichnis examples. Zunächst ist die Datei create.sql interessant.



Listing 1

1. DROP TABLE prod
2. CREATE TABLE prod (
3. id integer,
4. name varchar(200),
5. price numeric(18,2)
6. )
9. DROP TABLE category_prod
11. CREATE TABLE category_prod (
12. prod_id integer,
13. category_id integer
14. )
17. DROP TABLE prod_detail
19. CREATE TABLE prod_detail (
20. id integer,
21. prod_id integer,
22. name varchar(200)
23. )
26. DROP TABLE prod_group
28. CREATE TABLE prod_group (
29. id integer,
30. name varchar(200),
31. prod_id integer
32. )
35. DROP TABLE category
37. CREATE TABLE category (
38. id integer,
39. description varchar(200)
40. )

Diese Datei enthält SQL-Anweisungen, die benötigt werden, um die vorausgesetzten Tabellen in Ihrer Datenbank anlegen zu könne.Wie Sie sehen, werden insgesamt fünf Tabellen mit den Namen prod, category_prod, prod_detail, prod_group sowie category angelegt. Die Tabellen sind zudem untereinander verbunden (id, prod_id).

Verwenden Sie Postgres, haben Sie die Wahl der manuellen Eingabe der SQL-Befehle über den Client psql oder das Übergeben der Datei create.sql. Innerhalb psql geben Sie dazu folgendes Kommando ein:

1. \i [Pfad zur Datei]/create.sql

Nun ist Postgres für den Einsatz mit den Osage-Beispielprogrammen vorbereitet. Damit Osage nun aber überhaupt die Datenbank mit den darin enthaltenen Tabellen finden bzw. benutzen kann muss die Verbindung durch einige Parameter zunächst konfiguriert werden. Die Konfiguration erfolgt über eine XML-Datei. Im folgenden Listing sehen Sie eine Beispielkonfiguration für eine lokale Postgres-Konfiguration:

1. <?xml version="1.0"?>
2. <db>
3. <database name="test" vendor="postgres">
4. <driver class="org.postgresql.Driver" url="jdbc:postgresql://localhost/test"/>
5. <param name="user" value="postgres"/>
6. <param name="password" value="postgres"/>
7. </database>
8. </db>

Zunächst wird über das Tag driver durch das Attribute class der JDBC-Datenbanktreiber bestimmt. Damit der entsprechende Datenbanktreiber verfügbar ist, muss die jar-Datei des Treibers in den CLASSPATH aufgenommen werden. Im Falle von Postgres ist dies die Datei jdbc[Version].jar. Zu finden ist der Postgres-JDBC-Treiber auf http://www.retep.org.uk/postgres.

Außer dem Attribut class erfolgt noch die Übergabe des Verbindungsstrings durch das Attribut url. Im Beispiel konfigurieren wir ein Postgres-System, das lokal läuft und über eine Datenbank test verfügt. Durch die folgenden param-Tags werden die beiden Parameter user und password gesetzt. Sollte die Datenbankinstanz unter einem anderen Benutzer als postgres laufen, nehmen Sie an dieser Stelle bitte die erforderlichen Anpassungen vor. Ausserdem muss natürlich das von Ihnen gewählte Passwort eingesetzt werden. Benutzername und Passwort werden jeweils durch das Attribut value übergeben.

Nachdem die Datenbankverbindung steht, müssen noch eine Reihe weiterer Einstellungen getroffen werden. Hierzu gibt es eine zentrale Konfigurationsdatei. Eine Beispielkonfiguration ist unter examples/conf.xml zu finden.


Listing 2

1. <?xml version="1.0"?>
2. <osage>
3. <database>
4. <!-- omit this for no debugging -->
5. <logfilename>sql.log</logfilename>
6. </database>
7. <dbmap>
8. <schema>file:database.qjml</schema>
9. <input>file:test.xml</input>
10. </dbmap>
11. <classmap>
12. <schema>file:maps.qjml</schema>
13. <input>file:prodcomp.xml</input>
14. <input>file:product.xml</input>
15. </classmap>
16. <builder>
17. <sqlinterface>generic</sqlinterface>
18. <database>test</database>
19. <output>newmap.xml</output>
20. <dest>..</dest>
21. </builder>
22. </osage>

Die XML-Datei lässt sich in vier Hauptbereiche unterteilen, zu denen Einstellungen vorgenommen werden: Logging, Datenbank, Mapping und Builder.

Wie Sie erkennen können, taucht auch die Datei test.xml wieder auf, die innerhalb des Elementes dbmap zur Konfiguration der Datenbankverbindung angegeben wird. Zusätzlich tauchen zwei weitere wichtige XML-Konfigurationsdateien auf: prodcomp.xml und product.xml. Hier wird zentral das Mapping zwischen Datenbanktablen und Java-Klassen konfiguriert. Im folgenden Abschnitt werden wir die Konfiguration des Mappings anhand dieser Beispieldateien nachvollziehen.

Mapping

Das Mapping, zu deutsch Abpictureung, beschreibt die Verbindung von Datenbanktablen und Java-Klassen. Die Konfiguration erfolgt komfortabel über eine XML-Datei. Anhand der Beispieldateien prodcomp.xml und product.xml lassen sich die Einstellungen gut nachvollziehen. Im folgenden Listing sehen Sie einen kurzen Auszug zur Verdeutlichung:

1. <?xml version="1.0"?>
2. <maps>
3. <class name="yourapp.comp.Product">
4. <map-to database="test" xml="product" table="prod"/>
5. <key-generator type="max" field="id"/>
6. <field name="id" type="integer">
7. <sql primary-key="True" />
8. </field>
9. ...
10. </class>
11. </maps>

Die XML-Mapping-Datei wird durch das Element <maps> eingeleitet. Alle weiteren Einstellungen werden innerhalb dieses Elementes vorgenommen. Zunächst wird über <class> festgelegt, für welche Klasse das Mapping nachfolgend beschrieben wird. Die Klassenangabe erfolgt hierbei mit vollständigem Packagenamen. Nachdem die Klasse festgelegt ist, kann nun die Datenbank (Element <map-to>, Attribut database) eingestellt werden. Unser Beispiel verwendet eine Datenbank mit dem Namen test. Wie Sie bereits während der Postgres-Installation gesehen haben, lassen sich neue Datenbanken mit dem Befehl

1. createdb [Datenbankname]

erstellen. Durch das Element <field> kann nun jedes Feld einer Datenbank einer Variablen der Klasse zugeordnet werden (weitere Informationen zur Klassenimplementierung weiter unten). Hiermit werden die Variablentypen nach folgender Tabelle umgesetzt:

 
Für die Validierung der XML-Mapping-Datei wird Quick und die darin enthaltene Schemasprache QJML eingesetzt. Da eine kurze Einführung in diese Schemasprache bereits im Java Magazin 10.2001 auf Seite 80 zu finden ist, gehen wir an dieser Stelle nicht gesondert auf diese Technik ein. Die Datei maps.qjml beinhaltet die entsprechenden Validierungsregeln.

Java-Klassen

Wir haben bisher zwei wesentliche Bestandteile der Dreierkette Datenbank-Mapping-Java gesehen. Zum Vervollständigen der Betrachtung gehen wir nun in diesem Abschnitt auf die entsprechende Java-Implementierung ein. Wie Sie bereits gesehen haben, ordnet die Mapping-Datei den verschiedenen Feldern einer Datenbanktable entsprechende Eigenschaften einer Java-Klasse zu. Die Implementierung dieser Java-Klasse erfolgt natürlich nach einem vorgegebenen, aber relativ einfachen Schema.


Listing 3

1. package yourapp.db;
3. import java.math.BigDecimal;
4. import java.sql.Time;
5. import java.sql.Timestamp;
6. import java.util.ArrayList;
7. import java.util.Collection;
8. import java.util.Date;
11. public class Product {
13. public static String FOR_NAME = "yourapp.db.Product";
14. public static String ID = "id";
15. public static String GROUP_ID = "groupId";
16. public static String NAME = "name";
17. public static String PRICE = "price";
18. private int id;
19. private int groupId;
20. private String name;
21. private double price;
23. public int getGroupId()
24. {
25. return groupId;
26. }
28. public int getId(){
29. return id;
30. }
32. public String getName(){
33. return name;
34. }
36. public double getPrice(){
37. return price;
38. }
40. public void setGroupId(int groupId){
41. this.groupId = groupId;
42. }
44. public void setId(int id){
45. this.id = id;
46. }
48. public void setName(String name){
49. this.name = name;
50. }
52. public void setPrice(double price){
53. this.price = price;
54. }
56. }

Das Listing zeigt Ihnen die Umsetzung der Datenbanktable product in eine Java-Klasse. Der Klassenname ist hierbei mit dem Tabellennamen identisch. Die Verbindung der entsprechenden Tabellenfelder mit den zugehörigen Variablennamen erfolgt über die Deklaration von Konstanten.

1. public static String ID = "id";
2. public static String GROUP_ID = "groupId";
3. public static String NAME = "name";
4. public static String PRICE = "price";

Diese Konstanten entsprechen folgender Umsetzung:

 
Anschließend werden die zugehörigen Variablen deklariert.

1. private int id;
2. private int groupId;
3. private String name;
4. private double price;

Die Typenzuordnung erfolgt wie in Tabelle 1 aufgelistet. Dabei bleiben die beiden Integer-Felder id und groupId int-Variablen. Da es sich bei dem Feld name um den Typ varchar handelt, setzen wir hierfür den Typ string ein. Price wandeln wir von numeric in double um.

Den Großteil der Klasse product machen schließlich die zugehörigen get- und set-Methoden aus. Zu jeder Klassenvariable muss jeweils eine get- und eine set-Methode vorhanden sein. Der Name der Methode setzt sich hierbei immer aus dem Teilstring get bzw. set und dem Variablennamen zusammen. Der Variablenname wird grundsätzlich durch einen Großbuchstaben eingeleitet.

Um das Beispiel zu vervollständigen sehen Sie nun noch einmal die entsprechende SQL-Tabellenstruktur abgepictureet:

1. create table prod {
2. id int not null,
3. name varchar(200) not null,
4. price numeric(18,2) not null,
5. group_id int not null,
6. };

Automatisierung

Die drei Schritte, die nötig sind um das Mapping vorzubereiten haben Sie jetzt anhand eines Beispiels nachvollziehen können. Nun stellt sich natürlich die Frage, ob es nötig ist, jedes mal die Schritte von Hand auszuführen. Eine Datenbanktable anzulegen, die benötigte Mapping-Datei zu schreiben und anschließend die Klasse in Java zu implementieren, kann auf die Dauer sehr zeitintensiv werden. Besser wäre es, wenn bestimmte Schritte, die immer nach dem selben Schema durchgeführt werden, automatisiert werden könnten. Osage bietet Ihnen hierzu einige Hilfen an, die wir uns im Folgenden ansehen wollen. Die Klasse net.sourceforge.osage.util.builder.Main ist hierbei der zentrale Bestandteil. Mit Hilfe dieser Klasse erhalten Sie die folgenden Möglichkeiten:

• Aus einer vorhandenen Mapping-Datei die entsprechende Java-Klasse generieren.
• Aus einer vorhandenen Datenbank eine Mapping-Datei erstellen.
• Aus vorhanden Mapping-Dateien eine SQL-Datei erstellen, die SQL-Befehle enthält, um die entsprechende Tabelle in der Datenbank anzulegen.

Sie benötigen also nur einen Bestandteil der Dreierkette Datenbank-Mappingdatei-Javaklasse, um die fehlenden Teile automatisch ergänzen zu lassen. Die Anwendung dieser Hilfsklasse ist sehr einfach. Es werden lediglich zwei Strings an die Klasse per Kommandozeile übergeben. Der erste String beschreibt die Funktion die durchgeführt werden soll. Mögliche Werte sind hierbei:

• "net.sourceforge.osage.util.builder.ClassBuilder" - Erstellt aus einer Mapping-Datei eine Java-Klasse
• "net.sourceforge.osage.util.builder.MapBuilder" - Erstellt aus einer Datenbanktabelle eine Mapping-Datei
• "net.sourceforge.osage.util.builder.SQLBuilder" - Erstellt aus einer Mapping-Datei die benötigten SQL-Anweisungen zum Generieren der entsprechenden Tabelle.

Der zweite Parameter enthält die XML-Konfigurationsdatei des Projektes. Der Aufruf könnte also folgendermaßen aussehen:

1. java net.sourceforge.osage.util.builder.Main net.sourceforge.osage.util.builder.ClassBuilder conf.xml

Im Einsatz

Bis zu dieser Stelle haben wir nun alle Grundlagen betrachtet, die für die Anwendung des Mappings nötig sind. Sie haben die Tabellen der Datenbank initialisiert, eine Mapping-Datei erstellt und schließlich die Java-Mapping-Klasse implementiert. Außerdem haben Sie im letzten Abschnitt gesehen, dass wesentliche Schritte aus diesem Prozess automatisiert werden können und Ihnen als Programmierer somit eine Menge zusätzlicher Arbeit erspart wird. Im Folgenden besprechen wir jetzt die konkrete Anwendung des Mappings in eigenen Klassen. Ziel ist es hierbei, Daten aus der Tabelle der Datenbank durch Zugriff auf die entsprechenden Eigenschaften der Java-Mapping-Klasse zu erhalten. Somit können alle SQL- bzw. JDBC-spezifischen Codeblöcke aus Ihrem Projekt entfernt werden. Der Datenaustausch erfolgt ausschließlich über ein Objekt.

Als Beispiel verwenden wir weiterhin das Mapping der Tabelle product. Zunächst müssen wir eine Verbindung zu der verwendeten Datenbank herstellen. Da alle Verbindungseinstellungen bereits in der Konfigurationsdatei hinterlegt wurden, müssen keine Angaben fest im Quelltext codiert werden. Die Datenbank ist somit beliebig austauschbar.

1. Product product = null;
2. Database db = persistanceManager.getDatabase();
3. db.begin();

Der Quellcodeausschnitt erzeugt als erstes ein Objekt der Product-Klasse. Anschließend wird die Datenbankverbindung mit Hilfe des PersistanceManagers angefordert. db.begin() signalisiert anschließend ,dass eine Transaktion eingeleitet werden soll. Die Klassen PersistanceManager und Database sind im Package net.sourceforge.osage zu finden.

Um bestimmte Datensätze einer Tabelle abzufragen, kommt nun die Klasse RetrieveCritaria (Package: net.sourceforge.osage.api) zum Einsatz. Übergeben wird dem Konstruktor der Klasse das Kriterium, nach dem gefiltert werden soll.

1. RetrieveCritaria rc = new RetrieveCritaria(Product.FOR_NAME);

Wir benutzen als Kriterium die Konstante FOR_NAME (Wert : "yourapp.db.Product") und erhalten somit alle Produkte, die in der Tabelle gespeichert sind. Ausgeführt wird die Anfrage anschließend über den Befehl:

1. Iterator i = rc.perform(db);

Durch eine einfache While-Schleife können nun die erhaltenen Datensätze der Reihe nach durchlaufen werden.

1. while (i.hasNext())
2. {
3. product = (Product) i.next();
4. }

Wie gewohnt, muss auf den Rückgabewert der Funktion next() ein Cast-Operator angewendet werden. Hiermit erhalten Sie nun ein Objekt vom Typ product. Nach Beendigung der Transaktion müssen außerdem noch zwei Funktionen aufgerufen werden, die die Verbindung zur Datenbank wieder schließen:

1. db.commit();
2. db.close();

Die Liste der zurückgegebenen Datensätze kann eingeschränkt werden. Hierfür lassen sich Filterfunktionen einsetzen, die auf das Objekt der Klasse RetrieveCritaria angewendet werden. Sehen wir uns hierzu ein einfaches Anwendungsbeispiel an:

1. RetrieveCritaria rc = new RetrieveCritaria(Product.FOR_NAME);
2. rc.addSelectEqualTo(Product.PRICE, 10.0);
3. Iterator i = rc.perfom(db);
4. ...

Zunächst wird ein allgemeines Kriterium für die Datenbankanfrage erstellt. Anschließend fügt die Methode addSelectedEqualTo ein Filter hinzu, der alle Produktdatensätze ausschließt, die einen Preis ungleich 10.0 besitzen. Die Methode addSelectedEqualTo verfügt über zwei Parameter die übergeben werden müssen. Zum einen ist dies ein String, der den Feldnamen der Produkteigenschaft enthält und zum anderen wird der Wert übergeben, der zum Vergleich benutzt werden soll. Alle Filterfunktionen sind nach diesem Schema aufgebaut. Nachfolgend finden Sie eine Tabelle, die alle verfügbaren Filterfunktionen auflistet:

 
Es können natürlich mehrere Filter zu einem RetrieveCritaria-Objekt hinzugefügt werden, sodass Sie hiermit beliebige Filterungen durchführen können. Durch diese Vorgehensweise ersparen Sie sich das Erstellen von SQL-Abfragen.

Updateten und Löschen

Neben der Klasse RetrieveCriteria existieren außerdem noch die beiden Klassen UpdateCriteria und DeleteCriteria. Wie der Name der Klassen bereits vermuten lässt, wird UpdateCriteria eingesetzt, um Daten in der Datenbank zu aktualisieren und DeleteCriteria, um Daten zu löschen. Die Anwendung der Klassen geschieht analog zu RetrieveCriteria, es können folglich alle Filterfunktionen benutzt werden.

PersistanceManager

Kommen wir zum Schluss noch einmal auf die Klasse PersistanceManager zurück. In unseren bisherigen Beispielen sind wir davon ausgegangen, dass bereits ein Objekt peristanceManager existiert. Die Klasse PersistanceManager ist unter anderem dafür verantwortlich, dass die Konfigurationsdateien geladen werden können und somit eine Verbindung zur Datenbank hergestellt werden kann. Hier ist der Code zum initialisieren eines PersistanceManager-Objektes:

1. PersistanceManager persistanceManager = PersistanceManagerFactory.create();
2. Configuration conf = ConfigurationBuilder.build("conf.xml");
3. persistanceManager.setConfiguration(conf);
4. ....
6. peristanceManager.destroy();

Fazit

Hiermit sind wir am Ende unserer kleinen Einführung in das objekt-relationale Mapping mit Osage angekommen. Wie Sie an den Beispielen dieses Beitrages erkennen konnten, wird es mit Hilfe von Osage sehr einfach, auf Datenbanken zuzugreifen. Sie können durch das Mapping direkt mit Java-Objekten arbeiten und brauchen keinen speziellen SQL- bzw. JDBC-Code in ihr Projekt zu integrieren. Und nun wünsche ich Ihnen viel Spaß beim Testen von Osage.