Polecenie w języku Python
Polecenie to behawioralny wzorzec projektowy według którego żądania lub proste działania są konwertowane na obiekty.
Wyżej wymieniona konwersja pozwala odkładać zadania w czasie, uruchamiać je zdalnie, przechowywać ich historię, itp.
Złożoność:
Popularność:
Przykłady użycia: Wzorzec Polecenie jest dość powszechny w kodzie napisanym w Pythonie jako alternatywa dla wywołania zwrotnego (ang. callback) zakładającego przypisanie akcji elementom interfejsu użytkownika. Jest stosowany także w celu kolejkowania zadań, śledzenia historii wykonanych działań, itp.
Identyfikacja: Jeśli widzisz zestaw powiązanych klas odpowiadających konkretnym czynnościom (jak “Kopiuj”, “Wytnij”, “Wyślij”, “Drukuj”, itd.) — może to oznaczać użycie wzorca Polecenie. Takie klasy powinny implementować ten sam interfejs/klasę abstrakcyjną. Polecenia mogą samodzielnie implementować poszczególne czynności lub delegować zadania osobnym obiektom — zwanym odbiorcami. Ostatnim elementem układanki jest znalezienie obiektu wywołującego — będzie to klasa przyjmująca obiekty-polecenia w charakterze parametrów swoich metod lub konstruktora.
Przykład koncepcyjny
Poniższy przykład ilustruje strukturę wzorca Polecenie ze szczególnym naciskiem na następujące kwestie:
- Z jakich składa się klas?
- Jakie role pełnią te klasy?
- W jaki sposób elementy wzorca są ze sobą powiązane?
main.py: Przykład koncepcyjny
from __future__ import annotations from abc import ABC, abstractmethod class Command(ABC): """ The Command interface declares a method for executing a command. """ @abstractmethod def execute(self) -> None: pass class SimpleCommand(Command): """ Some commands can implement simple operations on their own. """ def __init__(self, payload: str) -> None: self._payload = payload def execute(self) -> None: print(f"SimpleCommand: See, I can do simple things like printing" f"({self._payload})") class ComplexCommand(Command): """ However, some commands can delegate more complex operations to other objects, called "receivers." """ def __init__(self, receiver: Receiver, a: str, b: str) -> None: """ Complex commands can accept one or several receiver objects along with any context data via the constructor. """ self._receiver = receiver self._a = a self._b = b def execute(self) -> None: """ Commands can delegate to any methods of a receiver. """ print("ComplexCommand: Complex stuff should be done by a receiver object", end="") self._receiver.do_something(self._a) self._receiver.do_something_else(self._b) class Receiver: """ The Receiver classes contain some important business logic. They know how to perform all kinds of operations, associated with carrying out a request. In fact, any class may serve as a Receiver. """ def do_something(self, a: str) -> None: print(f"\nReceiver: Working on ({a}.)", end="") def do_something_else(self, b: str) -> None: print(f"\nReceiver: Also working on ({b}.)", end="") class Invoker: """ The Invoker is associated with one or several commands. It sends a request to the command. """ _on_start = None _on_finish = None """ Initialize commands. """ def set_on_start(self, command: Command): self._on_start = command def set_on_finish(self, command: Command): self._on_finish = command def do_something_important(self) -> None: """ The Invoker does not depend on concrete command or receiver classes. The Invoker passes a request to a receiver indirectly, by executing a command. """ print("Invoker: Does anybody want something done before I begin?") if isinstance(self._on_start, Command): self._on_start.execute() print("Invoker: ...doing something really important...") print("Invoker: Does anybody want something done after I finish?") if isinstance(self._on_finish, Command): self._on_finish.execute() if __name__ == "__main__": """ The client code can parameterize an invoker with any commands. """ invoker = Invoker() invoker.set_on_start(SimpleCommand("Say Hi!")) receiver = Receiver() invoker.set_on_finish(ComplexCommand( receiver, "Send email", "Save report")) invoker.do_something_important() Output.txt: Wynik działania
Invoker: Does anybody want something done before I begin? SimpleCommand: See, I can do simple things like printing (Say Hi!) Invoker: ...doing something really important... Invoker: Does anybody want something done after I finish? ComplexCommand: Complex stuff should be done by a receiver object Receiver: Working on (Send email.) Receiver: Also working on (Save report.) 
