# GUI Entwicklung - welches Pattern?



## Cole (5. Nov 2010)

Hallo zusammen,
ich wollte mal fragen welche(s) Pattern ihr für die GUI Entwicklung einsetzt?
Builder Pattern? Factorys? "Komponente extenden" (zB SuperButton extends JButton)? Scheiss-egal-hauptsache-es-klappt? 

Wo seht ihr die Vor- und Nachteile?

Danke für den Input!

Gruss


----------



## Cole (8. Nov 2010)

Niemand der Input liefern kann?


----------



## SlaterB (8. Nov 2010)

hey Handwerker, was setzt du alles für schicke Terrassen ein, Nägel, Hämmer, Sägen?
eine GUI ist ein Java-Programm und verwendet potentiell alles, mit selben Vor-/ Nachteilen wie überall anders auch

MVC ist ein Pattern welches man überwiegend nur in GUIs kennt

edit:
bzw. das ist ja gar kein Entwurfsmuster (design pattern), sondern ein Architekturmuster..
Entwurfsmuster ? Wikipedia
Architekturmuster ? Wikipedia


----------



## Marcinek (8. Nov 2010)

In unseren Framework haben wir von jeder benötigten Componente eine MyJButton Componente erstellt.

Diese ist erweitert um bestimmte Interfaces, die das befüllen und auslesen von Daten mittels generischen Ansätzen funktioniert.

Zum Beispiel kannst du eine Combobox mittels KeyValue Objekten, Strings, die KeyValue beschreiben oder Maps befüllen kannst.

Via Reflection können wir auch Felder von Objekten auf diverese Componenten Mappen... Bla bla

Eigentlich sollte man das auf sourceforge hochladen oder so ^^


----------



## Cole (8. Nov 2010)

Genau, es geht mir in erster Linie um Desing patterns.
Ich will einfach mal nur wissen, was ihr so verwendet. Bzw wie ihrs einsetzt.
ZB sagt "man" ja, dass man eine Komponente nur extenden soll, wenn man zusätzliche Funktionialität einbaut, aber nicht um zB nur die Farbe zu ändern.
Wie löst ihr denn solche Fälle? (gut, anderes L+F verwenden ist natürlich eine Möglichkeit, aber das ist hier nicht gemeint).


----------



## Gast2 (8. Nov 2010)

Cole hat gesagt.:


> Genau, es geht mir in erster Linie um Desing patterns.
> Ich will einfach mal nur wissen, was ihr so verwendet. Bzw wie ihrs einsetzt.
> ZB sagt "man" ja, dass man eine Komponente nur extenden soll, wenn man zusätzliche Funktionialität einbaut, aber nicht um zB nur die Farbe zu ändern.
> Wie löst ihr denn solche Fälle? (gut, anderes L+F verwenden ist natürlich eine Möglichkeit, aber das ist hier nicht gemeint).



Kommt auch auf dein Toolkit an... bei SWT kannst du von KEINEN komponenten erben, da sie nativ sind.

Sonst bietet sich für Widgets eine WidgetFactory an...


----------



## v Ralle v (8. Nov 2010)

Ich schreibe gerade an einem E-Mail Client und nutze MVC und ich konnte meine Entscheidung nicht besser treffen. Es lässt sich so leicht erweitern: einfach ein neues Action Objekt anlegen, ein neuer Button und das Action Objekt daran binden. Fertig. 

Zwar muss man erstmal das Modell umsetzen, aber einmal gemacht, spart man sich massig Zeit. Besonders praktisch: bei Teamarbeit können Mitglieder das Konzept fortsetzen ohne sich viel Gedanken um die Problembehandlung zu machen.

Kann ich nur empfehlen


----------



## Cole (10. Nov 2010)

Danke erst mal für den Input.
Werde hier posten wenn ich / wir uns entschieden haben wie wir das umsetzen wollen.


----------



## Guybrush Threepwood (10. Nov 2010)

Hi Cole,
das hängt vermutlich auch von der Komplexität des Projekts ab. MVC finde ich für kleine Progrämmchen immer ziemlich überdosiert. Für große Sachen kommt man vermutlich nicht drum rum.


----------



## ARadauer (10. Nov 2010)

> MVC finde ich für kleine Progrämmchen immer ziemlich überdosiert


ja stimmt schon, aber das ist OO auch ;-)

Die Frage ist halt dan was ist klein und bleibt das Programm klein?
Ehe du dich versiehst hast du einen 150000 Zeilen Moloch den du nur noch mit der Pinzette anfassen kannst...


----------



## SlaterB (10. Nov 2010)

bei 150.000 Zeilen verwendet man die ersten 1000 auch nicht mehr, zumindest nicht im Originalzustand,
da hat man alles schon 3x neu organisiert..

also ich zumindest, mag sein dass andere das sofort richtig hinbekommen


----------



## KSG9|sebastian (10. Nov 2010)

welchen Sinn soll es haben zuerst die Design/ArchitekturPatterns auszuwählen um diese dann in die Anwendung zu pressen?

Wenn man gute Software entwickelt dann *ergeben* sich die DesignPatterns.

Implementiere ich die Anwendung mit vernünftiger Trennung zwischen UI/Model/Logik dann habe ich damit implizit schon eine Art MVC implementiert. Ob das nun MVC mittels Observer/Observable oder sonstwas ist macht keinen Unterschied.

Von eigenen UI-Toolkits halte ich gar nix. Meistens sind die Dinger nur dafür da um z.B. Daten besser an Controls binden zu können.

Oftmals wird sowas abgefackelt mittels irgendwelchen Interfaces..z.B:


```
public interface HasValue<T>{
   public T getValue();
   public void setValue(T value);
}
public interface HasMultipleValues<T>{
   public Collection<? extends T> getItems();
   public void setItems(Collection<? extends T> items);
}


class MyTextField implements HasValue<String>{...}
class MyCombo<T> implements HasValue<T>, HasMultipleValues<T>{...}
```


Finde ich nicht übermäßig schon und vor allem sehr wartungsintensiv.
Besser ist meiner Meinung nach diese Logik auszulagern in ein Bindingframework welches für verschiedene Komponenten weiß was es zu tun hat.


```
class ComboBoxBinding{
   // weiß wie es die Daten in eine Combobox bekommt
   // und auch wieder Daten zurückliefern kann
}

class MyApp{
   MyModel model = new MyModel();
   model.setPersonen(getPersonen());
   UI myUI = new MyUI();

   BindingHelper.addBinding(model, "personen", myUI, "comboPersonen.items");
}

class BindingHelper{
 
   public void addBinding(Object source, String sourcePath, Object target, String targetPath){
        ...
   }
}
```

BeansBinding macht das genau so. Größter Vorteil ist das die Bindings unabhängig von der UILibrary sind. Man kann auch von Swing auf SWT ändern oder das BindingFramework z.B. im Web verwenden.
Koppelt man die Logik an den UIToolkit muss man für jedes Framework (Swing, SWT, AWT, GWT...) eine Abstraktion schreiben - was in vielen Fällen gar nicht geht - siehe SWT und Vererbung (geht zwar aber sollte man unterlassen).


Ansonsten wüsste ich nicht was ich z.B. mit einem Factorypattern in der UI tun sollte?


----------



## Gast2 (10. Nov 2010)

KSG9|sebastian hat gesagt.:


> Ansonsten wüsste ich nicht was ich z.B. mit einem Factorypattern in der UI tun sollte?



Default werte schon vorher zu implementieren und nicht jedes mal den gleichen Code zu haben...
z.b. farben, layout sachen usw. 
Wie gesagt kommt aufs Toolkit an, gibt viele sinnvolle sachen.

Außerdem gibts es sehr wohl Berechtigungen für eigene Textfelder z.B. wenn man ein Bild im Textfeld haben will oder immer gleiche Suchfunktionen.

Sobald man das Widget mehrmals verwendet, sollte man sich etwas überlegen wie man es einfach wiederverwenden kann. Ob dann über Vererbung, Beziehung, Eigene Komponente usw. muss dann abgewägt werden.


----------



## Cole (12. Nov 2010)

Ich versuch mal ein konkretes Beispiel zu machen:
Ein Button soll eine gewisse Farbe haben und eine definierte Grösse.

Sag ich dann: 


```
public class MyButton extends JButton {

    public MyButton() {
        setSize(10, 10);
        setBackground(Color.BLUE);
    }

}
```

und dann der Aufruf


```
Button save = new MyButton();
Button cancel = new MyButton();
```

oder lieber eine FactoryMethode kreariren:

```
public JButton createMyButton() {
        JButton b = new JButton();
        b.setSize(10, 10);
        b.setBackground(Color.BLUE);
        return b;
    }
```

und dann als Aufruf:


```
Button save = createMyButton();
Button cancel = createMyButton();
```

(ist nur auf die schnelle zusammen geschrieben, Sachen wie ne Beschriftung wären n och von Vorteil...)

Das hat ja primär nichts mit MVC oder nicht zu tun, sondern mit der Erzeugung von GUI - Bestandteilen.


----------



## SlaterB (12. Nov 2010)

nicht mal mit GUI obwohl es da natürlich häufig vorkommt, da viel zu konfigurieren ist,

statische Methoden sind besser wenn möglich, wenn nicht zu voll


----------



## Gast2 (12. Nov 2010)

Jop eher statische Methoden...


----------



## JohannisderKaeufer (13. Nov 2010)

Den Einsatz von einem Builder, kann auch recht interessant sein.


```
class ButtonBuilder{
  Color background = null;
  public ButtonBuilder setBackground(Color color){
    background = color;
    return this;
  }
}

//dann per Vererbung oder Factory

class MyButton extends JButton{
  public MyButton(ButtonBuilder builder){
    if(builder.background!=null){
      this.setBackground(builder.background);
    }
  }
}

public static JButton createButton(ButtonBuilder builder){
  JButton button = new JButton();
  if(builder.background!=null){
    button.setBackground(builder.background);
  }
  return button;
}

ButtonBuilder builder = new ButtonBuilder().setBackground(Color.BLUE).setBackground(Color.BLACK);

JButton save = createButton(builder);
JButton cancel = createButton(builder);
```

Das erinnert mich irgendwie an das GridBagLayout und die Verwendung von GridbagConstraints (Builder) der beim Hinzufügen von Komponenten immer mitgegeben wird.


----------

