En el sistema de desarrollo de software, hay a menudo existe una estrecha unión entre "método solicitante" y "enfoque ejecutores". Esto no es propicio para la expansión y el mantenimiento de la funcionalidad del software. Por ejemplo, quieren llevar a cabo "deshacer, rehacer, ficha" y el procesamiento es muy incómodo, por lo que "el solicitante y el método de aplicación del método es como para desacoplar?" Se vuelve muy importante, el modo de comando puede ser una buena solución este problema.
En la vida real, hay muchos ejemplos de este tipo, por ejemplo, el control remoto del televisor (comando remitente) al televisor a través del botón de control remoto (mando específico) (receptores de órdenes), así como "teclas de función" y en el teclado del ordenador.
La definición y características del modo de comando
el modo de comando definido (Command) son los siguientes: encapsular una solicitud de un objeto, de modo que la ejecución de la solicitud y Responsabilidad solicitando separados. Este tipo de comunicación entre el objeto de comando tan fácil de objetos de comando para el almacenamiento, la transferencia, el recuerdo, y el aumento de la gestión.
La ventaja del modo de comando es la siguiente.
- Reducir el sistema de acoplamiento. funcionamiento en modo de comando se puede llamar el objeto y el objeto que implementa el desacoplamiento de la operación.
- Añadir o comando de eliminación es muy conveniente. Uso del modo de comando se incrementa con el comando de eliminación no afecta a las otras clases, que cumplen con el "principio de apertura y cierre" para extender más flexible.
- Macros se puede lograr. Modo de comando puede ser el modo combinado , en combinación, una pluralidad de combinaciones de órdenes ensamblada en un comando, es decir, un comando de macro.
- Facilitar la realización de operaciones de deshacer y rehacer. Modo de comando puede ser descrita más tarde con modo de notas en conjunción con la recuperación implementar un comando de deshacer.
Sus desventajas son: el comando puede tener numerosas clase específica. Debido a que la operación de conteo para cada necesidad particular para diseñar una clase de comando específico, esto aumentará la complejidad del sistema.
Arquitectura e Implementación del modo de comando
de comandos relacionados con el funcionamiento del sistema puede ser abstraído a la persona que llama asociado con la separación implementador, tiene la siguiente estructura.
1. Estructura Modelo
El modo de comando incluye el siguiente papel importante.
- Resumen de comandos de clase (Comando) Función: declarar una interfaz para ejecutar la orden, método abstracto tiene que ejecutar comandos se ejecutan ().
- papel comando específico papel (hormigón Comando): es una realización concreta de la clase clase abstracta de comandos, que tiene receptores objeto y la función mediante una llamada al destinatario para completar el comando de operación para ser ejecutado.
- Realización / receptor (receptor) función: realizar la función de comando de operaciones relacionado es darse cuenta de quién las órdenes específicas de los objetos de negocio.
- Los / Solicitante (Invoker) las funciones de llamada: la petición del emisor, por lo general tiene una gran cantidad de objeto de comando, y para poner en práctica la correspondiente solicitud accediendo al objeto de comando, que no accede directamente al destinatario.
La estructura mostrada en la Figura 1.
2. Modo de realización
Código de modo de comando es la siguiente:
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()方法被调用...");
}
}Resultados de operación del programa son los siguientes:
客户访问调用者的call()方法...
调用者执行命令command...
接收者的action()方法被调用...Ejemplos de aplicación de modo de comando
[Ejemplo 1] Los ejemplos lograr ir al cliente a un restaurante para comer el desayuno con el modo de comando.
Análisis: Los clientes pueden optar por ir a un restaurante con desayuno rollos de arroz, fideos de arroz y wonton, etc., los clientes pueden optar por varios camareros durante el desayuno, el camarero petición del cliente al chef conveniente formular. El punto aquí es el desayuno equivalente "orden", el camarero es equivalente a "llama", el chef equivalente de "receptor", que se consigue con el modo de comando apropiado.
En primer lugar, definir una clase desayuno (desayuno), que es una clase abstracta de comandos, método abstracto de cocina (), explique qué hacer, y luego definir subclases como rollos de arroz (ChangFen), clase raviolis (Huntun) y la clase (Pho Hefen), que es una clase específica de comandos que implementa la cocción () de clase desayuno, pero no lo hacen específicamente, pero al chef para hacer concreto; chef prepara clase concreta tienen rollos de arroz (ChangFenChef), raviolis Eclipse chef ( HunTunChef) y cook Pho (HeFenChef), que es el destinatario de la orden, ya que el presente ejemplo de la figura cocinar para cocinar pantalla ( representaciones que se muestran aquí para descargar ), por lo que el cocinero cada subclase se define como JFrame clase y, por último, la definición de la clase camarero (camarero), que recibe la solicitud del cliente para cocinar, cocinar y emitir el comando. clase de cliente por operadora clase la carta, la Fig. 2 es un diagrama de configuración de la figura.
Código es el siguiente:
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);
}
}Los resultados de ejecutar el programa mostrado en la Fig.
Escenarios modo de comando
El modo de comando se usa típicamente en la escena.
- Cuando el sistema requiere que la persona que llama tiene que ser desacoplado de la solicitud receptor, de modo de comando de modo que la persona que llama no interactúan directamente y el receptor.
- Cuando el sistema necesita solicitud de orden aleatorio o con frecuencia añadir o comando de eliminación, el modo de comando es más conveniente para implementar estas funciones.
- Cuando el sistema necesita para llevar a cabo un conjunto de operaciones, de modo de comando se puede definir para lograr esta función macros.
- Cuando el sistema tiene que apoyar comando Deshacer (la Deshacer) y la operación operación de recuperación (Redo), un objeto de comando puede ser almacenado, usando el modo memo se logra.
modo de comando extendida
En el desarrollo de software, a veces frente al modo de comando y aprender el modo de combinación se utiliza en combinación, lo que constituye un modo macro, también llamado modo de comando combinado. comando de macro que comprende un conjunto de comandos, que actúa como una doble función y comando específico de llamadas, la llamada recursiva que contiene todos los comandos que, cuando se ejecuta, se muestra su estructura específica en la Figura 3.
Código es el siguiente:
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()方法被调用...");
}
}Resultados de operación del programa son los siguientes:
客户访问调用者的execute()方法...
接收者的action1()方法被调用...
接收者的action2()方法被调用...Por supuesto, la misma nota puede comandar Modo (Memento) se usan en combinación, por lo que se convierte en un modo de comando revocable, que se describirá más adelante.
