Welches Pattern kann ich nutzen?

[diggaa1984]

hallo, bissel unglücklich die Themenwahl, aber ich versuch mein Glück

Also folgender Sachverhalt:
Ich habe in einem MVC-Gebilde einen Controller, welcher die reine Datenmanipulation beinhaltet. Er wird nur durch andere Controller aufgerufen. Sprich wenn jemand nen Knopf drückt oder nen Menüeintrag etc. wird der jeweilige ViewController angesprochen, und dieser ruft bei Bedarf (wenn die Funktion des Buttons es vorsieht) den Datencontroller auf, und soll ihm mitteilen was der Nutzer grad machen möchte (neuer Datensatz, Datensatz löschen, Datensatz ändern, alle ändern etc.).

Bei jeder Manipulation prüfe ich ob gewissen Sachen eingehalten werden (null-prüfung und weiss der geier was), daher einen zentralen Daten-Controller.

So der Aufruf für den Datencontroller sah in meiner Vorstellung grob so aus:

public class DataController {
    
    //Befehle
    //irgendwie n public Enum "request" mit den möglichen Befehlen drin (ADD, REMOVE, ADDALL, CHANGE, REMOVEALL ...

    public boolean handleRequest(request r, FooData d) {
        switch(r) {
            .... //aufruf privater Methoden für spezifischen Befehl
        }
    }
}

der Controller beinhaltet also alle Befehle die von aussen aufgerufen werden können.

Mir schwirrte nun immer der Begriff "Command-Pattern" durch den Kopf, was ich so recht noch nicht genutzt hab. Aber mir scheint als wäre es das richtige, doch wenn ich mir das hier anschaue, zweifel ich ein wenig. Das Auslagern der Befehle in extra Klassen is mir suspekt. In meiner Variante wäre doch alles beim Controller gut aufgehoben.

Eventuell gibts ein anderes Pattern, was mehr in meine Vorstellung passt, oder soll ich einfach meine Idee umsetzen?

Bitte um eure Meinung.

 

[Gast]

http://java.sun.com/developer/technicalArticles/javase/mvc/

Mediator
http://de.wikipedia.org/wiki/Vermittler_(Entwurfsmuster)

 

[diggaa1984]

war ich ja gar nich so verkehrt mit meiner Intuition etwas derart aufzubauen. Muss ich nur nochma das Umfeld dieses Controllers gestalten, da war ich mir bisher net ganz sicher, aber das Sun-Tut was du gelinkt hast sah ganz gut aus. :###

 

[Marco13]

Naja, ist schwer da was zu sagen, wenn man den Zusammenhang nicht genau kennt. Reicht der Controller nur "geprüfte" aufrufe an das Modell weiter? Kann der Controller direkt ein Listener für die View sein? Um wie viele Requests geht es? Dort ein switch mit 1000 case's zu machen wäre unschön.... Vielleicht kann man die ja noch irgendwie gruppieren ... also (sinngemäß!!!) nicht

 enum request {ADD, REMOVE, ADDALL, CHANGE, REMOVEALL ... }

    public boolean handleRequest(request r, FooData d) {
        switch(r) {
            .... //aufruf privater Methoden für spezifischen Befehl
        }

sondern vielleicht

    public void add(Item ... items) { ... }
    public void remove(Item ... items) { ... }
    public void change(Item ... items) { ... }

oder so - aber wie gesagt, das ist nur Stochern im Trüben...

 

[byte]

Der Switch ist in der Tat Käse. Mach pro Operation ein Command (oder auch schlicht Action genannt).

Wenn Du Swing verwendest, kannst Du auch ganz einfach Swing Actions dafür benutzen. Das hat den Vorteil, dass Du diese direkt an verschiedenen Teilen der GUI einbinden kannst (MenuBars, ToolBars, ...).
Mit Hilfe einer Enum hast Du dann noch eine komfortable Factory für Deine Actions:

public enum Actions {
    ADD(new AddAction()),
    REMOVE(new RemoveAction()),
    CHANGE(new ChangeAction());
    
    private MyAction action;
    
    private Actions(MyAction action) {
        this.action = action;
    }
    
    public MyAction action() {
        return action;
    }
    
    public void perform(Object arg) {
        action().actionPerformed(new ActionEvent(arg, 0, ""));
    }
    
    public MyAction delegate(final String name, final Icon icon, final Object argument) {
        return new MyAction(name, icon) {
            public void actionPerformed(ActionEvent e) {
                Actions.this.perform(argument);
            }
        };
    }
    
    public void enable() {
        action.setEnabled(true);
    }
    
    public void disable() {
        action.setEnabled(false);
    }
}

 

[diggaa1984]

Reicht der Controller nur "geprüfte" aufrufe an das Modell weiter?

Ja, da ich versch. View-Controller habe (zwecks CardPanel-Nutzung), und diese allerdings beide Optionen zum Manipulieren der Daten bieten wollte ich an dieser Stelle die Prüfungen ob Manipulation stattfinden darf (wie zB. null-prüfung) nicht doppelt coden, und hab mich daher für den DatenController entschieden. Was nun doppelt wäre, ein einfacher Request an den Datencontroller, aber lieber so, also doppelte Prüfalgorithmen.

Kann der Controller direkt ein Listener für die View sein?

aus oben genannter Hierarchie eher weniger

Um wie viele Requests geht es?

grob geschätzt 10, viel mehr sollten es nicht werden.

Wenn Du Swing verwendest, kannst Du auch ganz einfach Swing Actions dafür benutzen. Das hat den Vorteil, dass Du diese direkt an verschiedenen Teilen der GUI einbinden kannst (MenuBars, ToolBars, ...).

das würde ganz spontan für mich bedeuten, das ich diese Aufrufe in den ViewControllern spare, und ein Klick automatisch durch das SwingFramework ne Action auslöst, die gleich direkt den DatenController anspricht?

Kannst mir mal bitte nen groben Ablauf angeben wie das nacheinander angesprochen wird von den Methoden her?
Hab noch net so die Erfahrung mit den Actions, aber wenn das mehr dem Konzept von Swing entspricht, hab ich nix dagegen das gleich für mein Programm zu verwenden. Aber das wäre dann schon CommandPattern oder, da es so aussieht also ob die einzelnen Actions extern beheimatet sind.

 

[diggaa1984]

*nochmal rauswühl*

dachte grad Actions und ActionsListener ham was miteinander zu tun, aber dem scheint ja net so, sind nur artverwandt ^^ ... kurz zu Actions die API belesen, und denke schon, dass dies die bessere Wahl wäre, da ich damit im Notfall gleich GUI-weit komponenten deaktivieren kann und so weiter. Sicherlich nicht verkehrt, auch wenn SUN die geringere Performanz des Ganzen erwähnt.

Da ich noch lange net am Programmieren bin, sondern noch am planen, noch kurz was zu fragem

Ich verstehe das mit dem Enum (speziell mit: ADD(new ...Action())) so, dass immer wenn ich eine Action aus dem Enum an eine Komponente hänge, das System eine neue Action erstellt, und ich quasi 5 Action-Objekte habe die alle das selbe machen; oder wird beim enum nur ein Objekt erzeugt, und jede Nutzung stellt nur eine Referenz dar? (also speziell in dem Fall, mit explizitem Konstruktor).

Wären es mehrere Objekte, wäre das ja nicht nötig, auch wenns performanztechnisch nicht ins Gewicht fällt. Ein Actionobjekt für die jeweilige Action würde ja reichen, und ich würde dass dann per setAction an die Komponenten weiterleiten.


Und weiterhin würde ich dann in der actionPerformed der Actions direkt den Datencontroller ansprechen, und den jeweiligen View-Controller überspringen, welcher den Aufruf ja nur weiterleiten würde, ohne nötige Prüfungen. Ist ja in dem Sinne noch einigermaßen MVC-Konform, oder?


Und nochma zur Absicherung: ActionListener unterscheidet sich von den Actions nur dahingehend, dass er keine GUI-weiten PropertyChange-Broadcasts sendet?

Nachtrag: An welcher Stelle in dieser Swing-Action-Geschichte könnte ich denn diese ganzen Methoden des Enums aufrufen? Muss da nochma nachlesen wie scheint

 

[Landei]

dachte grad Actions und ActionsListener ham was miteinander zu tun, aber dem scheint ja net so, sind nur artverwandt

Action erbt von ActionListener, sie sind also mehr als "artverwandt": Überall wo ein ActionListener verlangt wird, kannst du auch eine Action übergeben.

 

[Marco13]

Ich verstehe das mit dem Enum (speziell mit: ADD(new ...Action())) so, dass immer wenn ich eine Action aus dem Enum an eine Komponente hänge, das System eine neue Action erstellt, und ich quasi 5 Action-Objekte habe die alle das selbe machen; oder wird beim enum nur ein Objekt erzeugt, und jede Nutzung stellt nur eine Referenz dar? (also speziell in dem Fall, mit explizitem Konstruktor).

Letzteres. "ADD" ist EIN konstantes Objekt - und zu diesem Objekt gehört EINE Action. Ich bin nicht 100% sicher, ob so eine Verbindung von Konstanten und Aktionen der Weisheit letzter Schluss ist, aber hab' gerade keine Zeit, darüber zu philosophieren...

Und weiterhin würde ich dann in der actionPerformed der Actions direkt den Datencontroller ansprechen, und den jeweiligen View-Controller überspringen, welcher den Aufruf ja nur weiterleiten würde, ohne nötige Prüfungen. Ist ja in dem Sinne noch einigermaßen MVC-Konform, oder?

MVC-Konform ... naja ... MVC ist kein "festes Schema", sondern eher eine abstrakte Idee, der man folgen sollte - wenn die View über eine Action direkt das Model verändert, dann ist die Action eben ein "kleiner Controller" - das ist erstmal nicht "falsch" - über den oben erwähnten Punkt müßte man aber nochmal nachdenken...

 

[diggaa1984]

wenn die View über eine Action direkt das Model verändert, dann ist die Action eben ein "kleiner Controller" - das ist erstmal nicht "falsch" - über den oben erwähnten Punkt müßte man aber nochmal nachdenken...

Ne die Action würde den Kontrollfluss in den Datencontroller lenken, und vielleicht nen Objekt zusammenstellen, damit der Datencontroller gleich alle nötigen Infos zum Manipulieren hat. Ob er dann manipuliert, wird erst dort entschieden.