Commande (patron de conception)


Commande (patron de conception)

En génie logiciel, Commande est un patron de conception (design pattern) 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.

Sommaire

Exemple

Perl

  # 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.

Java

/*the Command interface*/
 
public interface Command{
    void execute();
}
 
 
 
/*the Invoker class*/
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();
    }
 
}
 
 
/*Receiver class*/
 
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");
     }
 
}
 
 
/*the Command for turning on the light - ConcreteCommand #1*/
 
public class FlipUpCommand implements Command{
 
   private Light theLight;
 
   public FlipUpCommand(Light light){
        this.theLight=light;
       }
 
   public void execute(){
      theLight.turnOn();
   }
 
}
 
 
 
/*the Command for turning off the light - ConcreteCommand #2*/
 
public class FlipDownCommand implements Command{
 
   private Light theLight;
 
   public FlipDownCommand(Light light){
        this.theLight=light;
       }
 
   public void execute(){
      theLight.turnOff();
   }
 
}
 
/*The test class or client*/
public class PressSwitch{
 
   public static void main(String[] args){
       Light lamp = new Light();
       Command switchUp=new FlipUpCommand(lamp );
       Command switchDown=new FlipDownCommand(lamp );
 
       Switch s=new Switch(switchUp,switchDown);
 
       try {
           if (args[0].equalsIgnoreCase("ON")){
                s.flipUp();
                System.exit(0);
           }
           if (args[0].equalsIgnoreCase("OFF")){
               s.flipDown();
               System.exit(0);
           }
           System.out.println("Argument \"ON\" or \"OFF\" is required.");
           } catch (Exception e){
            System.out.println("Argument's required.");
           }
 
   }
}


C#

using System;
 
//the Command Interface
public interface ICommand
{
        void Execute();
}
 
 
//The ConcreteCommands
public class DVDPlayCommand : ICommand
{
        public DVDPlayCommand(){}
        public void Execute()
        {
                Console.WriteLine("DVD Started.");
        }
}
 
public class DVDStopCommand : ICommand
{
        public DVDStopCommand(){}
        public void Execute()
        {
                Console.WriteLine("DVD Stopped.");
        }
}
 
public class VCRPlayCommand : ICommand
{
        public VCRPlayCommand(){}
        public void Execute()
        {
                Console.WriteLine("VCR Started.");
        }
}
 
public class VCRStopCommand : ICommand
{
        public VCRStopCommand(){}
        public void Execute()
        {
                Console.WriteLine("VCR Stopped.");
        }
}
 
 
//The Invoker
public class Remote
{
        public Remote(){}
        public void Invoke(ICommand cmd )
        {
                Console.WriteLine("Invoking.......");
                cmd.Execute();
        }
}
 
 
//The Client
public class Client
{
        public Client(){}
        public static int Main(String[] args)
        {
                //Instantiate the invoker object
                Remote remote = new Remote();
                //Instantiate DVD related commands and pass them to invoker object
                DVDPlayCommand dvdPlayCommand = new DVDPlayCommand();
                remote.Invoke(dvdPlayCommand);
                DVDStopCommand dvdStopCommand = new DVDStopCommand();
                remote.Invoke(dvdStopCommand);
                //Instantiate VCR related commands and pass them to invoker object
                VCRPlayCommand vcrPlayCommand = new VCRPlayCommand();
                remote.Invoke(vcrPlayCommand);
                VCRStopCommand vcrStopCommand = new VCRStopCommand();
                remote.Invoke(vcrStopCommand);
                return 0;
        }
}

Voir aussi

Sur les autres projets Wikimedia :


Wikimedia Foundation. 2010.

Contenu soumis à la licence CC-BY-SA. Source : Article Commande (patron de conception) de Wikipédia en français (auteurs)

Regardez d'autres dictionnaires:

  • Commande (Patron De Conception) — En génie logiciel, Commande est un patron de conception (design pattern) 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… …   Wikipédia en Français

  • Commande (Motif de conception) — Commande (patron de conception) En génie logiciel, Commande est un patron de conception (design pattern) 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… …   Wikipédia en Français

  • Commande (motif de conception) — Commande (patron de conception) En génie logiciel, Commande est un patron de conception (design pattern) 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… …   Wikipédia en Français

  • Patron de conception — Pour les articles homonymes, voir Patron. le patron Proxy En informatique, et plus particulièrement en développement logiciel, un patron de conception (en anglais  …   Wikipédia en Français

  • Memento (patron de conception) — Mémento (patron de conception) Le patron mémento est un patron de conception logiciel qui fournit la manière de renvoyer un objet à un état précédent (retour arrière) sans violer le principe d encapsulation. Le mémento est utilisé par deux objets …   Wikipédia en Français

  • Mémento (patron de conception) — Le patron mémento est un patron de conception logiciel qui permet de restaurer un état précédent d un objet (retour arrière) sans violer le principe d encapsulation. Le mémento est utilisé par deux objets : le créateur et le gardien. Le… …   Wikipédia en Français

  • Chaîne de responsabilité (patron de conception) — En génie logiciel, le patron de conception Chaîne de responsabilité permet à un nombre quelconque de classes d essayer de répondre à une requête sans connaître les possibilités des autres classes sur cette requête. Cela permet de diminuer le… …   Wikipédia en Français

  • Commande — Cette page d’homonymie répertorie les différents sujets et articles partageant un même nom. Sur les autres projets Wikimedia : « Commande », sur le Wiktionnaire (dictionnaire universel) Commande, dans le commerce, intention,… …   Wikipédia en Français

  • Patron de modélisation — Patron de conception Pour les articles homonymes, voir Patron. Un patron de conception (design pattern en anglais) est un concept de génie logiciel destiné à résoudre les problèmes récurrents suivant le paradigme objet. En français on utilise… …   Wikipédia en Français

  • Patron — Cette page d’homonymie répertorie les différents sujets et articles partageant un même nom. Sur les autres projets Wikimedia : « Patron », sur le Wiktionnaire (dictionnaire universel) Un patron (du latin patronus, «avocat» ou… …   Wikipédia en Français


Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”

We are using cookies for the best presentation of our site. Continuing to use this site, you agree with this.