Dans le système de développement de logiciels, il y a souvent il y a un couplage étroit entre « méthode demandeur » et « approche Implementers ». Ce n'est pas propice à l'expansion et le maintien de la fonctionnalité logicielle. Par exemple, veulent mener « undo, redo, record » et le traitement est très pratique, donc « le demandeur et la méthode de la mise en œuvre de la méthode comment faire pour découpler? » Devient très important, le mode de commande peut être une bonne solution ce problème.
Dans la vraie vie, il y a de nombreux exemples, par exemple, le contrôle de la télécommande du téléviseur (émetteur de commande) au téléviseur via le bouton de commande à distance (commande spécifique) (récepteurs de commande), ainsi que « touches de fonction » et sur le clavier de l' ordinateur.
La définition et les caractéristiques du mode de commande
le mode de commande défini (Command) sont les suivantes: encapsuler une requête pour un objet, de sorte que l' exécution de la requête et la responsabilité demandant séparés. Une telle communication entre l'objet de commande si facile à des objets commande pour le stockage, le transfert, le rappel et la gestion accrue.
L'avantage principal du mode de commande est la suivante.
- Réduire le système de couplage. Le fonctionnement en mode commande peut appeler l'objet et l'objet qui implémente le découplage de l'opération.
- Ajouter ou commande de suppression est très pratique. Utilisation du mode de commande augmente avec la commande de suppression ne modifie pas les autres classes, qui répondent le « principe d'ouverture et de fermeture » pour étendre plus souple.
- Les macros peuvent être obtenues. Mode de commande peut être mode combiné en combinaison, une pluralité de combinaisons de commande assemblé dans une commande, à savoir une macro - commande.
- Faciliter la réalisation des opérations d' annulation et Redo. Mode de commande peut être décrit plus loin en mode mémo conjointement avec la reprise mettre en œuvre une commande d'annulation.
Ses inconvénients sont: la commande peut avoir de nombreuses classe spécifique. Parce que l'opération de comptage pour chaque besoin particulier de concevoir une classe de commande spécifique, cela augmentera la complexité du système.
Architecture et mise en œuvre du mode de commande
Fonctionnement du système de commande liée peut être prélevée en l'appelant associé à la séparation de implementor, a la structure suivante.
1. Structure modèle
le mode de commande comprend le rôle majeur suivant.
- commande Résumé de la classe (Command) Rôle: déclarer une interface pour exécuter la commande, méthode abstraite doit exécuter des commandes d'exécution ().
- rôle de commandement spécifique de rôle (Command Concrete): est une réalisation concrète de la classe abstraite de classe Command, qui a des récepteurs objet et la fonction en appelant le destinataire à remplir la commande d'opération à exécuter.
- rôle de réalisation / récepteur (récepteur): exécuter la fonction de commande des opérations connexes est de réaliser qui les ordres spécifiques d'objets métier.
- Les rôles de l'appelant / demande (Invoker): la demande de l'expéditeur, il a généralement beaucoup d'objet de commande, et de mettre en œuvre la demande pertinente en accédant à l'objet de commande, il n'a pas accès directement au destinataire.
La structure représentée sur la figure 1.
2. Mode de réalisation
code de mode commande est la suivante:
package command;
public class CommandPattern
{
public static void main(String[] args)
{
Command cmd=new ConcreteCommand();
Invoker ir=new Invoker(cmd);
System.out.println("客户访问调用者的call()方法...");
ir.call();
}
}
//调用者
class Invoker
{
private Command command;
public Invoker(Command command)
{
this.command=command;
}
public void setCommand(Command command)
{
this.command=command;
}
public void call()
{
System.out.println("调用者执行命令command...");
command.execute();
}
}
//抽象命令
interface Command
{
public abstract void execute();
}
//具体命令
class ConcreteCommand implements Command
{
private Receiver receiver;
ConcreteCommand()
{
receiver=new Receiver();
}
public void execute()
{
receiver.action();
}
}
//接收者
class Receiver
{
public void action()
{
System.out.println("接收者的action()方法被调用...");
}
}Les résultats d'exploitation du programme sont les suivants:
客户访问调用者的call()方法...
调用者执行命令command...
接收者的action()方法被调用...Exemples d'application du mode de commande
[Exemple 1] Exemples réaliser vos déplacements à la clientèle à un restaurant pour prendre le petit déjeuner avec le mode de commande.
Analyse: Les clients peuvent choisir d'aller dans un restaurant ayant des rouleaux de riz petit déjeuner, les nouilles de riz et wonton, etc., les clients peuvent choisir de plusieurs serveur au petit déjeuner, le serveur demande au chef concerné du client à faire. Le point ici est le petit déjeuner équivalent « ordre », le serveur est équivalent à « appelant », l'équivalent chef du « récepteur », est réalisé avec le mode de commande appropriée.
Tout d' abord, définir un petit - déjeuner de classe (petit déjeuner), qui est une classe abstraite de commande, méthode abstraite cuisson (), expliquer ce qu'il faut faire, et ensuite définir les sous - classes comme des rouleaux de riz (Changfen), classe raviolis (HunTun) et classe Pho ( Hefen), qui est une classe de commande spécifique qui met en œuvre la méthode de cuisson () du petit - déjeuner de classe, mais ils ne le font pas spécifiquement, mais au chef pour faire du béton, chef cuisine de classe de béton ont des rouleaux de riz (ChangFenChef), raviolis éclipse le chef ( HunTunChef) et cuisinier Pho (HeFenChef), ils sont le destinataire de la commande, puisque le présent exemple de la figure cuire à cuire affichage ( rendus à afficher ici pour télécharger ), de sorte que le cuire chaque sous-classe est définie comme JFrame classe, enfin, la définition de serveur de classe (serveur), il reçoit la demande du client pour la cuisson, la cuisine et exécutez la commande. est un schéma de configuration de la figure classe client par agent de classe à la carte,. la figure 2.
Code est la suivante:
package command;
import javax.swing.*;
public class CookingCommand
{
public static void main(String[] args)
{
Breakfast food1=new ChangFen();
Breakfast food2=new HunTun();
Breakfast food3=new HeFen();
Waiter fwy=new Waiter();
fwy.setChangFen(food1);//设置肠粉菜单
fwy.setHunTun(food2); //设置河粉菜单
fwy.setHeFen(food3); //设置馄饨菜单
fwy.chooseChangFen(); //选择肠粉
fwy.chooseHeFen(); //选择河粉
fwy.chooseHunTun(); //选择馄饨
}
}
//调用者：服务员
class Waiter
{
private Breakfast changFen,hunTun,heFen;
public void setChangFen(Breakfast f)
{
changFen=f;
}
public void setHunTun(Breakfast f)
{
hunTun=f;
}
public void setHeFen(Breakfast f)
{
heFen=f;
}
public void chooseChangFen()
{
changFen.cooking();
}
public void chooseHunTun()
{
hunTun.cooking();
}
public void chooseHeFen()
{
heFen.cooking();
}
}
//抽象命令：早餐
interface Breakfast
{
public abstract void cooking();
}
//具体命令：肠粉
class ChangFen implements Breakfast
{
private ChangFenChef receiver;
ChangFen()
{
receiver=new ChangFenChef();
}
public void cooking()
{
receiver.cooking();
}
}
//具体命令：馄饨
class HunTun implements Breakfast
{
private HunTunChef receiver;
HunTun()
{
receiver=new HunTunChef();
}
public void cooking()
{
receiver.cooking();
}
}
//具体命令：河粉
class HeFen implements Breakfast
{
private HeFenChef receiver;
HeFen()
{
receiver=new HeFenChef();
}
public void cooking()
{
receiver.cooking();
}
}
//接收者：肠粉厨师
class ChangFenChef extends JFrame
{
private static final long serialVersionUID = 1L;
JLabel l=new JLabel();
ChangFenChef()
{
super("煮肠粉");
l.setIcon(new ImageIcon("src/command/ChangFen.jpg"));
this.add(l);
this.setLocation(30, 30);
this.pack();
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void cooking()
{
this.setVisible(true);
}
}
//接收者：馄饨厨师
class HunTunChef extends JFrame
{
private static final long serialVersionUID=1L;
JLabel l=new JLabel();
HunTunChef()
{
super("煮馄饨");
l.setIcon(new ImageIcon("src/command/HunTun.jpg"));
this.add(l);
this.setLocation(350, 50);
this.pack();
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void cooking()
{
this.setVisible(true);
}
}
//接收者：河粉厨师
class HeFenChef extends JFrame
{
private static final long serialVersionUID=1L;
JLabel l=new JLabel();
HeFenChef()
{
super("煮河粉");
l.setIcon(new ImageIcon("src/command/HeFen.jpg"));
this.add(l);
this.setLocation(200, 280);
this.pack();
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void cooking()
{
this.setVisible(true);
}
}Les résultats de l'exécution du programme représenté sur la figure.
Mode de commande de scénarios
le mode commande est généralement utilisée dans la scène.
- Lorsque le système exige que l'appelant doit être découplée de la demande du récepteur, le mode de commande pour que l'appelant ne réagit pas directement et le récepteur.
- Lorsque le système a besoin de demande un ordre aléatoire ou souvent ajouter ou commande de suppression, le mode de commande est plus commode de mettre en œuvre ces fonctions.
- Lorsque le système a besoin d'effectuer un ensemble d'opérations, le mode de commande peut être définie pour obtenir cette fonction macros.
- Lorsque le système doit prendre en charge la commande d'annulation (Undo) et l'opération de redressement (Refaire), un objet de commande peut être stockée, en utilisant le mode de mémoire est obtenue.
mode de commande Extended
Dans le développement de logiciels, parfois en face du mode de commande et de mode combinaison apprendre utilisé en combinaison, ce qui constitue un mode macro, également appelé mode de commande combinée. macro-commande comprenant un ensemble de commandes, il agit comme un double rôle et la commande spécifique de l'appelant, l'appel récursif qu 'elle contient toutes les commandes qui, lorsqu'elles sont exécutées, sa structure spécifique est représentée sur la figure 3.
Code est la suivante:
package command;
import java.util.ArrayList;
public class CompositeCommandPattern
{
public static void main(String[] args)
{
AbstractCommand cmd1=new ConcreteCommand1();
AbstractCommand cmd2=new ConcreteCommand2();
CompositeInvoker ir=new CompositeInvoker();
ir.add(cmd1);
ir.add(cmd2);
System.out.println("客户访问调用者的execute()方法...");
ir.execute();
}
}
//抽象命令
interface AbstractCommand
{
public abstract void execute();
}
//树叶构件: 具体命令1
class ConcreteCommand1 implements AbstractCommand
{
private CompositeReceiver receiver;
ConcreteCommand1()
{
receiver=new CompositeReceiver();
}
public void execute()
{
receiver.action1();
}
}
//树叶构件: 具体命令2
class ConcreteCommand2 implements AbstractCommand
{
private CompositeReceiver receiver;
ConcreteCommand2()
{
receiver=new CompositeReceiver();
}
public void execute()
{
receiver.action2();
}
}
//树枝构件: 调用者
class CompositeInvoker implements AbstractCommand
{
private ArrayList<AbstractCommand> children = new ArrayList<AbstractCommand>();
public void add(AbstractCommand c)
{
children.add(c);
}
public void remove(AbstractCommand c)
{
children.remove(c);
}
public AbstractCommand getChild(int i)
{
return children.get(i);
}
public void execute()
{
for(Object obj:children)
{
((AbstractCommand)obj).execute();
}
}
}
//接收者
class CompositeReceiver
{
public void action1()
{
System.out.println("接收者的action1()方法被调用...");
}
public void action2()
{
System.out.println("接收者的action2()方法被调用...");
}
}Les résultats d'exploitation du programme sont les suivants:
客户访问调用者的execute()方法...
接收者的action1()方法被调用...
接收者的action2()方法被调用...Bien sûr, le même mémo peut mode mode de commande (Memento) utilisé en combinaison, de sorte qu'il devient un mode de commande révocable, qui sera décrit plus loin.
