Método de comando: patrones de diseño de Python

Command Method es un patrón de diseño de comportamiento que encapsula una solicitud como un objeto, lo que permite la parametrización de clientes con diferentes requests y la puesta en cola o el registro de requests. Parametrizar otros objetos con diferentes requests en nuestra analogía significa que el botón que se usa para encender las luces se puede usar más tarde para encender el estéreo o tal vez para abrir la puerta del garaje. Ayuda a promover la «invocación de un método en un objeto» al estado completo del objeto. Básicamente, encapsula toda la información necesaria para realizar una acción o desenstringr un evento.

Problema sin usar el método de comando

Imagina que estás trabajando en un editor de código. Su tarea actual es agregar los nuevos botones en la barra de herramientas del editor para varias operaciones diferentes. Definitivamente es fácil crear una única clase de botón que se pueda usar para los botones. Como sabemos que todos los botones utilizados en el editor tienen un aspecto similar, ¿qué debemos hacer? ¿Deberíamos crear muchas subclases para cada lugar donde se usa el botón?

Problema-sin-Método-de-Comando

Solución usando el método de comando

Echemos un vistazo a la solución para el problema descrito anteriormente. Siempre es una buena idea dividir el software en diferentes capas, lo que ayuda a codificar y depurar fácilmente. El patrón de comando sugiere que los objetos no deberían enviar estas requests directamente. En su lugar, debe extraer todos los detalles de la solicitud, como el objeto al que se llama, el nombre del método y la lista de argumentos en una clase de comando separada con un solo método que activa esta solicitud.

"""Use built-in abc to implement Abstract classes and methods"""
from abc import ABC, abstractmethod
  
"""Class Dedicated to Command"""
class Command(ABC):
      
    """constructor method"""
    def __init__(self, receiver):
        self.receiver = receiver
      
    """process method"""
    def process(self):
        pass
  
"""Class dedicated to Command Implementation"""
class CommandImplementation(Command):
      
    """constructor method"""
    def __init__(self, receiver):
        self.receiver = receiver
  
    """process method"""
    def process(self):
        self.receiver.perform_action()
  
"""Class dedicated to Receiver"""
class Receiver:
      
    """perform-action method"""
    def perform_action(self):
        print('Action performed in receiver.')
  
"""Class dedicated to Invoker"""
class Invoker:
      
    """command method"""
    def command(self, cmd):
        self.cmd = cmd
  
    """execute method"""
    def execute(self):
        self.cmd.process()
  
"""main method"""
if __name__ == "__main__":
      
    """create Receiver object"""
    receiver = Receiver()
    cmd = CommandImplementation(receiver)
    invoker = Invoker()
    invoker.command(cmd)
    invoker.execute()

Producción

Action performed in receiver.

Diagrama de clase

El siguiente es el diagrama de clases para el método Command

Clase-diagrama-comando-método

ventajas 

• Principio Abierto/Cerrado: Podemos introducir los nuevos comandos en la aplicación sin romper el código del cliente existente.
• Principio de responsabilidad única: es realmente fácil desacoplar las clases aquí que invocan operaciones de otras clases.
• UNDO/REDO implementable: Es posible implementar las funcionalidades de UNDO/REDO con la ayuda del método Command.
• Encapsulación: ayuda a encapsular toda la información necesaria para realizar una acción o un evento.

Desventajas

• Aumenta la complejidad: La complejidad del código aumenta a medida que introducimos ciertas capas entre los emisores y los receptores.
• Aumenta la cantidad de clases: Para cada comando individual, aumenta la cantidad de clases.
• Comando Concreto: Cada comando individual es una clase de ComandoConcreto que aumenta el volumen de las clases para implementación y mantenimiento.

Aplicabilidad 

• Implementación de operaciones reversibles: como el método Command proporciona las funcionalidades para las operaciones UNDO/REDO , es posible que podamos invertir las operaciones.
• Parametrización: Siempre es preferible usar el método Comando cuando tenemos que parametrizar los objetos con las operaciones.

Lectura adicional: método de comando en Java