Design patterns
Patrón de comando

Ejemplo de patrón de comando en Java

definición de wikipedia :

El patrón de comando es un patrón de diseño de comportamiento en el que un objeto se utiliza para encapsular toda la información necesaria para realizar una acción o desencadenar un evento en un momento posterior

Diagrama UML de dofactory :

Componentes básicos y flujo de trabajo:

1. Command declara una interfaz para los comandos abstractos como execute()
2. Receiver sabe cómo ejecutar un comando en particular
3. Invoker posee ConcreteCommand , que debe ser ejecutado.
4. Client crea ConcreteCommand y asigna un Receiver
5. ConcreteCommand define el enlace entre Command y Receiver

De esta manera, el patrón de comando desacopla al remitente (cliente) del receptor a través del invocador . El Invoker tiene un conocimiento completo de qué Comando se ejecutará y el Comando sabe qué Receptor se debe invocar para ejecutar una operación en particular.

Fragmento de código:

interface Command {
    void execute();
}
class Receiver {
    public void switchOn(){
        System.out.println("Switch on from:"+this.getClass().getSimpleName());
    }
}
class OnCommand implements Command{
    private Receiver receiver;

    public OnCommand(Receiver receiver){
        this.receiver = receiver;
    }
    public void execute(){
        receiver.switchOn();
    }
}
class Invoker {
    private Command command;
  
    public Invoker(Command command){
        this.command = command;
    }
    public void execute(){
        this.command.execute();
    }
}

class TV extends Receiver{
    
    public String toString(){
        return this.getClass().getSimpleName();
    }
}
class DVDPlayer extends Receiver{
    
    public String toString(){
        return this.getClass().getSimpleName();
    }
}

public class CommandDemoEx{
    public static void main(String args[]){
        // On command for TV with same invoker 
        Receiver receiver = new TV();
        Command onCommand = new OnCommand(receiver);
        Invoker invoker = new Invoker(onCommand);
        invoker.execute();
        
        // On command for DVDPlayer with same invoker 
        receiver = new DVDPlayer();
        onCommand = new OnCommand(receiver);
        invoker = new Invoker(onCommand);
        invoker.execute();            
    }
}

salida:

Switch on from:TV
Switch on from:DVDPlayer

Explicación:

En este ejemplo,

1. La interfaz de comandos define el método execute() .
2. OnCommand es ConcreteCommand , que implementa el método execute() .
3. El receptor es la clase base.
4. TV y DVDPlayer son dos tipos de receptores , que se pasan a ConcreteCommand como OnCommand.
5. Invoker contiene el comando . Es la clave para separar el remitente del receptor .
6. El invocador recibe OnCommand -> que llama a Receiver (TV) para ejecutar este comando.

Al usar Invoker, puedes encender TV y DVDPlayer. Si extiendes este programa, también apagarás TV y DVDPlayer.

Casos de uso clave:

1. Para implementar el mecanismo de devolución de llamada.
2. Implementar funcionalidad deshacer y rehacer.
3. Mantener un historial de comandos.