# Befehlsmuster



## kronzeuge (30. Jun 2006)

Hallo,

kann mir jemand erklären (vielleicht sogar anhand eines Beispiels) wie das Befehlsmuster, im englischen auch als command pattern bekannt, funktioniert? Leider komme ich mit den Klassendiagrammen in der UML-Notation nicht so zurecht.
Schon mal danke an Alle die mir den Schleier des Unwissens entfernen können.

Grüße
der Kronzeuge


----------



## Beni (30. Jun 2006)

Du hast irgendein Command...

```
public interface Command{
  public void work();
}
```
... und irgendeine Klasse welche Commands bearbeitet:

```
public class Worker{
  public void execute( Command cmd ){
    // z.B. in eine Queue stecken, und in einem anderen Thread abarbeiten.

    // die primitivste Version ist:
    cmd.work();
  }
}
```

Die Commands können verschiedene Dinge darstellen, z.B. eine Datei öffnen, einen Punkt verschieben...

```
public class OpenFile implement Command{
  private File file;

  public OpenFile( File file ){
    this.file = file;
  }

  public void work(){
    FileInputStream in = new FileInputStream( file );
    // etwas mit "in" machen...
  }
}
```

Soweit so uninteressant, spannend wirds, wenn die Commands zusätzliche Informationen bieten. Z.B. wenn sie ihren Fortschritt berechnen können, wenn man sie abbrechen kann, oder wenn sie auch eine "undo"-Methode bieten.
Nett ist auch, wenn die Commands erstmals in einer Queue gesammelt werden, und dann in einem anderen Thread verarbeitet werden (etwas, das man mit einfachen Methodenaufrufen nicht haben kann).


----------



## Wildcard (1. Jul 2006)

idR werden Commands im Zusammenhang mit Undo/Redo Funktionalität eingesetzt.
Es gibt unterschiedliche Wege sie zu verwenden:
1. Commands mit Sender und Empfänger
Funktionieren ähnlich wie Messages, nur das sie nicht benachrichtigen, sondern selbst etwas tun.

2. Commands mit CommandProcessor
Alle Commands werden auf einem CommandProcessor ausgeführt und von ihm in einem Undo-Stack verwaltet

3.Die GEF Variante (gefällt mir übrigens sehr gut)
Bei GEF gibt es sogenannte EditParts(Controller) die bestimmte Policies auf sich installieren können.
Empfängt der EditPart nun Events übernehmen die Policies und generieren gegebenenfalls Commands die eingesammelt werden und auf eine Queue gepackt werden.
Die Queue wird dann abgearbeitet und Undoable Commands nach deren Ausführung auf den Undo-Stack gelegt.

Häufig Verwendete Methoden bei Commands:


```
void execute()

boolean canExecute()

void undo()

boolean canUndo()

void redo()

boolean canRedo()
```


----------



## kronzeuge (1. Jul 2006)

Danke Euch beiden für die Antwort,

ich wollte das Befehlsmuster als Ersatz für das Fabrikmuster verwenden. So wollte ich das unschöne if, elseif umgehen, doch mir fehlt noch irgendwie die Idee wie ich die entsprechende Kommandoklasse ausführe, ohne es explizit in meinem Code einzubetten.

bye


----------



## byte (1. Jul 2006)

Das eine ist ein Erzeugungsmuster und das andere ein Verhaltensmuster. Ich bezweifel, dass Du die beiden kombinieren oder gegeneinander austauschen kannst.


----------



## Wildcard (1. Jul 2006)

Als Ersatz für das Fabrikmuster könntest du zB das Prototype Muster verwenden.


----------

