# Datenbankabfragen kapseln



## mare (13. Apr 2010)

Hallo zusammen,

nach langer langer Suche im Internet habe ich mich entschlossen meine Frage hier zu posten. Meine Java- und OO-Kenntnisse sind nicht gerade die besten, deshalb verzeiht mir, falls ich irgendwo einen falschen Fachausdruck nutze oder einen total dummen Ansatz habe.

Also zu meinem Problem. 
Ausgangssituation: 
Ich habe mehrere Klassen die alle von einer Oberklasse namens "Modul" erben. Nun ist es so, dass all diese Unterklassen von Modul, (welche teilweise unterschiedliche Attribute besitzen), bzw deren Instanzen in einer Datenbank gespeichert, abgerufen, gelöscht, geupdated und so weiter, werden sollen.

Und da habe ich gedacht, dass es ganz vielleicht irgendein Pattern oder sonstiges dazu gibt, dass ich nicht in jeder Unterklasse die Methoden (update(), insert() und soweiter) haben muss um auf die Datenbank zuzugreifen. Also dass ich die irgendwie abstrahieren kann. 

Bisheriger Ansatz:
Ich habe ein Interface DatabaseHandlings

```
public interface DatabaseHandling {

    /**
     * liefert alle Einträge, Beispielsweise alle Behäter von Behälter
     */
    public ArrayList<String> getAllElements();

    // speichert das aktuelle Objekt in der Datenbank
    public void save();

    // aktualisiert das aktuelle Objekt in der Datenbank
    public void update();
    
    
}
```

Dann habe ich eine Klasse "SimpleDataBaseHandling" welches das Interface implementiert

```
public class SimpleDatabaseHandling implements DatabaseHandling{

    private DBConnection dbcon = DBConnection.
            getDBConnection("jdbc:mysql://localhost/mydb", "root", "");


   public ArrayList<String> getAllElements() {
             //Code
    }

    public void save() {
            //Code
    }

    public void update() {
        //Code
    }

}
```

So dann natürlcih meine Klasse Modul

```
public abstract class Modul {
    DatabaseHandling databaseHandling;
            

    public ArrayList<String> getAllElements() {
        return databaseHandling.getAllElements();
    }

    public void save() {
        databaseHandling.save();
    }

    public void update() {
        databaseHandling.update();
    }
}
```

und hier noch als Beispiel die Unterklasse Behälter

```
public class Behaelter extends Modul{
    private String bezeichnung; 
    private double laenge;
    private double breite;
    private double hoehe;

    public Behaelter()    {
        databaseHandling = new SimpleDatabaseHandling();
    }
}
```

Ziel der ganzen Sache:
Ich will in keiner meiner Unterklassen, wie beispielsweise Behälter, die "Datenbankzugriffsmethoden" implementieren. Die Klasse "SimpleDatabaseHandling" ist nur da, dass ich eventuell falls mal eine andere Datenbank ins Spiel kommen sollten ich einfach einer andere Klasse schreiben kann, die das Interface DatabaseHandling implementiert.

Achja obiger Code ist nicht ganz vollständig, es fehlen beispielsweise die Parameter der Methoden, denn an denen scheitert eigentlich mein ganzes Vorhaben. Da jede Unterklasse von Modul andere Attribute aufweist, weiss ich nicht so ganz wie ich dann die Datenbankabfragen in "SimpleDatabaseHandling" implementiere.

So also ich hoffe ich konnte einigermaßen rüberbringen was ich will :>

Gruß
Marius


----------



## SlaterB (14. Apr 2010)

löblicher Wunsch, 
von der Umsetzung ist noch nicht viel zu sehen, es gibt überhaupt keinen save-Code und es ist nicht ganz klar, ob der in eine Basisklasse kommt (und wie dann für beliebige Probleme passt) oder in Unterklassen,
vor allem aber: es fehlt jedwege Frage?! (falls nicht meine letzte Zeile die Frage war)

wenn man sich z.B. Hibernate anschaut, dann scheint mir persönlich ein anderer Ansatz passender:
die Datenklassen sind einfache Java-Objekte nur mit getter + setter
und es gibt eine DB-Lade-Klasse Session mit
session.save(object);
session.load(Class, Id);

in der ganzen Anwendung muss man quasi nur das eine Session-Objekt austauschen um die gesamte Persistenz umzustellen

edit: ok, ich sehe gerade dass dein DatabaseHandling im wesentlichen genau diese Session ist 
finde ich gut, nur ob man Module einsetzt oder nicht ist leicht fraglich


----------



## -MacNuke- (21. Apr 2010)

Du bist gerade auf dem Weg ein ORM zu entwickeln. Nimm ein fertiges (Hibernate, EclipseLink, OpenJPA, etc.) ist leichter


----------

