Datenbanken, Java - von am Thursday, November 29, 2007 22:52 - 0 Kommentare

Eine kurze Einführung in db4o

Was ist eine objektorientierte Datenbank? Objekte werden direkt in der Datenbank gespeichert und aus dieser wieder ausgelesen. Die objektorientierte Programmiersprache wird zur Abfragesprache der Daten aus der Datenbank. Kein relationaler Datenbankentwurf und keine Abfragen in SQL sind mehr nötig. Lassen Sie uns gemeinsam die ersten Schritte in db4o gehen, indem wir ein einfaches Objekt Auto erstellen, speichern und wieder auslesen.

Sind Sie neugierig geworden? Artikel und Links rund um das Thema objektorientierte Datenbanken finden Sie auf dem englischsprachigen Portal zum Thema: http://www.odbms.org. Suchen Sie weitere Informationen über das Open-Source-Projekt db4o, so können Sie folgende Website besuchen: http://www.db4o.de.

Installation von db4o

Beginnen wir mit der Installation: Es ist kein Installationsvorgang im üblichen Sinne notwendig, sondern nur ein Einbinden der entsprechenden Bibliothek. Laden Sie als Erstes die neueste Version von db4o von der Seite http://www.db4o.de herunter und entpacken Sie sie an einem Ort Ihrer Wahl. Im Verzeichnis lib finden Sie für die verschiedenen Java-Versionen jeweils eine Bibliothek mit der Endung *.jar, wobei die Version 5 sowohl Java 1.4 als auch 5 unterstützt. Sie müssen jetzt nur noch die Bibliothek Ihrem Projekt hinzufügen und schon können Sie db4o und alle seine Funktionalitäten nutzen.

In NetBeans fügen Sie Ihrem Projekt eine Bibliothek hinzu, indem Sie das entsprechende Projekt mit der rechten Maustaste anklicken, Properties und anschließend Libraries auswählen und mit dem Add JAR/Folder die Bibliothek hinzufügen.

In Eclipse müssen Sie ähnlich vorgehen: Klicken Sie mit der rechten Maustaste auf Ihr Projekt, wählen Properties und dann Java Class Path aus. Hier besteht in dem Register Libraries die Möglichkeit eine Bibliothek hinzufügen, indem Sie auf den Button “Add External JARs” klicken.

Wir erstellen eine Klasse Auto:

Wir wollen einige einfache Objekte speichern, so beginnen wir mit einer einfachen Klasse: der Klasse Auto. Sie soll nur einen Parameter, und zwar mit Namen name, zwei Konstruktoren und eine Getter- und eine Setter-Methode enthalten:

  1. package ErstesBeispiel;
  2.  
  3. public class Auto {
  4.    
  5.     private String name;
  6.    
  7.     /*Standardkonstruktor*/
  8.     public Auto() {
  9.     }
  10.    
  11.     /*Konstruktor mit dem Parameter name*/
  12.     public Auto(String name) {
  13.     this.name = name;
  14.     }
  15.    
  16.     /*Getter-Methode, die uns den Namen des Autos zurückgibt.*/
  17.     public String getName() {
  18.     return name;
  19.     }
  20.    
  21.     /*Setter-Methode, mit der wir den Namen des Autos festlegen können.*/
  22.     public void setName(String name) {
  23.     this.name = name;
  24.     }
  25.    
  26. }

Wie speichern wir dieses Auto in db4o?

Mit der Methode set(). Wo werden die Objekte gespeichert? In einer Datei mit der Endung *.yap. Diese Datei wird automatisch angelegt, wenn Sie beim ersten Mal eine Datenbank mit der Methode openFile() der Klasse Db4o öffnen und ein Objekt abspeichern. Betrachten wir, wie eine Methode speichern() konkret aussieht:

  1. package ErstesBeispiel;
  2.  
  3. import com.db4o.Db4o;
  4. import com.db4o.ObjectContainer;
  5. import com.db4o.ext.DatabaseFileLockedException;
  6.  
  7. public class AutoSpeichern {
  8.    
  9.     public void speichern(Auto auto){
  10.    
  11.     /*Wir öffnen eine Datenbank:*/
  12.     ObjectContainer db = Db4o.openFile
  13.         ("C:/Datenbank/EinfuehrungInDb4o/AutoDatenbank.yap");
  14.    
  15.     /*Der Vorgang muss in einem try/catch-Block stehen, da
  16.      im Falle eines Problems beim Speichern eine Exception
  17.      geworfen wird, die in dem catch-Block aufgefangen
  18.      werden muss .*/   
  19.     try{
  20.    
  21.         db.set(auto);
  22.     }
  23.     catch(DatabaseFileLockedException e){
  24.        
  25.         /*Im Falle von Komplikationen beim Speichern wird eine
  26.          Fehlermeldung ausgegeben.*/
  27.         e.printStackTrace();
  28.     }
  29.    
  30.     /*Zum Schluss muss die Datenbank wieder gelöscht werden.*/
  31.     finally{
  32.         db.close();
  33.     }
  34.     }  
  35. }

Wie werden die Objekte wieder ausgelesen?

Mit der Methode get(). Wie lesen Sie Objekte wieder aus? Es gibt in db4o drei Abfragekonzepte: Query-by-Example, S.O.D.A. und Native Queries. Im Rahmen dieses Artikels wollen wir uns auf Query-by-Example konzentrieren. Was versteht man unter Query-by-Example? Es wird ein Beispielobjekt erstellt, indem Sie dem Konstruktor des Objektes den Default-Wert eines Objektes übergeben, nämlich null. Handelt es sich um einen primitiven Datentyp, so ist der Default-Wert 0.

  1. Auto a = new Auto(null);

Wie sieht die entsprechende Methode dazu aus? Wie folgt:

  1. package ErstesBeispiel;
  2.  
  3. import com.db4o.Db4o;
  4. import com.db4o.ObjectContainer;
  5. import com.db4o.ObjectSet;
  6. import com.db4o.ext.DatabaseFileLockedException;
  7. import java.util.ArrayList;
  8.  
  9. public class AutoAuslesen {
  10.    
  11.     /*Wir lesen eine generische ArrayList<Auto> aus.*/
  12.     public ArrayList<Auto> auslesen(){
  13.        
  14.     ObjectContainer db = Db4o.openFile
  15.         ("C:/Datenbank/EinfuehrungInDb4o/AutoDatenbank.yap");
  16.    
  17.     /*Wir instanziieren eine generische ArrayList<Auto>.*/
  18.     ArrayList<Auto> arrayListAuto = new ArrayList<Auto>();
  19.    
  20.     try{
  21.        
  22.         /*Wir erstellen ein Beispielobjekt mit dem
  23.          Default-Wert null.*/
  24.         Auto auto = new Auto(null);
  25.        
  26.         /*Die Methode get() gibt ein ObjectSet zurück, das
  27.          alle Objekte der Klasse Auto enthält, die dem
  28.          Beispielobjekt entsprechen.*/
  29.         ObjectSet<Auto> result = db.get(auto);
  30.        
  31.         /*Solange es noch Autos im ObjectSet gibt,*/
  32.         while(result.hasNext()){
  33.        
  34.         /*sollen alle Autos der ArrayList<Auto> mit Namen
  35.          arrayListAuto hinzugefügt werden.*/
  36.         auto = result.next();
  37.         arrayListAuto.add(auto);
  38.         }
  39.        
  40.     }
  41.     catch(DatabaseFileLockedException e){
  42.         e.printStackTrace();
  43.     }
  44.     finally{
  45.         db.close();
  46.     }
  47.     return arrayListAuto;
  48.     }
  49. }

War das nicht einfach? Die Objekte werden mit Methoden von Java abgespeichert und wieder ausgelesen, SQL wird überflüssig.

Wir werden jetzt beide Methoden testen: Wir speichern zwei Objekte der Klasse Auto, ein Auto mit Namen „Rennwagen“ und ein Auto mit Namen „Kleinwagen“.

  1. package ErstesBeispiel;
  2.  
  3. public class Speichern {
  4.    
  5.     public static void main(String[ ] args){
  6.    
  7.     Auto rennwagen = new Auto("Rennwagen");
  8.     Auto kleinwagen = new Auto("Kleinwagen");
  9.    
  10.     AutoSpeichern autoSpeichern = new AutoSpeichern();
  11.     autoSpeichern.speichern(rennwagen);
  12.     autoSpeichern.speichern(kleinwagen);
  13.    
  14.     }
  15. }

Anschließend lesen wir sie wieder aus und erhalten auf der Konsole als Ausgabe alle Objekte der Klasse Auto:

  1. package ErstesBeispiel;
  2.  
  3. import java.util.ArrayList;
  4.  
  5. public class Auslesen {
  6.    
  7.     public static void main(String[] args){
  8.    
  9.     AutoAuslesen autoAuslesen = new AutoAuslesen();
  10.     ArrayList<Auto> autos = autoAuslesen.auslesen();
  11.    
  12.     for(Auto a : autos){
  13.         System.out.println("Name des Autos: " + a.getName());
  14.     }
  15.    
  16.     }
  17. }

Ausgabe:

Name des Autos: Kleinwagen
Name des Autos: Rennwagen

Wie werden bestimmte Objekte wieder ausgelesen?

Nehmen wir an, Sie wollen nur den Rennwagen auslesen, so benötigen wir ein Beispielobjekt mit Namen „Rennwagen“:

  1. Auto a = new Auto("Rennwagen“);

Wir bauen dieses Beispielobjekt in eine Methode ein, die ein bestimmtes Auto aus der Datenbank ausliest:

  1. package ErstesBeispiel;
  2.  
  3. import com.db4o.Db4o;
  4. import com.db4o.ObjectContainer;
  5. import com.db4o.ObjectSet;
  6. import com.db4o.ext.DatabaseFileLockedException;
  7. import java.util.ArrayList;
  8.  
  9. public class AutoAuslesenEinzeln {
  10.    
  11.     /*Wir lesen ein Objekt der Klasse Auto aus.*/
  12.     public Auto auslesenEinzeln(String name){
  13.        
  14.     ObjectContainer db = Db4o.openFile
  15.         ("C:/Datenbank/EinfuehrungInDb4o/AutoDatenbank.yap");
  16.    
  17.     Auto a = new Auto();
  18.    
  19.     try{
  20.        
  21.         /*Wir erstellen ein Beispielobjekt mit dem String name*/
  22.         Auto auto = new Auto(name);
  23.        
  24.         /*Die Methode get() gibt ein ObjectSet zurück, das
  25.          genau ein Auto enthält, das exakt dem Beispielobjekt
  26.          entspricht.*/
  27.         ObjectSet<Auto> result = db.get(auto);
  28.        
  29.         /*Das bestimmte Objekt wird aus dem ObjectSet ausgelesen.*/
  30.         a = result.next();
  31.        
  32.     }
  33.     catch(DatabaseFileLockedException e){
  34.         e.printStackTrace();
  35.     }
  36.     finally{
  37.         db.close();
  38.     }
  39.     return a;
  40.     }
  41. }

Wenden wir die Methode auslesenEinzeln() an, erhalten wir als Ergebnis auf der Konsole den gewünschten Rennwagen:

  1. package ErstesBeispiel;
  2.  
  3. import java.util.ArrayList;
  4.  
  5. public class AuslesenEinzeln {
  6.    
  7.     public static void main(String[] args){
  8.    
  9.     String name = "Rennwagen";
  10.     AutoAuslesenEinzeln autoAuslesenEinzeln = new AutoAuslesenEinzeln();
  11.     Auto auto = autoAuslesenEinzeln.auslesenEinzeln(name);
  12.    
  13.     System.out.println("Name des Autos: " + auto.getName());
  14.    
  15.     }
  16. }

Ausgabe:

Name des Autos: Rennwagen

Mit den Abfragekonzepten S.O.D.A. und Native Queries stellt db4o zwei weitere Abfragekonzepte vor, die es Ihnen ermöglicht zusätzlich komplexe Abfragen durchzuführen. Somit steht db4o in Nichts anderen Datenbank nach.

Sourcecode zum Artikel

Sourcecode: Eine kurze Einführung in die objektorientierte Datenbank db4o

Weiterführende Literatur

Eine ausführliche Einführung zum Thema db4o gibt Ihnen das Buch „The Definitive Guide to db4o“ von Stefan Edlich, Henrik Hörning, Raidar Hörning und Jim Paterson, das leider bisher nur in englischer Sprache erschienen ist.

Wollen Sie sich nur kurz über die wichtigsten Features informieren, empfehle ich Ihnen das kleine Büchlein „db4o. schnell + kompakt“ von Patrick Römer und Larysa Visengeriyeva.

Interessieren Sie sich mehr für Webanwendungen, Servlets und JSPs, könnte Sie mein Buch, “Datenbankentwicklung mit db4o – Einführung in eine objektorientierte Datenbank“, interessieren: Ich erkläre anhand eines kleinen Content-Management-Systems, programmiert in Java und umgesetzt mit NetBeans, die wichtigsten Funktionalitäten von db4o.

Be Sociable, Share!


Kommentare

Kommentieren

Weitere Empfehlungen: