Patrons de conception/Commande

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche
Patrons de conception
Patrons de conception
Sommaire
Patron de conception
Catégorie: « Gang of Four »Comportement
Nom français : Commande
Nom anglais : Command
Encapsuler l'invocation d'une commande

Commande est un patron de conception de type comportemental qui encapsule la notion d'invocation. Il permet de séparer complètement le code initiateur de l'action, du code de l'action elle-même. Ce patron de conception est souvent utilisé dans les interfaces graphiques où, par exemple, un item de menu peut être connecté à différentes Commandes de façons à ce que l'objet d'item de menu n'ait pas besoin de connaître les détails de l'action effectuée par la Commande.

À utiliser lorsque : il y a prolifération de méthodes similaires, et que le code de l'interface devient difficile à maintenir.

Symptômes:

  • Les objets possèdent trop de méthodes publiques à l'usage d'autres objets.
  • L'interface est inexploitable et on la modifie tout le temps.
  • Les noms des méthodes deviennent de longues périphrases.

Un objet Commande sert à communiquer une action à effectuer, ainsi que les arguments requis. L'objet est envoyé à une seule méthode dans une classe, qui traite les Commandes du type requis. L'objet est libre d'implémenter le traitement de la Commande par un switch, ou un appel à d'autres méthodes (notamment des méthodes surchargées dans les sous-classes). Cela permet d'apporter des modifications aux Commandes définies simplement dans la définition de la Commande, et non dans chaque classe qui utilise la Commande.

Diagramme de classes[modifier | modifier le wikicode]

Le patron de conception Commande peut être représenté par le diagramme de classes UML suivant :

Diagramme de classes UML du patron de conception Commande

Utilisations[modifier | modifier le wikicode]

Ce patron de conception peut être utilisé pour implémenter divers comportements :

Défaire sur plusieurs niveaux
Les actions de l'utilisateur sont enregistrées par empilement de commandes. Pour les défaire, il suffit de dépiler les dernières commandes et d'appeler leur méthode undo() pour annuler chaque commande.
Comportement transactionnel
La méthode d'annulation est appelée rollback() et permet de revenir en arrière si quelque chose se passe mal au cours d'une transaction (un ensemble de commandes). Exemples : installateurs de programmes, modification de base de données.
Barre de progression
Si chaque Commande possède une méthode d'estimation de durée, il est possible de représenter la progression de l'exécution d'un ensemble de tâches (Commandes).
Menu et boutons (interface graphique)
En Swing et Delphi, un objet Action est une Commande à laquelle on peut associer un raccourci clavier, une icône, un texte d'info-bulle ...
Wizards
Pour implémenter les boîtes de dialogue de type Wizard, une instance de Commande est créée. Chaque fois que l'utilisateur passe à la page suivante avec le bouton "Suivant" ("Next" en anglais), les valeurs entrées sont enregistrées dans la Commande. Le bouton "Terminer" ("Finish" en anglais) provoque l'exécution de la Commande.
Ensemble de threads (ThreadPool en anglais)
Un ensemble de threads exécute des tâches (Commandes) stockées dans une file.
Enregistrement de macros
Chaque action de l'utilisateur peut être enregistrée sous la forme d'une séquence de Commande qui peut être rejouée par la suite. Pour enregistrer les macros sous la forme de scripts, chaque commande possède une méthode toScript() pour générer le script correspondant.

Exemple[modifier | modifier le wikicode]

Java[modifier | modifier le wikicode]

Considérons un interrupteur simple (switch en anglais). Dans cet exemple, on configure le switch avec deux commandes : une pour allumer la lumière, et une pour l'éteindre.

L'avantage de cette implémentation particulière du patron Commande est que l'interrupteur peut être utilisé avec n'importe quel périphérique, pas seulement une lampe. Dans l'exemple suivant l'interrupteur allume et éteint une lampe, mais le constructeur accepte toute classe dérivée de Command comme double paramètre. On peut, par exemple, configurer le switch pour démarrer et arrêter un moteur.

/* Invocateur */
public class Switch
{
    private Command flipUpCommand;
    private Command flipDownCommand;

    public Switch(Command flipUpCmd,Command flipDownCmd)
    {
        this.flipUpCommand=flipUpCmd;
        this.flipDownCommand=flipDownCmd;
    }

    public void flipUp()
    {
        flipUpCommand.execute();
    }

    public void flipDown()
    {
        flipDownCommand.execute();
    }
}

/* Récepteur */
public class Light
{
    public Light() {  }

    public void turnOn()
    {
        System.out.println("The light is on");
    }

    public void turnOff()
    {
        System.out.println("The light is off");
    }
}

/* Commande */
public interface Command
{
    void execute();
}


/* Commande concrète pour allumer la lumière */
public class TurnOnCommand implements Command
{
    private Light theLight;

    public TurnOnCommand(Light light)
    {
        this.theLight=light;
    }

    public void execute()
    {
        theLight.turnOn();
    }
}

/* Commande concrète pour éteindre la lumière */
public class TurnOffCommand implements Command
{
    private Light theLight;

    public TurnOffCommand(Light light)
    {
        this.theLight=light;
    }

    public void execute()
    {
        theLight.turnOff();
    }
}

/* Classe de test */
public class TestCommand
{
    public static void main(String[] args)
    {
        Light lamp = new Light();
        Command switchUp=new TurnOnCommand(lamp );
        Command switchDown=new TurnOffCommand(lamp );

        Switch s=new Switch(switchUp,switchDown);

        s.flipUp();
        s.flipDown();
    }
}

Perl[modifier | modifier le wikicode]

  # exemple de style "switch":
 
  sub doCommand {
    my $me = shift;
    my $cmd = shift; $cmd->isa('BleahCommand') or die;
    my $instr = $cmd->getInstructionCode();
    if($instr eq 'PUT') {
      # PUT logic here
    } elsif($instr eq 'GET') {
      # GET logic here
    }
    # etc
  }
 
  # exemple de style "appel de méthode":
  
  sub doCommand {
    my $me = shift;
    my $cmd = shift; $cmd->isa('BleahCommand') or die;
    my $instr = $cmd->getInstructionCode();
    my $func = "process_" . $instr;
    return undef unless defined &$func;
    return $func->($cmd, @_);
  }
 
  # exemple de style "sous-classe".
  # on suppose que %commandHandlers contient une liste de pointeurs d'objets.
 
  sub doCommand {
    my $me = shift;
    my $cmd = shift; $cmd->isa('BleahCommand') or die;
    my $insr = $cmd->getInstructionCode();
    my $objectRef = $commandHandlers{$instr};
    return $objectRef ? $objectRef->handleCommand($cmd, @_) : undef;
  }

Comme Perl dispose d'un AUTOLOAD, le principe pourrait être émulé. Si un package voulait effectuer un ensemble de commandes arbitrairement grand, il pourrait recenser toutes les méthodes undefined grâce à AUTOLOAD, puis tenter de les répartir (ce qui suppose que %commandHandlers contient une table de pointeurs, dont les clés sont les noms des méthodes):

  sub AUTOLOAD {
    my $me = shift;
    (my $methodName) = $AUTOLOAD m/.*::(\w+)$/;
    return if $methodName eq 'DESTROY';
    my $objectRef = $commandHandlers{$methodName};
    return $objectRef ? $objectRef->handleCommand($methodName, @_) : undef;
  }

Cela convertit les appels aux différentes méthodes dans l'objet courant, en appels à une méthode handleCommand dans différents objets. Cet exemple utilise Perl pour adapter un patron de conception à base d'objets Commandes, dans une interface qui en est dépourvue.