Patrón de Comando

El patrón de comando (Command Pattern) es un patrón de diseño basado en datos que pertenece a los patrones de comportamiento.

El patrón de comando encapsula una solicitud como un objeto, lo que permite parametrizar clientes con diferentes solicitudes, poner en cola o registrar solicitudes, y admitir operaciones reversibles.

Diagrama de estructura del patrón de comando:

Introducción

Intención

Encapsular una solicitud como un objeto, permitiendo a los usuarios parametrizar clientes con diferentes solicitudes.

Problema principal que resuelve

  • Resuelve el problema del acoplamiento estrecho entre el solicitante y el ejecutor en sistemas de software, especialmente en escenarios donde se requiere registrar comportamientos, deshacer/rehacer o manejar transacciones.

Escenarios de uso

  • Cuando se necesita registrar comportamientos, deshacer/rehacer o manejar transacciones, se utiliza el patrón de comando para desacoplar al solicitante y al ejecutor.

Método de implementación

  • Definir la interfaz de comando: La interfaz que todos los comandos deben implementar.
  • Crear comandos concretos: Clases concretas que implementan la interfaz de comando y contienen métodos para ejecutar solicitudes.
  • Invocador: Mantiene el objeto de comando y desencadena la ejecución del comando.
  • Receptor: El objeto que realmente ejecuta el comando.

Código clave

  • Receptor (Receiver): El objeto real que ejecuta el comando.
  • Comando (Command): Define la interfaz para ejecutar comandos.
  • Invocador (Invoker): Punto de entrada que utiliza el objeto de comando.

Ejemplo de aplicación

  • Struts 1: ActionServlet actúa como Invoker, y las clases de la capa de modelo actúan como Command concretos.

Ventajas

  1. Reduce el acoplamiento: Se reduce el acoplamiento entre el solicitante y el ejecutor.
  2. Fácil de extender: Los nuevos comandos pueden agregarse fácilmente al sistema.

Desventajas

  • Demasiadas clases de comando: El sistema puede tener demasiadas clases de comando concretas, lo que aumenta la complejidad del sistema.

Consejos de uso

  • En una GUI, cada botón o elemento de menú puede considerarse como un comando.
  • Utilice el patrón de comando en escenarios que requieran simular operaciones de línea de comandos.

Notas importantes

  • Si el sistema necesita admitir operaciones de deshacer (Undo) y rehacer (Redo) de comandos, el patrón de comando es una opción adecuada.

Estructura

Se involucran principalmente los siguientes roles principales:

  • Comando (Command):

    • Define la interfaz para ejecutar operaciones, generalmente contiene unexecutemétodo, que se utiliza para invocar operaciones específicas.

  • Comando concreto (ConcreteCommand):

    • Implementa la interfaz de comando y se encarga de ejecutar operaciones específicas. Generalmente contiene una referencia al receptor, y completa el procesamiento de la solicitud invocando los métodos del receptor.

  • Receptor (Receiver):

    • Sabe cómo ejecutar las operaciones relacionadas con la solicitud; es el objeto que realmente ejecuta el comando.

  • Invocador/Solicitante (Invoker):

    • El objeto que envía el comando; contiene un objeto de comando y puede desencadenar la ejecución del comando. El invocador no procesa la solicitud directamente, sino que la transfiere al objeto de comando.

  • Cliente (Client):

    • Crea objetos de comando concretos, establece su receptor y entrega el objeto de comando al invocador para su ejecución.

Implementación

Primero creamos la interfaz que actúa como comandoOrder, y luego creamos la que actúa como solicitudStockClase. La clase de comando concretaBuyStockySellStock, implementa laOrderinterfaz y ejecutará el procesamiento real del comando. Cree la clase que actúa como objeto invocadorBroker, que acepta pedidos y puede realizar pedidos.

BrokerEl objeto utiliza el patrón de comando para determinar qué objeto ejecuta qué comando según el tipo de comando.CommandPatternDemoLa clase utiliza laBrokerclase para demostrar el patrón de comando.

Paso 1

Crear una interfaz de comando.

Order.java

public interface Order { void execute(); }

Paso 2

Crear una clase de solicitud.

Stock.java

public class Stock { private String name = "ABC"; private int quantity = 10; public void buy(){ System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] bought"); } public void sell(){ System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] sold"); } }

Paso 3

Crear clases de entidad que implementan laOrderinterfaz.

BuyStock.java

public class BuyStock implements Order { private Stock abcStock; public BuyStock(Stock abcStock){ this.abcStock = abcStock; } public void execute() { abcStock.buy(); } }

SellStock.java

public class SellStock implements Order { private Stock abcStock; public SellStock(Stock abcStock){ this.abcStock = abcStock; } public void execute() { abcStock.sell(); } }

Paso 4

Crear la clase invocadora de comandos.

Broker.java

import java.util.ArrayList; import java.util.List; public class Broker { private List<Order> orderList = new ArrayList<Order>(); public void takeOrder(Order order){ orderList.add(order); } public void placeOrders(){ for (Order order : orderList) { order.execute(); } orderList.clear(); } }

Paso 5

Utilice la clase Broker para aceptar y ejecutar comandos.

CommandPatternDemo.java

public class CommandPatternDemo { public static void main(String[] args) { Stock abcStock = new Stock(); BuyStock buyStockOrder = new BuyStock(abcStock); SellStock sellStockOrder = new SellStock(abcStock); Broker broker = new Broker(); broker.takeOrder(buyStockOrder); broker.takeOrder(sellStockOrder); broker.placeOrders(); } }

Paso 6

Ejecute el programa y muestre el resultado:

Stock [ Name: ABC, Quantity: 10 ] bought
Stock [ Name: ABC, Quantity: 10 ] sold
Otras extensiones