Interface, mehrere Datenquellen

[IchBitteUmHilfe]

Hallo,

ich möchte ein Programm schreiben, dass sich Daten aus einer Datei ausliest. Später könnten evt. noch andere Datenquellen hinzukommen, wie müsste man das mit den Interface handhaben?

Interface:

public interface IReader
{

public String[] getData();

}

Klasse, welche aus Datei liest:

class DateiReader implements IReader {

public String[] getData()
{
   //lala
}

}

Klasse die aus Datenbank liest:

class DatabaseReader implements IReader {

public String[] getData()
{
   //lala
}


}

Hauptklasse:

class Anwendung {


}

Wie mache ich das denn jetzt am elegantesten in der Anwendung, dass ich später beim Hinzufügen anderer Datenquellen wenig Aufwand habe?

Einfach mit if-Abfragen?
Also:

class Anwendung {

   if(quelle.equels("Datei"))
   {
     DateiReader dateiR = new DateiReader();
   } else if(quelle.equels("Datenbank"))
   {
     DatabaseReader dbR = new DatabaseReader();
   }

}

Sieht mir falsch aus, weil ich danach ja doch wieder Programmieraufwand habe, je nachdem welche Quelle ich benutze...

P.S.: Den Code habe ich gerade frei Hand geschrieben, könnte syntaktisch falsch sein

 

[maki]

Wie mache ich das denn jetzt am elegantesten in der Anwendung, dass ich später beim Hinzufügen anderer Datenquellen wenig Aufwand habe?

DAO: http://java.sun.com/blueprints/corej2eepatterns/Patterns/DataAccessObject.html

 

[SlaterB]

das Interface nützt dir nur was, wenn du verschiedene Objekte gleich behandeln willst,

einen String zu parsen und anhand dessen ein bestimmtes Objekt zu erzeugen ist eine andere Aufgabe,
if else-Konstrukte sind dafür gar nicht mal so falsch

natürlich solltest du nirgendwo im Programm so einen String erzeugen und an anderer Stelle wieder parsen, falls du das meinst,
aber für einen externen Konigurationsparameter gibts wenig höhere Magie,

 

[IchBitteUmHilfe]

@maki: DAO liest sich so, als würde sich das nur auf Datenbankabfragen beziehen, allerdings habe ich das jetzt noch nicht komplett gelesen...

@slaterB: Das sollte später eigentlich so aussehen, dass in der Klasse Dateireader eine Datei eingelesen wird, die Informationen daraus in ein String[] geschrieben werden und dann an das Anwendungsprogramm zurückgegeben werden, welches diese dann darstellt/weiterverarbeitet etc.
Die DatabseReader, soll eigentlich das gleiche machen. Die Informationen (die von Ihrer Art gleich sind) aus der Datenbank lesen, in ein String[] schreiben und in das Anwendungsprogramm übergeben, welches dann wieder damit arbeitet.

Das Anwendungsprogramm soll es also nicht kümmern aus welcher Quelle die Daten stammen, deshalb dachte ich, wären die Interfaces dafür geeignet.

 

[maki]

@maki: DAO liest sich so, als würde sich das nur auf Datenbankabfragen beziehen, allerdings habe ich das jetzt noch nicht komplett gelesen...

Dann lies doch mal komplett

Das Anwendungsprogramm soll es also nicht kümmern aus welcher Quelle die Daten stammen, deshalb dachte ich, wären die Interfaces dafür geeignet.

Diesen Satz solltest du dort auch finden

 

[Guest]

So, da bin ich wieder.

Hatte mir das Beispiel von der Seite mal angeschaut und ausprobiert und ich frage mich, wie ich denn die Verbindungsparameter am geschikctesten übergeben kann.

Für die Datenbank den Host, username etc und für eine XML-Datei den Pfad zu Datei.
Ich wüßte nicht, wie ich das lösen könnte.

 

[Guest]

Kann keiner helfen?

Bei den Beispielen sind die Verbindungsdaten ja immer fest im Quellcode, aber ichmöchte die gerne über eine GUI eingeben können, aber ich weiß nicht wie ich die übergeben kann...

 

[maki]

Bin nicht sicher ob ich deine Frage richtig vertanden habe.


Hier nochmal das Beispiel, mit dieser Klasse bekommst du deine Konkrete Dao Factory:

// Abstract class Dao Factory
public abstract class DaoFactory {

  // List of Dao types supported by the factory
  public static final int ORACLE = 1;
  public static final int XML = 2;
  ...

  // There will be a method for each Dao that can be 
  // created. The concrete factories will have to 
  // implement these methods.
  public abstract KundeDao getKundeDao();
  ...

  public static DaoFactory getDaoFactory(
      int whichFactory) {
  
    switch (whichFactory) {
      case XML: 
          return new OracleDaoFactory();
      case ORACLE    : 
          return new XmlDaoFactory();      
      case SYBASE    : 
          return new SybaseDaoFactory();
      ...
      default           : 
          return null;
    }
  }
}

Über die Abstrakte Factory lässt du dir die unterschiedlichen konkreten Factories geben.


Hier die konkrete DaoFactory, da kommt die ganze DB Connection Initialisierungs-Logik:

// Oracle concrete Dao Factory implementation
import java.sql.*;

public class OracleDaoFactory extends DaoFactory {
  public static final String DRIVER=
    "COM.cloudscape.core.RmiJdbcDriver";
  public static final String DBURL=
    "oracle jdbc conn URL";

  // method to create Oracle connections
  public static Connection createConnection() {
    // Use DRIVER and DBURL to create a connection
    // Recommend connection pool implementation/usage
  }
  public KundeDao getKundeDao() {
    return new KundeOracleDaoImpl();
  }

  ...
}

Wie eine Verbindung (oder überhaupt) zu einer DB hergestellt wird, wird in der konreketen DaoFactory implentiert.
Die konkreten Factorys erben von der abstrakten und implmentieren die getxxxDao() methoden, in denen konkrete Daos zurückgegeben werden.



Das Herzstück, das Dao Interface:

public interface KundeDao {
    
    public Kunde findeKunden(Integer id);
    
    public List<Kunde> findeAlle();
}

Hier ein schematisches Beispiel für eine mögliche Implementierung, in dem die Oracle DB per JDBC abgefragt wird:

public class KundeOracleDaoImpl implements KundeDao{

    public KundeOracleDaoImpl( Connection conn );

    public Kunde findeKunden(Integer id) {
        Kunde kunde;
        
        // hier die DB abfragen und ein Kunde Objekt konstruieren
        
        return kunde;
    }
    
    public List<Kunde> findeAlle(); {
        List result= new ArrayList();
        
        // hier eine DB abfrage, das Ergebnis dann in result speichern
        
        return result;
    }
}

Beispiele:
So würde es im deinem Code aussehen, wenn du ein konkretes Kunde Dao holen würdest, welches die Daten aus einer Oracle DB holt:

KundeDao dao= DaoFactory.getDaoFactory( DaoFactory.ORACLE ).getKundeDao(); 

Kunde kunde= dao.getKunde( 1 );

List alleKunden= dao.getAlleKunden();

.. und so würde es im deinem Code aussehen, wenn du ein konkretes Kunde Dao holen würdest, welches die Daten aus XML holen soll:

KundeDao dao= DaoFactory.getDaoFactory( DaoFactory.XML ).getKundeDao(); 

Kunde kunde= dao.getKunde( 1 );

List alleKunden= dao.getAlleKunden();

Spätestens jetzt sollte dir etwas auffallen

Du brauchst in deinem "client code", in deinen Fachklassen, nur das KundeDao Interface zu benutzen, egal woher die Kundendaten kommen.
Wie eine bestimmte Datenquelle initialisiert wird, wird in den konkreten DaoFactorys festgelegt,
wie eine bestimmte Datenquelle abgefragt wird, wird in den konkreten Daos festgelegt.

Sieh dir nochmal die UML Diagramme an

 

[Guest]

Erstmal Danke für deine Mühe!

Das hatte ich bei mir soweit schon implementiert, funktioniert auch, allerdings sind wie auch in deinem Beispiel die "Zugangsdaten" zur DB im fest im Quellcode.
Ich wollte aber gerne, dass der User selber seinen Benutzernamen und Passwort über ein JPanel eingibt und ab da weiß ich nicht, wie ich diese Daten benutzen kann.

 

[maki]

Das hatte ich bei mir soweit schon implementiert, funktioniert auch, allerdings sind wie auch in deinem Beispiel die "Zugangsdaten" zur DB im fest im Quellcode.
Ich wollte aber gerne, dass der User selber seinen Benutzernamen und Passwort über ein JPanel eingibt und ab da weiß ich nicht, wie ich diese Daten benutzen kann.

Na gut, beim nächsten Frage ich besser nochmal nach bevor ich das offensichtliche wiederhole.. lol

Eine Möglichkeit wäre die zu deiner Anforderung passen könnte, wäre, den Benutzernamen und Passwort als paramter der abstrakten DaoFactory zu übergeben:

Deine abstrakte Factory würde so aussehen:

// Abstract class Dao Factory
public abstract class DaoFactory {

  // List of Dao types supported by the factory
  public static final int ORACLE = 1;
  public static final int XML = 2;
  ...

  // There will be a method for each Dao that can be
  // created. The concrete factories will have to
  // implement these methods.
  public abstract KundeDao getKundeDao();
  ...

  public static DaoFactory getDaoFactory(
      int whichFactory, String userName, String password) {
 
    switch (whichFactory) {
      case XML:
          return new OracleDaoFactory(userName, password);
      case ORACLE    :
          return new XmlDaoFactory(userName, password);     
      case SYBASE    :
          return new SybaseDaoFactory(userName, password);
      ...
      default           :
          return null;
    }
  }
}

In deinem Konkreten DaoFactories würdest du natürlich den passenden Konstruktor mitliefern

Später dann könntest du es so verwenden:

KundeDao dao= DaoFactory.getDaoFactory(DaoFactory.ORACLE, name, password).getKundeDao();

 

[Guest]

Hm stimmt, klingt eigentlich ganz plausibel, morgen mal ausprobieren.

Und nimm's nicht so schwer, viele werden es Dir danken, dass du dir solch eine Mühe gemacht hast

 

[maki]

Dieser Ansatz funktioniert nur für einen(!) Benutzer, und bestimmt möchtest du ja nicht jedesmal eine neue Connection aufbauen (?).

Besser wäre es, nicht jedesmal eine neue Factory mit new zu erzeugen, sondern eine statische Referenz auf die Factories zu haben und diese zurückzugeben.

Dann noch einen Konstruktor oder eine eine Init Methode in die konkreten Factories zu bauen, wo einmalig das Password und der Benutzername übergeben wird und eine Verbindung aufgebaut wird.