"Elegantes" Füllen eines Models?

[Kababär]

Hi,

ich überlege mir gerade, wie ich am Elegantesten meine Models befüllen kann.
Zur Erläuterung:
Ich habe mehrere Textfiles, die ich einlesen möchte. Jedes Textfile ist quasi wie eine Tabelle aufgebaut, wobei die erste Zeile quasi die Spaltennamen sind.
Beispielsweise:

TEAM SPIELE    TORE   GEGENTORE    SIEGE    NIEDERLAGEN    TEAM_ID
"ALU"    "3"    "33"    "3"    "1"    "0"    "1"
"FELGE"    "3"    "70"    "3"    "1"    "0"    "2"
"MIT"    "3"    "351"    "4"    "1"    "0"    "3"
"EINEM"    "3"    "410"    "4"    "1"    "0"    "4"
"SCHUSS"    "3"    "832"    "4"    "1"    "0"    "5"
"SAURE"    "3"    "476"    "4"    "1"    "0"    "6"
"SAHNE"    "3"    "617"    "4"    "1"    "0"    "7"

Es gibt etliche solcher Dateien, die aber nicht die gleichen Spaltennamen haben, sondern anderen Werte benutzen.
Ich lese die Datei zeilenweise ein und splitte nach jedem Leerzeichen und möchte mit dem erhaltenen String[]-Array mein Model befüllen.
Die Reihenfolge der Variablen im Konstruktor des Models sind ja fest vorgeschrieben. Was ist aber, wenn sich die Reihenfolge der Spalten im Textfile ändert (auch unter Berücksichtigung, dass eventuell Spalten fehlen?)?
Wo mache ich am besten die Konvertierung von String zu int für das Model (Spiele, Tore, Gegentore, etc)?

Wäre über jeden Ratschlag dankbar

PS: Bisher nur den Code zum einlesen:

    public static void main(String[] args) {
        // TODO code application logic here
        List<String[]> arrList = new ArrayList<>();
        String pfad = "";
        File f = new File(pfad);
        try (BufferedReader br = new BufferedReader(new FileReader(f))) {
            String line;
            while ((line = br.readLine()) != null) {
                arrList.add(line.trim().split(" "));
            }
        } catch (IOException ex) {
            Logger.getLogger(GOAE.class.getName()).log(Level.SEVERE, null, ex);
        }

        arrList.stream().map(e -> Arrays.toString(e)).forEach(System.out::println);
    }

Mein Model besteht nur aus Objektattributen (pro Spalte ein Attribut mit der jeweiligen Bezeichnung), ein Konstruktor zum setzen der Werte sowie Getter.

 

[looparda]

Du musst dir in irgend einer Form ein Meta-Modell aufbauen, das die Datentypen der Spalten kennt. (Ich kann dir das nur examparisch zeigen um die Möglichkeiten aufzuzeigen)
Im einfachsten Fall sind Unterscheidungen im Code wie

if(spaltenname.equals("TORE")) {
    int tore = Integer.parse(spaltenvalue);
}

Wenn du die Typinformation auslagerst kannst du es zu sowas machen:

if(spaltenname.equals("TORE")) {
    int tore = metaModel.getValueFor("TORE", spaltenvalue);
    // das Beispiel hinkt etwas wegen fehlender Typinformation bei der Rückgabe
}

Wenn du es dynamisch machen willst, dann benutzt du einen Mapper wie Dozer oder Orika und formulierst dein Metamodell dort über Mappingregeln. Das ist vielleicht übertrieben aber kann man sich ja mal anschauen.

Wenn du zu einem Zeitpunkt Reflection nutzen willst für das Problem. Z.b. um Setter aufzurufen schau dir mal die Apache Commons BeanUtils an. Aber das kann auch noch viel mehr und hat vielleicht auch eine Art Mapper.

 

[Kababär]

Das klingt interessant, ist aber etwas overdosed für mein Beispiel, oder?
Als Idee kam mir gerade eben, dass im Konstruktor ja die Reihenfolge der Werte fest bestimmt sind.
Ich brauche also nur noch in meinem Model quasi ein Index-Pointer, der mir zurückliefert, wo denn welche Werte eingetragen werden bzw. mir die Reihenfolge gibt.
Beim Einlesen speichere ich mir die Indices der Spaltennamen und schreibe demnach eine Methode, welche die "Sortierung" übernimmt.

Bei deinem Beispiel wüsste ich nicht, wo ich hinschreiben könnte oder wie ich es realisieren könnte, wenn die Spalten mal vertauscht wären.

PS: Das ist so typisch. Ich weiß nicht mal ob die Spalten überhaupt irgendwann mal vertauscht sind, aber was wäre wenn? Müssen wir Programmierer alle "Was wäre wenn" Fälle abdecken?

 

[looparda]

Du möchtests halt gern den Konstruktor nutzen um dein Objekt zu initialisieren. Wenn du dich davon löst reduziert sich das Problem auf setter aufrufen. Dein default-Konstruktor könnte default-Werte in das Objekt schreiben, die es haben soll, falls keine weiteren Werte per setter gesetzt werden.

 

[mrBrown]

Oder Builder-Pattern nutzen, dann hast du Setter für deine einzelnen Werte, nutzt aber trotzdem den Konstruktor.

Als Idee kam mir gerade eben, dass im Konstruktor ja die Reihenfolge der Werte fest bestimmt sind.
Ich brauche also nur noch in meinem Model quasi ein Index-Pointer, der mir zurückliefert, wo denn welche Werte eingetragen werden bzw. mir die Reihenfolge gibt.
Beim Einlesen speichere ich mir die Indices der Spaltennamen und schreibe demnach eine Methode, welche die "Sortierung" übernimmt.

Oder 'ne Map nutzen Key ist der Spaltenname, Value dann der Wert. Zu jeder Spalte kennst du auch den Typ, musst den dann nur noch nach dem get aus der Map passend parsen.

 

[Kababär]

Was ist die bessere Variante, die von looparda oder von mrBrown?
Dass mit der Map habe ich jetzt auch hinter mir, hab die Idee quasi direkt umgesetzt.
Dann ich aber keine Beziehung bzw Information, wenn ich eine ganze Zeile aus x-beliebiger Reihe printen will.
Deshalb überlege ich, quasi ein Objekt zu erstellen, dass eine ganze Zeile mit den Spaltennamen repräsentiert?

 

[mrBrown]

Was ist die bessere Variante, die von looparda oder von mrBrown?

Je nachdem, was du besser findest Mit Default-Konstruktor erstellt man erstmal halt ein unvollständiges Objekt, wenn man Builder benutzt kann man den Fall verhindern, außerdem kann das Objekt immutable sein.

Dass mit der Map habe ich jetzt auch hinter mir, hab die Idee quasi direkt umgesetzt.
Dann ich aber keine Beziehung bzw Information, wenn ich eine ganze Zeile aus x-beliebiger Reihe printen will.
Deshalb überlege ich, quasi ein Objekt zu erstellen, dass eine ganze Zeile mit den Spaltennamen repräsentiert?

Eine Zeile wird ja dann durch dein Objekt repräsentiert, die Map braucht man nur zum überführen der Datei in die Objekte. Attributnamen entsprechen dann den Spaltennamen.

Man kann natürlich auch ZwischenObjekte nutzen, die dann Spaltenname->Wert für jede Zeile abbilden, das könnte man intern vermutlich auch mit einer Map lösen, aber wenn man es nicht braucht würde ich's lassen

 

[Kababär]

Gute Idee danke, dann werde ich das so machen.

Aus Neugier: Wie genau sähe denn so ein Code bspw. aus wenn ich es machen so möchte wie looparda es vorgeschlagen hat?

 

[mrBrown]

Ganz normales Objekt mit Gestern/Settern, Spaltennamen in einem Array, aktuelle Zeile gesplittet in einem zweiten.
Über Spaltennamen iterieren, switch über den aktuellen Namen, Wert entsprechend parsen und Setter aufrufen.

Reicht's oder brauchst du Code?

 

[Kababär]

Reicht danke

 

[Kababär]

Aber ich stoße gerade an ein Problem.
Mein Objekt enthält jetzt ein String[]-Array, das die Namen der Spalten beinhaltet in der richtigen Reihenfolge, auch String[]-Array, das initialisiert wird, wenn der Konstruktor aufgerufen wird (Entweder kann man ein String[]-Array oder ein String übergeben, welcher mit einer Switch Case an die richtige Stelle geparsed wird).
Für die erste Zeile brauche ich ja so etwas wie ein "init", um herauszufinden, wo welche Spaltennamen sind, damit ich weiß, wo welche Werte stehen. So was wie Default-Positionen für die Spalten.
Das habe ich mit einer for-Schleife mit laufendem Index gelöst, aber da ein Objekt ja nur eine Zeile enthält, weiß ich nicht, wie ich diese Default-Werte für jedes Objekt abspeichere. Denn bei der zweiten Zeile habe ich die Information über die Spaltennamen nämlich nicht mehr, außer ich gehe hin, speichere mir die erste Zeile und übergebe die bei jedem neuen erzeugten Objekt als Argument mit... wäre aber unschön..
Ich könnte aber hingehen und könnte eine zweite Klasse dafür schreiben a la TeamDefault und die Default-Werte static final setzen?
Oder soll ich lieber eine Liste angelegen, so dass ein Objekt das ganze File repräsentiert?
Wäre aber auch doof, weil es Performance-Probleme gäbe, denn ich müsste bei 10 Dateien quasi 10 mal über alle Dateien drüber laufen (denn es können ja Abhängigkeiten zwischen Teams bestehen).

 

[mrBrown]

Welches Objekt enthält die Arrays? Der Parser oder dein Model?
Das Model weiß im Idealfall nichts von irgendwelchen Strings, das sollte erstmal nur die Attribute mit passendem Typ enthalten.

Welche Default-Werte brauchst du denn? Wenn das Model welche hat, gehören die ins Model, oder in den entsprechenden Builder.

im Prinzip muss man nur die erste Zeile gesondert speichern, und danach alle weiteren in einer Liste (oder direkt parsen). Wenn alles 'ne ID hat, macht es uU Sinn, die direkt in eine Map zu legen.
Mehrmals Dateien einlesen muss man nicht, wenn man sie einmal eingelesen hat, hat man sie ja schon. Abhängigkeiten kann man dann auflösen, wenn alles gelesen wurde.


Vllt versteh ich grad aber auch das Problem nicht...

 

[looparda]

Kannst du bitte deinen Code posten? Da kann man besser verstehen wo das Problem ist.

 

[looparda]

Ich habe es mal mit den BeanUtils versucht - es funktioniert wie ich erwartet habe. Die Library nimmt einem auch das Meta-Modell ab - da alle Properties erstmal Strings sind und sie beim Setter-Aufruf in den jeweiligen Typen geparst werden.

 

[Kababär]

Ok, als erstes der Code:
Klasse:Tore; besteht zunächst nur aus Gettern und Setter... und einer kleinen Logik, die falsche Reihenfolge zu behandeln.

ublic class Tore {

    private static final String[] sArr = new String[]{"TEAM", "SPIELE", "TORE", "GEGENTORE",
        "Siege", "NIEDERLAGEN", "TEAM_ID"};

    private String[] currentLine = new String[5];
    private int teamPos;
    private int teamspielePos;
    private int torePos;
    private int gegentorePos;
    private int siegePos;
    private int niederlagenPos;
    private int teamIdPos;

    private final int defTeamPos = 0;
    private final int defSpielePos = 1;
    private final int defTorePos = 2;
    private final int defGegentorePos = 3;
    private final int defSiegePos = 4;
    private final int defNiederlagenPos = 5;
    private final int defTeamIdPos = 6;

    public Tore(String str) {
        fillColIndicesString(str);
    }

    public Tore(String[] arr) {
        fillColIndices(arr);
    }

    private void fillColIndicesString(String sr) {
        fillColIndices(sr.split("\\s+"));
    }

    private void fillColIndices(String[] arr) {
        for (int i = 0; i < arr.length; i++) {
            switch (arr[i].trim().toLowerCase()) {
                case "team":
                    setTeamPos(i);
                    currentLine[defTeamPos] = arr[i];
                    break;
                case "spiele":
                    setSpielePos(i);
                    currentLine[defSpielePos] = arr[i];
                    break;
                case "tore":
                    setNiederlagenPos(i);
                    currentLine[defTorePos] = arr[i];
                    break;
                case "siege":
                    setSiegePos(i);
                    currentLine[defSiegePos] = arr[i];
                    break;
                case "niederlagen":
                    setNiederlagenPos(i);
                    currentLine[defNiederlagenPos] = arr[i];
                    break;
                case "team_id":
                    setTeamIdPos(i);
                    currentLine[defTeamIdPos] = arr[i];
                    break;
                default:
                    currentLine[i] = null;

            }
        }
    }

    public int getTeamPos() {
        return teamPos;
    }

    public void setTeamPos(int teamPos) {
        this.teamPos = teamPos;
    }

    public int getSpielePos() {
        return teamspielePos;
    }

    public void setSpielePos(int teamspielePos) {
        this.teamspielePos = teamspielePos;
    }

    public int getTorePos() {
        return torePos;
    }

    public void setTorePos(int torePos) {
        this.torePos = torePos;
    }

    public int getGegentorePos() {
        return gegentorePos;
    }

    public void setGegentorePos(int gegentorePos) {
        this.gegentorePos = gegentorePos;
    }

    public int getSiegePos() {
        return siegePos;
    }

    public void setSiegePos(int siegePos) {
        this.siegePos = siegePos;
    }

    public int getNiederlagenPos() {
        return niederlagenPos;
    }

    public void setNiederlagenPos(int niederlagenPos) {
        this.niederlagenPos = niederlagenPos;
    }

    public int getTeamIdPos() {
        return teamIdPos;
    }

    public void setTeamIdPos(int teamIdPos) {
        this.teamIdPos = teamIdPos;
    }

}

Also wie man sieht, will ich quasi Parser und Model "vereinigen".
So sieht bisher eine Klasse für ein File aus, jedes File würde nun so eine Klasse bekommen.

Wenn ich jetzt zeilenweise meine Datei auslese und ein Objekt pro Zeile erzeuge, hab ich nur in einem einzigen Objekt die Info über die Spaltennamen und in alle anderen quasi die Werte.
Wo bzw wie soll ich den Parser nun dazu kriegen, dass alle anderen Objekte korrekt initialisiert werden?
Ich brauche also irgendwo Default-Werte, die mir angeben, in welcher Spalte welcher Name vorkommt.

 

[mrBrown]

Also wie man sieht, will ich quasi Parser und Model "vereinigen".

Genau das würde ich nicht machen - Single-Responsibility-Prinzip
Eine Klasse sollte immer nur eine Aufgabe machen, dann läufst du auch nicht in die Probleme, die du grad hast

 

[looparda]

Du vermischst hier die Zuständigkeiten - dein Modell ist ein simples Datenobjekt, das keinerlei Logik beinhaltet. Besser aufsplitten!

 

[Kababär]

Also wirklich strikt:
Model ist mein Container. Sobald da auch nur die kleinste Logik drin ist, sofort in eine andere Klasse auslagern?
Also könnte ich mir jetzt so was wie ein Mapping anlegen, deren Werte ich über "static" beziehe?
Denn ansonsten stauen sich ja die Parameter bei Methoden, etc.
Kann ich die split-Funktionen auch in die Mappingklasse hauen oder mir quasi so was wie ein StringUtil bauen?

 

[mrBrown]

Model ist mein Container. Sobald da auch nur die kleinste Logik drin ist, sofort in eine andere Klasse auslagern?

Jein, der Logikteil des Models kann uU auch im Model bleiben (wobei das jeder anders sieht, und die Frage ist, was man als Logik bezeichnet), das Parsen des Models aus einer Datei sollte aber woanders hin.

Also könnte ich mir jetzt so was wie ein Mapping anlegen, deren Werte ich über "static" beziehe?
Denn ansonsten stauen sich ja die Parameter bei Methoden, etc.

was meinst du mit "über 'static' beziehen"?
Ich habs grad einmal probiert (2 Arrays, drüber iterieren, Builder füllen), keine Methode hat dabei mehr als einen Parameter, was sollte sich da irgendwo stauen?

Kann ich die split-Funktionen auch in die Mappingklasse hauen oder mir quasi so was wie ein StringUtil bauen?

#split gibts doch schon?
Die einzige Funktion im Parser mit mehreren Zeilen ist bei mir nur die Zuordnung Spaltenname->Setter, die könnte man uU auslagern, macht aber bei dem kurzem Teil den ich hab (noch) keinen Sinn.

 

[Kababär]

Vielleicht stehe ich gerade nur auf dem Schlauch, ich glaube schon, ja

 

[mrBrown]

Vielleicht stehe ich gerade nur auf dem Schlauch, ich glaube schon, ja

'Nen Schritt zurück und noch mal neu losgehen wirkt manchmal Wunder