Java modo gráfico diseño de modo de comando
los requisitos del proyecto de vida inteligente
Mira una demanda concreta
- Hemos comprado un conjunto de casa inteligente categoría de aparatos, hay luces, ventiladores, refrigeradores, lavadoras, siempre y cuando instalamos la aplicación puede controlar estos aparatos funcionan en el teléfono.
- Estos aparatos inteligentes de diferentes fabricantes, no queremos que los aparatos se instalan para cada una aplicación, control, respectivamente, sólo queremos que una aplicación puede controlar todos los aparatos inteligentes.
- Para implementar un necesidades de aplicaciones para controlar todos los aparatos inteligentes, entonces cada uno fabricantes de electrodomésticos inteligentes tienen que proporcionar una interfaz unificada para la aplicación a la llamada, entonces se puede considerar el uso del modo de comando.
- El modo de comando "de operación solicitante" desacoplamiento de "hacedor de la acción" objeto.
- En nuestro ejemplo, la acción de la solicitante es una aplicación de teléfono móvil, a cada hacedor de la acción es un vendedor de electrodomésticos.
Introducción básica al modo de comando
- En el diseño de software, a menudo necesitamos para enviar una petición a ciertos objetos, pero no sabe quién es el destinatario de la solicitud, que no sabemos es que la operación solicitada, sólo tenemos que ejecutar el programa: modo de comando (Patrón de comandos) solicitud específica para el receptor, ahora se puede utilizar para diseñar el modo de comando
- El modo de comando hace que el remitente petición o solicitud de destinatario para eliminar el acoplamiento entre sí , de modo que las llamadas entre los objetos más flexible y lograr desacoplamiento .
- En el modo de comando, solicitará un paquete para un objeto, utilizando diferentes parámetros con el fin de representar diferentes solicitudes (es decir, nombre), mientras que el modo de comando también es compatible con las operaciones de deshacer.
- entendimiento claro: General emitió una orden a los soldados para hacerlo. Hay varios papeles: General (emisor de comandos), soldados (comandos específicos ejecutor de comandos), (generales de conexión y soldados).
Invocador es la persona que llama (general), receptor es la persona que llama (soldados), MyCommand es un comando, para implementar la interfaz de comandos, sosteniendo el objeto receptor
Diagrama de clases del principio de modo de comando
ilustrativa diagrama de clases de los principios de:
1) invocador es el papel de la persona que llama
2) Comando: un papel de comando, todos los comandos a ejecutar están aquí, o puede ser una clase abstracta
3) Receptor: el papel del receptor, sabe cómo implementar y ejecutar una solicitud de operación relacionada
4) ConcreteCommand: un objeto receptor a una acción de unión, el destinatario llama al funcionamiento correspondiente logra ejecutar
package com.example.demo.command;
/**
* 创建命令接口
* @author zhaozhaohai
*
*/
public interface Command {
/**
* 执行动作（操作）
*/
public void execute();
/**
* 撤销动作（操作）
*/
public void undo();
}
package com.example.demo.command;
public class LightOffCommand implements Command{
/**
* 聚合LightReceiver
*/
private LightReceiver LightReceiver;
public LightOffCommand(LightReceiver lightReceiver) {
this.LightReceiver = lightReceiver;
}
@Override
public void execute() {
// TODO Auto-generated method stub
LightReceiver.off();
}
@Override
public void undo() {
// TODO Auto-generated method stub
LightReceiver.on();
}
}
package com.example.demo.command;
public class LightOnCommand implements Command{
/**
* 聚合LightReceiver
*/
private LightReceiver LightReceiver;
public LightOnCommand(LightReceiver lightReceiver) {
this.LightReceiver = lightReceiver;
}
@Override
public void execute() {
// TODO Auto-generated method stub
// 调用接收者方法
LightReceiver.on();
}
@Override
public void undo() {
// TODO Auto-generated method stub
// 调用接收者方法
LightReceiver.off();
}
}
package com.example.demo.command;
public class LightReceiver {
public void on() {
System.out.println(" 电灯打开了。。。 ");
}
public void off() {
System.out.println(" 电灯关闭了。。。 ");
}
}
package com.example.demo.command;
/**
* 没有任何命令，即空执行 ：用于初始化每个按钮，当调用空命令时，对象什么都不做其实，这样是一种设计模式，可以省掉对空判断
* @author zhaozhaohai
*
*/
public class NoCommand implements Command{
@Override
public void execute() {
// TODO Auto-generated method stub
}
@Override
public void undo() {
// TODO Auto-generated method stub
}
}
package com.example.demo.command;
public class RemoteController {
// 开 按钮的命令数组
private Command[] onCommands;
private Command[] offCommands;
// 执行撤销的命令
private Command undoCommand;
/**
* 构造器，完成对按钮初始化
*/
public RemoteController() {
onCommands = new Command[5];
offCommands = new Command[5];
for (int i = 0;i < 5; i++) {
onCommands[i] = new NoCommand();
offCommands[i] = new NoCommand();
}
}
/**
* 给我们的按钮设置你需要的命令
* @param no
* @param onCommand
* @param offCommand
*/
public void setCommand(int no, Command onCommand, Command offCommand) {
onCommands[no] = onCommand;
offCommands[no] = offCommand;
}
/**
* 按下开按钮
* @param no
*/
public void onButtonWasPushed(int no) {
// 找到你按下的开的按钮，并调用对应的方法
onCommands[no].execute();
// 记录这次的操作，用于撤销
undoCommand = onCommands[no];
}
/**
* 按下关的按钮
* @param no
*/
public void offButtonWasPushed(int no) {
// 找到你按下的关的按钮，并调用对应方法
offCommands[no].execute();
// 记录这次的操作，用于撤销
undoCommand = offCommands[no];
}
/**
* 按下撤销按钮
*/
public void undoButtonWasPushed() {
undoCommand.undo();
}
}
package com.example.demo.command;
public class TVOffCommand implements Command{
/**
* 聚合TVReceiver
*/
private TVReceiver tvReceiver;
public TVOffCommand(TVReceiver tvReceiver) {
this.tvReceiver = tvReceiver;
}
@Override
public void execute() {
// TODO Auto-generated method stub
tvReceiver.off();
}
@Override
public void undo() {
// TODO Auto-generated method stub
tvReceiver.on();
}
}
package com.example.demo.command;
public class TVOnCommand implements Command{
/**
* 聚合TVReceiver
*/
private TVReceiver tvReceiver;
public TVOnCommand(TVReceiver tvReceiver) {
this.tvReceiver = tvReceiver;
}
@Override
public void execute() {
// TODO Auto-generated method stub
tvReceiver.on();
}
@Override
public void undo() {
// TODO Auto-generated method stub
tvReceiver.off();
}
}
package com.example.demo.command;
public class TVReceiver {
public void on() {
System.out.println(" 电视机打开了。。。 ");
}
public void off() {
System.out.println(" 电视机关闭了。。。 ");
}
}
package com.example.demo.command;
public class Client {
public static void main(String[] args) {
// 使用命令设计模式，完成通过遥控器，对电灯的操作
// 创建电灯的对象（接受者）
LightReceiver lightReceiver = new LightReceiver();
// 创建电灯相关的开关命令
LightOnCommand lightOnCommand = new LightOnCommand(lightReceiver);
LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver);
// 需要一个遥控器
RemoteController remoteController = new RemoteController();
// 给遥控器设置命令，比如 no = 0 是电灯的开和关的操作
remoteController.setCommand(0, lightOnCommand, lightOffCommand);
System.out.println("----------按下开的按钮------------");
remoteController.onButtonWasPushed(0);
System.out.println("----------按下关的按钮------------");
remoteController.offButtonWasPushed(0);
System.out.println("----------按下撤销的按钮------------");
remoteController.undoButtonWasPushed();
System.out.println("----------使用遥控器操作电视机-------");
TVReceiver tvReceiver = new TVReceiver();
TVOffCommand tvOffCommand = new TVOffCommand(tvReceiver);
TVOnCommand tvOnCommand = new TVOnCommand(tvReceiver);
// 给遥控器设置命令，比如 no = 1 是电视机的开和关的操作
remoteController.setCommand(1, tvOnCommand, tvOffCommand);
System.out.println("----------按下开的按钮------------");
remoteController.onButtonWasPushed(1);
System.out.println("----------按下关的按钮------------");
remoteController.offButtonWasPushed(1);
System.out.println("----------按下撤销的按钮------------");
remoteController.undoButtonWasPushed();
}
}
análisis de código fuente de la aplicación del modo de comando JdbcTemplate en el Marco del resorte
Descripción:
- interfaces de StatementCallback, similar a la interfaz de comandos (Command)
- QueryStatementCallback clase implementa StatementCallback, SqlProvider, clase interna anónima que implementa la interfaz de comandos, sino que también actúa como un receptor de órdenes
- Comando es el método llamante JdbcTemplate, que ejecutar (acción StatementCallback), el método de llamada action.doInStatement, diferentes objetos para lograr interfaz StatementCallback, correspondiente a diferente lógica implementada doInStatement
- También cuenta StatementCallback interfaz de comandos subclase también QueryStatementCallback, BatchUpdateStatementCallback, ExecuteStatementCallback, UpdateStatementCallback
Notas y detalles del modo de comando
1) El desacoplamiento del objeto de origen y la solicitud de ejecución objeto solicitado. Objeto que originó la petición es la persona que llama, la persona que llama simplemente ejecutar el objeto de comando () puede permitir que el destinatario de trabajo, sin necesidad de conocer el destinatario específico que es el objeto, es la forma de lograr, para que el destinatario será responsable de la solicitud de ejecución objeto de comando la acción, es decir: el desacoplamiento entre el "iniciador de la demanda" y "ejecutivo solicitud" se logra a través del objeto de comando, objeto de comando actúa como un puente de enlace.
2) fácil de diseñar una cola de comandos. Siempre y cuando el objeto de comando en la cola, puede realizar comandos multi-roscado.
3) fácil de implementar deshacer y rehacer la solicitud de
4) falta de modo de comando: Algunos sistemas pueden conducir a la clase de comando concreto excesiva, aumentar la complejidad de tales sistemas, el uso de este punto en el tiempo para prestar atención a
comandos 5) está vacía un patrón de diseño, elimina vaciar el funcionamiento condenado por nosotros. En el ejemplo anterior, si no hay un comando de aire, cada vez que pulse un botón para ser condenado vacía, esto traerá algunos problemas de codificación.
6) Modo de comando escenario clásico: una interfaz de botón es un comando que simule CMD (comando de DOS) órdenes de deshacer / rehacer, disparador - mecanismo de retroalimentación
